@aiden-ade/sandbox-agent 0.1.60 → 0.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {

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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,610 +0,0 @@
-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