@aiden-ade/sandbox-agent 0.1.58 → 0.1.60

package/dist/__tests__/binding-switch-git.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=binding-switch-git.test.d.ts.map

package/dist/__tests__/binding-switch-git.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-switch-git.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/binding-switch-git.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/binding-switch-git.test.js

@@ -0,0 +1,610 @@
+import { execFileSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { executeBindingSwitchGitRpc } from "../binding-switch-git.js";
+const tempDirs = [];
+vi.setConfig({ testTimeout: 20_000 });
+function git(cwd, ...args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+}
+function makeTempDir() {
+    const path = mkdtempSync(join(tmpdir(), "alan-binding-switch-git-"));
+    tempDirs.push(path);
+    return path;
+}
+function configureIdentity(repoPath) {
+    git(repoPath, "config", "user.name", "Alan Test");
+    git(repoPath, "config", "user.email", "alan-test@example.com");
+}
+function createRepository(root, name) {
+    const repoPath = join(root, name);
+    mkdirSync(repoPath);
+    git(repoPath, "init", "-b", "main");
+    configureIdentity(repoPath);
+    writeFileSync(join(repoPath, "tracked.txt"), "initial\n");
+    git(repoPath, "add", "tracked.txt");
+    git(repoPath, "commit", "-m", "Initial commit");
+    return repoPath;
+}
+function createRemoteFixture(root) {
+    const remotePath = join(root, "remote.git");
+    mkdirSync(remotePath);
+    git(remotePath, "init", "--bare");
+    git(remotePath, "symbolic-ref", "HEAD", "refs/heads/main");
+    const seedPath = createRepository(root, "seed");
+    git(seedPath, "remote", "add", "origin", remotePath);
+    git(seedPath, "push", "-u", "origin", "main");
+    const mainSha = git(seedPath, "rev-parse", "HEAD");
+    const sourcePath = join(root, "source");
+    const targetPath = join(root, "target");
+    git(root, "clone", remotePath, sourcePath);
+    git(root, "clone", remotePath, targetPath);
+    configureIdentity(sourcePath);
+    configureIdentity(targetPath);
+    return { remotePath, sourcePath, targetPath, mainSha };
+}
+function common(repoPath, suffix = "one") {
+    let expectedRemoteUrl;
+    try {
+        expectedRemoteUrl = git(repoPath, "config", "--get", "remote.origin.url");
+    }
+    catch {
+        expectedRemoteUrl = undefined;
+    }
+    return {
+        switchId: `switch-${suffix}`,
+        repoKey: `repo-${suffix}`,
+        repoPath,
+        projectPath: repoPath,
+        expectedRepoRoot: repoPath,
+        expectedRemoteUrl,
+        expectedBranch: git(repoPath, "branch", "--show-current"),
+    };
+}
+async function waitForPath(path, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (!existsSync(path)) {
+        if (Date.now() >= deadline)
+            throw new Error(`Timed out waiting for ${path}`);
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, 20));
+    }
+}
+afterEach(() => {
+    for (const path of tempDirs.splice(0))
+        rmSync(path, { recursive: true, force: true });
+});
+describe("binding-switch git RPC", () => {
+    it("reports and verifies the repository fetch remote during status inspection", async () => {
+        const root = makeTempDir();
+        const { remotePath, sourcePath } = createRemoteFixture(root);
+        await expect(executeBindingSwitchGitRpc("git.status", common(sourcePath))).resolves.toMatchObject({
+            repoRoot: sourcePath,
+            remoteUrl: remotePath,
+            branch: "main",
+            dirty: false,
+        });
+    });
+    it("rejects a mismatched expected remote during status inspection", async () => {
+        const root = makeTempDir();
+        const { sourcePath } = createRemoteFixture(root);
+        const otherRemote = join(root, "other.git");
+        mkdirSync(otherRemote);
+        git(otherRemote, "init", "--bare");
+        await expect(executeBindingSwitchGitRpc("git.status", {
+            ...common(sourcePath, "status-remote-mismatch"),
+            expectedRemoteUrl: otherRemote,
+        })).rejects.toMatchObject({ code: "remote_url_mismatch" });
+    });
+    it("reports a missing remote without weakening repository path authorization", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "repo-without-remote");
+        const { expectedRemoteUrl: _expectedRemoteUrl, ...request } = common(repoPath, "status-no-remote");
+        await expect(executeBindingSwitchGitRpc("git.status", request)).resolves.toMatchObject({
+            repoRoot: repoPath,
+            remoteUrl: null,
+        });
+    });
+    it("rejects credential-bearing remotes during status inspection", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "repo-with-credential-remote");
+        git(repoPath, "remote", "add", "origin", "https://user:secret@example.invalid/owner/repo.git");
+        const { expectedRemoteUrl: _expectedRemoteUrl, ...request } = common(repoPath, "status-credential-remote");
+        await expect(executeBindingSwitchGitRpc("git.status", request)).rejects.toMatchObject({
+            code: "remote_url_credentials_rejected",
+        });
+    });
+    it("creates one guarded checkpoint and replays it by switch/repository trailers", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "repo");
+        const originalHead = git(repoPath, "rev-parse", "HEAD");
+        writeFileSync(join(repoPath, "tracked.txt"), "checkpointed\n");
+        writeFileSync(join(repoPath, "untracked.txt"), "new\n");
+        const status = (await executeBindingSwitchGitRpc("git.status", common(repoPath)));
+        expect(status).toMatchObject({
+            headSha: originalHead,
+            dirty: true,
+            filesChanged: 2,
+        });
+        expect(status.statusFingerprint).toMatch(/^[0-9a-f]{64}$/);
+        const request = {
+            ...common(repoPath),
+            expectedHeadSha: originalHead,
+            expectedStatusFingerprint: status.statusFingerprint,
+            expectedProposedTreeSha: status.proposedTreeSha,
+            commitMessage: "chore: checkpoint work before environment switch\n\nCo-Authored-By: Alan <agent@tryalan.ai>",
+            authorName: "Siddharth Talesara",
+            authorEmail: "siddharth@example.com",
+        };
+        const first = (await executeBindingSwitchGitRpc("git.checkpoint", request));
+        expect(first.replayed).toBe(false);
+        expect(first.sha).not.toBe(originalHead);
+        expect(git(repoPath, "show", "-s", "--format=%B", "HEAD")).toContain("Alan-Switch-Id: switch-one");
+        expect(git(repoPath, "show", "-s", "--format=%B", "HEAD")).toContain("Alan-Repository-Id: repo-one");
+        expect(git(repoPath, "show", "-s", "--format=%B", "HEAD")).toContain("Co-Authored-By: Alan <agent@tryalan.ai>");
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", request)).resolves.toMatchObject({
+            sha: first.sha,
+            replayed: true,
+        });
+        writeFileSync(join(repoPath, "tracked.txt"), "changed after checkpoint\n");
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", request)).resolves.toMatchObject({
+            sha: first.sha,
+            replayed: true,
+        });
+        expect(git(repoPath, "status", "--porcelain")).toContain("tracked.txt");
+    });
+    it("invalidates approval when bytes change at the same tracked or untracked path", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "repo");
+        writeFileSync(join(repoPath, "tracked.txt"), "first tracked bytes\n");
+        writeFileSync(join(repoPath, "untracked.txt"), "first untracked bytes\n");
+        const first = (await executeBindingSwitchGitRpc("git.status", common(repoPath)));
+        writeFileSync(join(repoPath, "tracked.txt"), "second tracked bytes\n");
+        writeFileSync(join(repoPath, "untracked.txt"), "second untracked bytes\n");
+        const second = (await executeBindingSwitchGitRpc("git.status", common(repoPath)));
+        expect(second.statusFingerprint).not.toBe(first.statusFingerprint);
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", {
+            ...common(repoPath),
+            expectedHeadSha: first.headSha,
+            expectedStatusFingerprint: first.statusFingerprint,
+            expectedProposedTreeSha: first.proposedTreeSha,
+            commitMessage: "checkpoint",
+            authorName: "Alan",
+            authorEmail: "agent@tryalan.ai",
+        })).rejects.toMatchObject({ code: "source_changed_since_approval" });
+    });
+    it("commits only the approved proposed tree when bytes change during preparation", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "checkpoint-race");
+        writeFileSync(join(repoPath, "tracked.txt"), "approved checkpoint bytes\n");
+        const inspected = (await executeBindingSwitchGitRpc("git.status", common(repoPath, "checkpoint-race")));
+        const barrierDir = join(root, "checkpoint-barrier");
+        const previousBarrier = process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR;
+        process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR = barrierDir;
+        try {
+            const checkpointPromise = executeBindingSwitchGitRpc("git.checkpoint", {
+                ...common(repoPath, "checkpoint-race"),
+                expectedHeadSha: inspected.headSha,
+                expectedStatusFingerprint: inspected.statusFingerprint,
+                expectedProposedTreeSha: inspected.proposedTreeSha,
+                commitMessage: "approved checkpoint",
+                authorName: "Alan",
+                authorEmail: "agent@tryalan.ai",
+            });
+            await waitForPath(join(barrierDir, "ready"));
+            writeFileSync(join(repoPath, "tracked.txt"), "post-approval bytes\n");
+            writeFileSync(join(barrierDir, "release"), "release\n");
+            const result = (await checkpointPromise);
+            expect(result.replayed).toBe(false);
+            expect(git(repoPath, "rev-parse", `${result.sha}^{tree}`)).toBe(inspected.proposedTreeSha);
+            expect(git(repoPath, "show", `${result.sha}:tracked.txt`)).toBe("approved checkpoint bytes");
+            expect(git(repoPath, "status", "--porcelain")).toContain("tracked.txt");
+        }
+        finally {
+            mkdirSync(barrierDir, { recursive: true });
+            writeFileSync(join(barrierDir, "release"), "release\n");
+            if (previousBarrier === undefined) {
+                delete process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR;
+            }
+            else {
+                process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR = previousBarrier;
+            }
+        }
+    });
+    it("leaves both branches and the new branch index intact when HEAD changes during finalization", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "checkpoint-branch-race");
+        const originalHead = git(repoPath, "rev-parse", "HEAD");
+        git(repoPath, "branch", "other-checkpoint", originalHead);
+        writeFileSync(join(repoPath, "tracked.txt"), "approved checkpoint bytes\n");
+        const inspected = (await executeBindingSwitchGitRpc("git.status", common(repoPath, "checkpoint-branch-race")));
+        const barrierDir = join(root, "checkpoint-finalize-barrier");
+        const previousBarrier = process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR;
+        process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR = barrierDir;
+        try {
+            const checkpointPromise = executeBindingSwitchGitRpc("git.checkpoint", {
+                ...common(repoPath, "checkpoint-branch-race"),
+                expectedHeadSha: inspected.headSha,
+                expectedStatusFingerprint: inspected.statusFingerprint,
+                expectedProposedTreeSha: inspected.proposedTreeSha,
+                commitMessage: "approved checkpoint",
+                authorName: "Alan",
+                authorEmail: "agent@tryalan.ai",
+            });
+            await waitForPath(join(barrierDir, "ready"));
+            git(repoPath, "switch", "other-checkpoint");
+            writeFileSync(join(barrierDir, "release"), "release\n");
+            await expect(checkpointPromise).rejects.toMatchObject({
+                code: "source_changed_since_approval",
+            });
+            expect(git(repoPath, "rev-parse", "refs/heads/main")).toBe(originalHead);
+            expect(git(repoPath, "rev-parse", "refs/heads/other-checkpoint")).toBe(originalHead);
+            expect(git(repoPath, "branch", "--show-current")).toBe("other-checkpoint");
+            expect(git(repoPath, "rev-parse", "HEAD")).toBe(originalHead);
+            expect(git(repoPath, "diff", "--cached", "--name-only")).toBe("");
+            expect(git(repoPath, "status", "--porcelain")).toBe("M tracked.txt");
+            expect(readFileSync(join(repoPath, "tracked.txt"), "utf8")).toBe("approved checkpoint bytes\n");
+        }
+        finally {
+            mkdirSync(barrierDir, { recursive: true });
+            writeFileSync(join(barrierDir, "release"), "release\n");
+            if (previousBarrier === undefined) {
+                delete process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR;
+            }
+            else {
+                process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR = previousBarrier;
+            }
+        }
+    });
+    it("rejects checkpoint and push when the branch changes at the same HEAD", async () => {
+        const root = makeTempDir();
+        const checkpointRepo = createRepository(root, "checkpoint");
+        writeFileSync(join(checkpointRepo, "tracked.txt"), "dirty on main\n");
+        const inspected = (await executeBindingSwitchGitRpc("git.status", common(checkpointRepo, "same-sha-checkpoint")));
+        git(checkpointRepo, "switch", "-c", "other-checkpoint");
+        expect(git(checkpointRepo, "rev-parse", "HEAD")).toBe(inspected.headSha);
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", {
+            ...common(checkpointRepo, "same-sha-checkpoint"),
+            expectedBranch: "main",
+            expectedHeadSha: inspected.headSha,
+            expectedStatusFingerprint: inspected.statusFingerprint,
+            expectedProposedTreeSha: inspected.proposedTreeSha,
+            commitMessage: "must not commit another branch",
+            authorName: "Alan",
+            authorEmail: "agent@tryalan.ai",
+        })).rejects.toMatchObject({ code: "source_changed_since_approval" });
+        const { sourcePath } = createRemoteFixture(root);
+        const approvedHead = git(sourcePath, "rev-parse", "HEAD");
+        git(sourcePath, "switch", "-c", "other-push");
+        expect(git(sourcePath, "rev-parse", "HEAD")).toBe(approvedHead);
+        await expect(executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "same-sha-push"),
+            expectedBranch: "main",
+            expectedHeadSha: approvedHead,
+            branch: "main",
+        })).rejects.toMatchObject({ code: "source_changed_since_approval" });
+    });
+    it("publishes the source branch and lands a different bootstrap checkout at the exact SHA", async () => {
+        const root = makeTempDir();
+        const { remotePath, sourcePath, targetPath } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/migrate");
+        writeFileSync(join(sourcePath, "tracked.txt"), "source task work\n");
+        git(sourcePath, "commit", "-am", "Task work");
+        const pushedSha = git(sourcePath, "rev-parse", "HEAD");
+        expect(await executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath),
+            expectedHeadSha: pushedSha,
+            branch: "task/migrate",
+            expectedRemoteUrl: `file://${remotePath}`,
+        })).toMatchObject({
+            pushedSha,
+            branch: "task/migrate",
+            replayed: false,
+        });
+        expect(git(targetPath, "branch", "--show-current")).toBe("main");
+        const prepared = await executeBindingSwitchGitRpc("git.prepare_checkout", {
+            ...common(targetPath),
+            branch: "task/migrate",
+            targetSha: pushedSha,
+        });
+        expect(prepared).toMatchObject({
+            path: targetPath,
+            branch: "task/migrate",
+            headSha: pushedSha,
+            replayed: false,
+        });
+        expect(git(targetPath, "branch", "--show-current")).toBe("task/migrate");
+        expect(git(targetPath, "rev-parse", "HEAD")).toBe(pushedSha);
+        expect(await executeBindingSwitchGitRpc("git.prepare_checkout", {
+            ...common(targetPath),
+            branch: "task/migrate",
+            targetSha: pushedSha,
+        })).toMatchObject({ headSha: pushedSha, replayed: true });
+        expect(await executeBindingSwitchGitRpc("git.verify_head", {
+            ...common(targetPath),
+            expectedSha: pushedSha,
+        })).toMatchObject({ headSha: pushedSha, verified: true });
+    });
+    it("rejects verification of a dirty target even when HEAD is exact", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "dirty-verify");
+        const expectedSha = git(repoPath, "rev-parse", "HEAD");
+        writeFileSync(join(repoPath, "late-target-edit.txt"), "must block verification\n");
+        await expect(executeBindingSwitchGitRpc("git.verify_head", {
+            ...common(repoPath, "dirty-verify"),
+            expectedSha,
+        })).rejects.toMatchObject({ code: "target_checkout_dirty" });
+    }, 60_000);
+    it("fetches and creates an Alan-managed worktree at the published SHA", async () => {
+        const root = makeTempDir();
+        const { sourcePath, targetPath } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/worktree");
+        writeFileSync(join(sourcePath, "tracked.txt"), "worktree work\n");
+        git(sourcePath, "commit", "-am", "Worktree task");
+        const pushedSha = git(sourcePath, "rev-parse", "HEAD");
+        await executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "worktree"),
+            expectedHeadSha: pushedSha,
+            branch: "task/worktree",
+        });
+        const managedRoot = join(dirname(targetPath), `${basename(targetPath)}-alan-worktrees`);
+        const worktreePath = join(managedRoot, "switch-worktree", "repo");
+        expect(await executeBindingSwitchGitRpc("git.prepare_worktree", {
+            ...common(targetPath, "worktree"),
+            worktreePath,
+            branch: "task/worktree",
+            targetSha: pushedSha,
+        })).toMatchObject({
+            path: worktreePath,
+            branch: "task/worktree",
+            headSha: pushedSha,
+            replayed: false,
+        });
+        expect(git(worktreePath, "rev-parse", "HEAD")).toBe(pushedSha);
+        expect(await executeBindingSwitchGitRpc("git.prepare_worktree", {
+            ...common(targetPath, "worktree"),
+            worktreePath,
+            branch: "task/worktree",
+            targetSha: pushedSha,
+        })).toMatchObject({ headSha: pushedSha, replayed: true });
+    });
+    it("rejects an arbitrary repository root even when its path is otherwise valid", async () => {
+        const root = makeTempDir();
+        const trustedProject = createRepository(root, "trusted");
+        const arbitraryRepo = createRepository(root, "arbitrary");
+        writeFileSync(join(arbitraryRepo, "tracked.txt"), "arbitrary dirt\n");
+        const status = (await executeBindingSwitchGitRpc("git.status", common(arbitraryRepo, "arbitrary")));
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", {
+            ...common(arbitraryRepo, "arbitrary"),
+            projectPath: trustedProject,
+            expectedRepoRoot: arbitraryRepo,
+            expectedHeadSha: status.headSha,
+            expectedStatusFingerprint: status.statusFingerprint,
+            expectedProposedTreeSha: status.proposedTreeSha,
+            commitMessage: "must not commit",
+            authorName: "Alan",
+            authorEmail: "agent@tryalan.ai",
+        })).rejects.toMatchObject({ code: "repository_path_not_authorized" });
+        expect(git(arbitraryRepo, "status", "--porcelain")).not.toBe("");
+    });
+    it("rejects a mismatched remote before contacting either repository", async () => {
+        const root = makeTempDir();
+        const { sourcePath, remotePath } = createRemoteFixture(root);
+        const otherRemote = join(root, "other.git");
+        mkdirSync(otherRemote);
+        git(otherRemote, "init", "--bare");
+        git(sourcePath, "switch", "-c", "task/remote-guard");
+        writeFileSync(join(sourcePath, "tracked.txt"), "guarded work\n");
+        git(sourcePath, "commit", "-am", "Guarded work");
+        const expectedHeadSha = git(sourcePath, "rev-parse", "HEAD");
+        await expect(executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "remote-guard"),
+            expectedHeadSha,
+            branch: "task/remote-guard",
+            expectedRemoteUrl: otherRemote,
+        })).rejects.toMatchObject({ code: "remote_url_mismatch" });
+        expect(git(remotePath, "for-each-ref", "--format=%(refname)", "refs/heads/task/remote-guard")).toBe("");
+        expect(git(otherRemote, "for-each-ref", "--format=%(refname)", "refs/heads/task/remote-guard")).toBe("");
+    });
+    it("rejects an Alan worktree path whose symlinked ancestor escapes the managed root", async () => {
+        const root = makeTempDir();
+        const { sourcePath, targetPath } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/symlink");
+        writeFileSync(join(sourcePath, "tracked.txt"), "symlink guarded\n");
+        git(sourcePath, "commit", "-am", "Symlink work");
+        const pushedSha = git(sourcePath, "rev-parse", "HEAD");
+        await executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "symlink"),
+            expectedHeadSha: pushedSha,
+            branch: "task/symlink",
+        });
+        const managedRoot = join(dirname(targetPath), `${basename(targetPath)}-alan-worktrees`);
+        const outsideRoot = join(root, "outside");
+        mkdirSync(managedRoot);
+        mkdirSync(outsideRoot);
+        symlinkSync(outsideRoot, join(managedRoot, "escape"));
+        await expect(executeBindingSwitchGitRpc("git.prepare_worktree", {
+            ...common(targetPath, "symlink"),
+            worktreePath: join(managedRoot, "escape", "task"),
+            branch: "task/symlink",
+            targetSha: pushedSha,
+        })).rejects.toMatchObject({ code: "worktree_path_not_authorized" });
+        expect(existsSync(join(outsideRoot, ".git"))).toBe(false);
+        rmSync(managedRoot, { recursive: true });
+        symlinkSync(outsideRoot, managedRoot);
+        await expect(executeBindingSwitchGitRpc("git.prepare_worktree", {
+            ...common(targetPath, "symlink"),
+            worktreePath: join(managedRoot, "task"),
+            branch: "task/symlink",
+            targetSha: pushedSha,
+        })).rejects.toMatchObject({ code: "worktree_path_not_authorized" });
+        expect(existsSync(join(outsideRoot, ".git"))).toBe(false);
+    });
+    it("cancels a hung network operation without letting its child finish later", async () => {
+        const root = makeTempDir();
+        const repoPath = createRepository(root, "repo");
+        git(repoPath, "switch", "-c", "task/timeout");
+        const markerPath = join(root, "network-finished");
+        const fakeBin = join(root, "fake-bin");
+        mkdirSync(fakeBin);
+        const sshScript = join(fakeBin, "ssh");
+        writeFileSync(sshScript, `#!/bin/sh\nsleep 2\nprintf finished > '${markerPath}'\nexit 1\n`);
+        chmodSync(sshScript, 0o755);
+        const remoteUrl = "ssh://git@example.invalid/owner/repo.git";
+        git(repoPath, "remote", "add", "origin", remoteUrl);
+        const previousSshCommand = process.env.ALAN_TEST_GIT_SSH_COMMAND;
+        const previousTimeout = process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS;
+        process.env.ALAN_TEST_GIT_SSH_COMMAND = sshScript;
+        process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS = "100";
+        try {
+            await expect(executeBindingSwitchGitRpc("git.push", {
+                ...common(repoPath, "timeout"),
+                expectedHeadSha: git(repoPath, "rev-parse", "HEAD"),
+                branch: "task/timeout",
+                expectedRemoteUrl: "https://example.invalid/owner/repo.git",
+            })).rejects.toMatchObject({ code: "git_network_timeout" });
+            await new Promise((resolvePromise) => setTimeout(resolvePromise, 500));
+            expect(existsSync(markerPath)).toBe(false);
+        }
+        finally {
+            if (previousSshCommand === undefined)
+                delete process.env.ALAN_TEST_GIT_SSH_COMMAND;
+            else
+                process.env.ALAN_TEST_GIT_SSH_COMMAND = previousSshCommand;
+            if (previousTimeout === undefined)
+                delete process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS;
+            else
+                process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS = previousTimeout;
+        }
+    });
+    it("preserves published SHA evidence when the source changes during push", async () => {
+        const root = makeTempDir();
+        const { remotePath, sourcePath } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/push-race");
+        writeFileSync(join(sourcePath, "tracked.txt"), "approved work\n");
+        git(sourcePath, "commit", "-am", "Approved work");
+        const approvedSha = git(sourcePath, "rev-parse", "HEAD");
+        const readyPath = join(root, "push-ready");
+        const releasePath = join(root, "push-release");
+        const sshScript = join(root, "blocking-ssh.sh");
+        writeFileSync(sshScript, [
+            "#!/bin/sh",
+            'if [ "$1" = "-G" ]; then exit 0; fi',
+            'command=""',
+            'for argument in "$@"; do command="$argument"; done',
+            `case "$command" in *git-receive-pack*) touch '${readyPath}'; while [ ! -f '${releasePath}' ]; do sleep 0.02; done ;; esac`,
+            'exec /bin/sh -c "$command"',
+            "",
+        ].join("\n"));
+        chmodSync(sshScript, 0o755);
+        const remoteUrl = `ssh://git@localhost${remotePath}`;
+        git(sourcePath, "remote", "set-url", "origin", remoteUrl);
+        const previousSshCommand = process.env.ALAN_TEST_GIT_SSH_COMMAND;
+        process.env.ALAN_TEST_GIT_SSH_COMMAND = sshScript;
+        try {
+            const pushPromise = executeBindingSwitchGitRpc("git.push", {
+                ...common(sourcePath, "push-race"),
+                expectedHeadSha: approvedSha,
+                expectedBranch: "task/push-race",
+                branch: "task/push-race",
+                expectedRemoteUrl: remoteUrl,
+            });
+            await waitForPath(readyPath);
+            writeFileSync(join(sourcePath, "tracked.txt"), "committed work changed during push\n");
+            git(sourcePath, "commit", "-am", "Late local commit");
+            const lateSha = git(sourcePath, "rev-parse", "HEAD");
+            expect(lateSha).not.toBe(approvedSha);
+            writeFileSync(releasePath, "release\n");
+            await expect(pushPromise).rejects.toMatchObject({
+                code: "source_changed_since_approval",
+                details: {
+                    published: {
+                        pushedSha: approvedSha,
+                        branch: "task/push-race",
+                        remote: "origin",
+                        replayed: false,
+                    },
+                },
+            });
+            expect(git(remotePath, "rev-parse", "refs/heads/task/push-race")).toBe(approvedSha);
+            expect(git(sourcePath, "rev-parse", "HEAD")).toBe(lateSha);
+            expect(git(sourcePath, "status", "--porcelain")).toBe("");
+        }
+        finally {
+            writeFileSync(releasePath, "release\n");
+            if (previousSshCommand === undefined)
+                delete process.env.ALAN_TEST_GIT_SSH_COMMAND;
+            else
+                process.env.ALAN_TEST_GIT_SSH_COMMAND = previousSshCommand;
+        }
+    });
+    it("rejects stale status approval and a fetched branch at the wrong SHA", async () => {
+        const root = makeTempDir();
+        const { sourcePath, targetPath, mainSha } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/stale");
+        writeFileSync(join(sourcePath, "tracked.txt"), "dirty\n");
+        const status = (await executeBindingSwitchGitRpc("git.status", common(sourcePath, "stale")));
+        writeFileSync(join(sourcePath, "another.txt"), "raced\n");
+        await expect(executeBindingSwitchGitRpc("git.checkpoint", {
+            ...common(sourcePath, "stale"),
+            expectedHeadSha: status.headSha,
+            expectedStatusFingerprint: status.statusFingerprint,
+            expectedProposedTreeSha: status.proposedTreeSha,
+            commitMessage: "checkpoint",
+            authorName: "Alan",
+            authorEmail: "agent@tryalan.ai",
+        })).rejects.toThrowError(expect.objectContaining({
+            code: "source_changed_since_approval",
+        }));
+        git(sourcePath, "add", "--all");
+        git(sourcePath, "commit", "-m", "Published task work");
+        const taskSha = git(sourcePath, "rev-parse", "HEAD");
+        await executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "stale"),
+            expectedHeadSha: taskSha,
+            branch: "task/stale",
+        });
+        await expect(executeBindingSwitchGitRpc("git.fetch", {
+            ...common(targetPath, "stale"),
+            branch: "task/stale",
+            expectedSha: mainSha,
+        })).rejects.toThrowError(expect.objectContaining({
+            code: "target_sha_mismatch",
+        }));
+    });
+    it("never fast-forwards a dirty or divergent shared checkout", async () => {
+        const root = makeTempDir();
+        const { sourcePath, targetPath } = createRemoteFixture(root);
+        git(sourcePath, "switch", "-c", "task/safe");
+        writeFileSync(join(sourcePath, "tracked.txt"), "remote task work\n");
+        git(sourcePath, "commit", "-am", "Remote task work");
+        const pushedSha = git(sourcePath, "rev-parse", "HEAD");
+        await executeBindingSwitchGitRpc("git.push", {
+            ...common(sourcePath, "safe"),
+            expectedHeadSha: pushedSha,
+            branch: "task/safe",
+        });
+        writeFileSync(join(targetPath, "dirty.txt"), "local dirt\n");
+        await expect(executeBindingSwitchGitRpc("git.prepare_checkout", {
+            ...common(targetPath, "safe"),
+            branch: "task/safe",
+            targetSha: pushedSha,
+        })).rejects.toThrowError(expect.objectContaining({
+            code: "target_checkout_dirty",
+        }));
+        rmSync(join(targetPath, "dirty.txt"));
+        git(targetPath, "switch", "-c", "task/safe");
+        writeFileSync(join(targetPath, "local.txt"), "divergent\n");
+        git(targetPath, "add", "local.txt");
+        git(targetPath, "commit", "-m", "Local divergent work");
+        await expect(executeBindingSwitchGitRpc("git.prepare_checkout", {
+            ...common(targetPath, "safe"),
+            branch: "task/safe",
+            targetSha: pushedSha,
+        })).rejects.toThrowError(expect.objectContaining({
+            code: "target_branch_diverged",
+        }));
+    });
+});
+//# sourceMappingURL=binding-switch-git.test.js.map