@aiden-ade/sandbox-agent 0.1.60 → 0.1.62

package/dist/binding-switch-git.js

@@ -1,973 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-import { getDaemonCliEnvironment } from "./cli-executable.js";
-export const BINDING_SWITCH_GIT_METHODS = [
-    "git.status",
-    "git.checkpoint",
-    "git.push",
-    "git.fetch",
-    "git.prepare_checkout",
-    "git.prepare_worktree",
-    "git.verify_head",
-];
-export function isBindingSwitchGitMethod(method) {
-    return BINDING_SWITCH_GIT_METHODS.includes(method);
-}
-export class BindingSwitchGitError extends Error {
-    code;
-    details;
-    constructor(code, message, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = "BindingSwitchGitError";
-    }
-}
-const LOCAL_GIT_TIMEOUT_MS = 10_000;
-const NETWORK_GIT_TIMEOUT_MS = 30_000;
-const MAX_GIT_OUTPUT_BYTES = 10 * 1024 * 1024;
-function runGitResult(cwd, args, options = {}) {
-    const result = spawnSync("git", args, {
-        cwd,
-        env: { ...getDaemonCliEnvironment(), ...options.env },
-        encoding: "utf8",
-        input: options.input,
-        maxBuffer: MAX_GIT_OUTPUT_BYTES,
-        timeout: LOCAL_GIT_TIMEOUT_MS,
-    });
-    if (result.error) {
-        return { status: 1, stdout: "", stderr: result.error.message };
-    }
-    return {
-        status: result.status ?? 1,
-        stdout: result.stdout ?? "",
-        stderr: result.stderr ?? "",
-    };
-}
-function networkGitTimeoutMs() {
-    if (process.env.NODE_ENV !== "test")
-        return NETWORK_GIT_TIMEOUT_MS;
-    const override = Number.parseInt(process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS ?? "", 10);
-    return Number.isFinite(override) && override >= 10
-        ? Math.min(override, NETWORK_GIT_TIMEOUT_MS)
-        : NETWORK_GIT_TIMEOUT_MS;
-}
-async function waitForCheckpointTestBarrier() {
-    const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR : undefined;
-    if (!barrierDir)
-        return;
-    mkdirSync(barrierDir, { recursive: true });
-    const readyPath = join(barrierDir, "ready");
-    const releasePath = join(barrierDir, "release");
-    writeFileSync(readyPath, "ready\n");
-    const deadline = Date.now() + 5_000;
-    while (!existsSync(releasePath)) {
-        if (Date.now() >= deadline) {
-            throw new BindingSwitchGitError("checkpoint_prepare_timeout", "Checkpoint preparation test barrier timed out");
-        }
-        await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
-    }
-}
-async function waitForCheckpointFinalizeTestBarrier() {
-    const barrierDir = process.env.NODE_ENV === "test"
-        ? process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR
-        : undefined;
-    if (!barrierDir)
-        return;
-    mkdirSync(barrierDir, { recursive: true });
-    const readyPath = join(barrierDir, "ready");
-    const releasePath = join(barrierDir, "release");
-    writeFileSync(readyPath, "ready\n");
-    const deadline = Date.now() + 5_000;
-    while (!existsSync(releasePath)) {
-        if (Date.now() >= deadline) {
-            throw new BindingSwitchGitError("checkpoint_finalize_timeout", "Checkpoint finalization test barrier timed out");
-        }
-        await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
-    }
-}
-async function runNetworkGit(cwd, args, code) {
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn("git", args, {
-            cwd,
-            env: {
-                ...getDaemonCliEnvironment(),
-                GCM_INTERACTIVE: "Never",
-                GIT_TERMINAL_PROMPT: "0",
-                ...(process.env.NODE_ENV === "test" && process.env.ALAN_TEST_GIT_SSH_COMMAND
-                    ? { GIT_SSH_COMMAND: process.env.ALAN_TEST_GIT_SSH_COMMAND }
-                    : {}),
-            },
-            detached: process.platform !== "win32",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let outputExceeded = false;
-        let timedOut = false;
-        let settled = false;
-        const killTree = () => {
-            if (child.pid && process.platform !== "win32") {
-                try {
-                    process.kill(-child.pid, "SIGKILL");
-                    return;
-                }
-                catch {
-                    // The process may already have exited between the timeout and kill.
-                }
-            }
-            child.kill("SIGKILL");
-        };
-        const timer = setTimeout(() => {
-            timedOut = true;
-            killTree();
-        }, networkGitTimeoutMs());
-        timer.unref?.();
-        const append = (current, chunk) => {
-            if (Buffer.byteLength(current) + chunk.byteLength > MAX_GIT_OUTPUT_BYTES) {
-                outputExceeded = true;
-                killTree();
-                return current;
-            }
-            return current + chunk.toString("utf8");
-        };
-        child.stdout.on("data", (chunk) => {
-            stdout = append(stdout, chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = append(stderr, chunk);
-        });
-        child.once("error", (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            rejectPromise(new BindingSwitchGitError(code, error.message));
-        });
-        child.once("close", (exitCode) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            if (timedOut) {
-                rejectPromise(new BindingSwitchGitError("git_network_timeout", "The Git network operation timed out and was cancelled"));
-                return;
-            }
-            if (outputExceeded) {
-                rejectPromise(new BindingSwitchGitError("git_output_limit_exceeded", "The Git network operation produced too much output and was cancelled"));
-                return;
-            }
-            if (exitCode !== 0) {
-                rejectPromise(new BindingSwitchGitError(code, (stderr || stdout || "Git network command failed").trim()));
-                return;
-            }
-            resolvePromise(stdout.trim());
-        });
-    });
-}
-function runGit(cwd, args, code = "git_operation_failed") {
-    return runGitWithOptions(cwd, args, {}, code);
-}
-function runGitWithOptions(cwd, args, options, code = "git_operation_failed") {
-    const result = runGitResult(cwd, args, options);
-    if (result.status !== 0) {
-        throw new BindingSwitchGitError(code, (result.stderr || result.stdout || "Git command failed").trim());
-    }
-    return result.stdout.trim();
-}
-function sourceChangedDuringCheckpoint(message) {
-    return new BindingSwitchGitError("source_changed_since_approval", message);
-}
-function acquireCheckpointHeadLock(locks) {
-    try {
-        writeFileSync(locks.headLockPath, "", { flag: "wx" });
-        locks.headLockHeld = true;
-    }
-    catch {
-        throw sourceChangedDuringCheckpoint("Source repository is being changed by another Git operation");
-    }
-}
-function releaseCheckpointHeadLock(locks) {
-    if (!locks.headLockHeld)
-        return;
-    rmSync(locks.headLockPath, { force: true });
-    locks.headLockHeld = false;
-}
-function acquireCheckpointRepositoryLocks(repoRoot) {
-    const gitDir = runGit(repoRoot, ["rev-parse", "--absolute-git-dir"], "checkpoint_lock_unavailable");
-    const indexPath = runGit(repoRoot, ["rev-parse", "--path-format=absolute", "--git-path", "index"], "checkpoint_lock_unavailable");
-    const locks = {
-        headLockPath: join(gitDir, "HEAD.lock"),
-        headLockHeld: false,
-        indexLockPath: `${indexPath}.lock`,
-        indexLockHeld: false,
-        indexPath,
-    };
-    try {
-        writeFileSync(locks.indexLockPath, "", { flag: "wx" });
-        locks.indexLockHeld = true;
-        acquireCheckpointHeadLock(locks);
-        return locks;
-    }
-    catch {
-        if (locks.indexLockHeld) {
-            rmSync(locks.indexLockPath, { force: true });
-            locks.indexLockHeld = false;
-        }
-        throw sourceChangedDuringCheckpoint("Source repository is being changed by another Git operation");
-    }
-}
-function releaseCheckpointRepositoryLocks(locks) {
-    releaseCheckpointHeadLock(locks);
-    if (locks.indexLockHeld) {
-        rmSync(locks.indexLockPath, { force: true });
-        locks.indexLockHeld = false;
-    }
-}
-function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
-    const currentRef = runGit(repoRoot, ["symbolic-ref", "-q", "HEAD"], "source_changed_since_approval");
-    const currentHead = runGit(repoRoot, ["rev-parse", "HEAD"], "source_changed_since_approval");
-    if (currentRef !== expectedRef || currentHead !== expectedHeadSha) {
-        throw sourceChangedDuringCheckpoint("Source HEAD or branch changed during checkpoint finalization");
-    }
-}
-function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
-    const tempDir = mkdtempSync(join(tmpdir(), "alan-checkpoint-index-"));
-    const indexPath = join(tempDir, "index");
-    try {
-        runGitWithOptions(repoRoot, ["read-tree", checkpointSha], { env: { GIT_INDEX_FILE: indexPath } }, "checkpoint_index_sync_failed");
-        return { indexPath, tempDir };
-    }
-    catch (error) {
-        rmSync(tempDir, { recursive: true, force: true });
-        throw error;
-    }
-}
-function installCheckpointIndexBaseline(locks, baselineIndexPath) {
-    try {
-        copyFileSync(baselineIndexPath, locks.indexLockPath);
-        renameSync(locks.indexLockPath, locks.indexPath);
-        locks.indexLockHeld = false;
-    }
-    catch (error) {
-        throw new BindingSwitchGitError("checkpoint_index_sync_failed", error instanceof Error ? error.message : "The checkpoint index could not be installed");
-    }
-}
-function requiredString(params, key) {
-    const value = params[key];
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new BindingSwitchGitError("invalid_git_request", `${key} is required`);
-    }
-    if (/[\0\r\n]/.test(value)) {
-        throw new BindingSwitchGitError("invalid_git_request", `${key} contains unsafe characters`);
-    }
-    return value;
-}
-function requiredCommitMessage(params) {
-    const value = params.commitMessage;
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new BindingSwitchGitError("invalid_git_request", "commitMessage is required");
-    }
-    // Commit messages are passed to `git commit-tree` through stdin, not a shell
-    // argument. Newlines are both safe and required for trailers such as
-    // Co-Authored-By; only NUL cannot be represented safely in Git commit text.
-    if (value.includes("\0")) {
-        throw new BindingSwitchGitError("invalid_git_request", "commitMessage contains unsafe characters");
-    }
-    return value;
-}
-function optionalString(params, key) {
-    const value = params[key];
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "string" || value.trim() === "" || /[\0\r\n]/.test(value)) {
-        throw new BindingSwitchGitError("invalid_git_request", `${key} is invalid`);
-    }
-    return value;
-}
-function commonRequest(params) {
-    return {
-        switchId: requiredString(params, "switchId"),
-        repoKey: requiredString(params, "repoKey"),
-        repoPath: resolve(requiredString(params, "repoPath")),
-    };
-}
-function assertCommitSha(sha, key) {
-    if (!/^[0-9a-f]{40,64}$/i.test(sha)) {
-        throw new BindingSwitchGitError("invalid_git_request", `${key} is not a commit SHA`);
-    }
-}
-function assertValidBranch(branch) {
-    if (branch.startsWith("-")) {
-        throw new BindingSwitchGitError("invalid_git_request", "branch is not a safe Git ref");
-    }
-    const result = spawnSync("git", ["check-ref-format", "--branch", branch], {
-        env: getDaemonCliEnvironment(),
-        encoding: "utf8",
-    });
-    if (result.status !== 0) {
-        throw new BindingSwitchGitError("invalid_git_request", "branch is not a valid Git ref");
-    }
-}
-function validatedRemote(params) {
-    const remote = optionalString(params, "remote") ?? "origin";
-    if (remote.startsWith("-") || remote.includes("/") || remote.includes("\\")) {
-        throw new BindingSwitchGitError("invalid_git_request", "remote is not a safe remote name");
-    }
-    return remote;
-}
-function canonicalRemoteUrl(repoRoot, value) {
-    const trimmed = value.trim();
-    if (!trimmed || /[\0\r\n]/.test(trimmed)) {
-        throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
-    }
-    const scpStyle = trimmed.match(/^([^/@:\s]+)@([^/:\s]+):(.+)$/);
-    const urlValue = scpStyle ? `ssh://${scpStyle[1]}@${scpStyle[2]}/${scpStyle[3]}` : trimmed;
-    if (isAbsolute(urlValue) || urlValue.startsWith("./") || urlValue.startsWith("../")) {
-        const absolute = isAbsolute(urlValue) ? urlValue : resolve(repoRoot, urlValue);
-        return `file://${canonicalPathWithMissingTail(absolute)
-            .replace(/\/+$/, "")
-            .replace(/\.git$/, "")}`;
-    }
-    let parsed;
-    try {
-        parsed = new URL(urlValue);
-    }
-    catch {
-        throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
-    }
-    if (parsed.protocol === "file:") {
-        return `file://${canonicalPathWithMissingTail(fileURLToPath(parsed))
-            .replace(/\/+$/, "")
-            .replace(/\.git$/, "")}`;
-    }
-    if (parsed.search || parsed.hash) {
-        throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
-    }
-    if (!["https:", "http:", "ssh:", "git:"].includes(parsed.protocol)) {
-        throw new BindingSwitchGitError("invalid_git_request", "Remote URL uses an unsupported protocol");
-    }
-    if (parsed.password ||
-        ((parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.username)) {
-        throw new BindingSwitchGitError("remote_url_credentials_rejected", "Credential-bearing remote URLs are not allowed for environment migration");
-    }
-    const defaultPort = (parsed.protocol === "https:" && parsed.port === "443") ||
-        (parsed.protocol === "http:" && parsed.port === "80") ||
-        (parsed.protocol === "ssh:" && parsed.port === "22");
-    const transport = parsed.protocol === "https:" || parsed.protocol === "ssh:" ? "secure:" : parsed.protocol;
-    const authority = `${parsed.hostname.toLowerCase()}${parsed.port && !defaultPort ? `:${parsed.port}` : ""}`;
-    const path = parsed.pathname
-        .replace(/\/+/g, "/")
-        .replace(/\/+$/, "")
-        .replace(/\.git$/, "");
-    return `${transport}//${authority}${path}`;
-}
-function verifiedRemote(repoRoot, params, includePushUrls) {
-    const remote = validatedRemote(params);
-    const expectedRemoteUrl = canonicalRemoteUrl(repoRoot, requiredString(params, "expectedRemoteUrl"));
-    const fetchUrls = runGit(repoRoot, ["remote", "get-url", "--all", remote], "git_remote_unavailable")
-        .split("\n")
-        .filter(Boolean);
-    const pushUrls = includePushUrls
-        ? runGit(repoRoot, ["remote", "get-url", "--push", "--all", remote], "git_remote_unavailable")
-            .split("\n")
-            .filter(Boolean)
-        : [];
-    const urls = [...fetchUrls, ...pushUrls];
-    if (urls.length === 0 ||
-        urls.some((url) => canonicalRemoteUrl(repoRoot, url) !== expectedRemoteUrl)) {
-        throw new BindingSwitchGitError("remote_url_mismatch", "The configured Git remote does not match the repository selected for migration");
-    }
-    return { remote, expectedRemoteUrl, remoteUrl: fetchUrls[0] };
-}
-function inspectedRemoteUrl(repoRoot, params) {
-    if (optionalString(params, "expectedRemoteUrl")) {
-        return verifiedRemote(repoRoot, params, false).remoteUrl;
-    }
-    const remote = validatedRemote(params);
-    const result = runGitResult(repoRoot, ["remote", "get-url", "--all", remote]);
-    const urls = result.status === 0 ? result.stdout.split("\n").filter(Boolean) : [];
-    if (urls.length === 0)
-        return null;
-    for (const url of urls)
-        canonicalRemoteUrl(repoRoot, url);
-    return urls[0];
-}
-function isPathContained(childPath, parentPath) {
-    const rel = relative(resolve(parentPath), resolve(childPath));
-    return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`));
-}
-function canonicalPathWithMissingTail(path) {
-    const missingSegments = [];
-    let cursor = resolve(path);
-    while (!existsSync(cursor)) {
-        const parent = dirname(cursor);
-        if (parent === cursor) {
-            throw new BindingSwitchGitError("path_canonicalization_failed", "The selected path has no existing canonical ancestor");
-        }
-        missingSegments.unshift(basename(cursor));
-        cursor = parent;
-    }
-    return join(realpathSync.native(cursor), ...missingSegments);
-}
-function assertCanonicalPathContained(childPath, parentPath, code, message) {
-    if (!isPathContained(canonicalPathWithMissingTail(childPath), canonicalPathWithMissingTail(parentPath))) {
-        throw new BindingSwitchGitError(code, message);
-    }
-}
-function alanWorktreeRoot(projectRoot) {
-    return join(dirname(projectRoot), `${basename(projectRoot)}-alan-worktrees`);
-}
-function resolveRepositoryRoot(requestedPath) {
-    if (!existsSync(requestedPath)) {
-        throw new BindingSwitchGitError("repository_not_found", `The selected repository path does not exist: ${requestedPath}`);
-    }
-    const root = runGitResult(requestedPath, ["rev-parse", "--show-toplevel"]);
-    if (root.status !== 0 || !root.stdout.trim()) {
-        throw new BindingSwitchGitError("repository_not_found", "The selected folder is not inside a Git repository");
-    }
-    return realpathSync.native(resolve(root.stdout.trim()));
-}
-function listWorktrees(repoRoot) {
-    return runGit(repoRoot, ["worktree", "list", "--porcelain"])
-        .split("\n\n")
-        .flatMap((entry) => {
-        const lines = entry.split("\n");
-        const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
-        if (!path)
-            return [];
-        return [
-            {
-                path: canonicalPathWithMissingTail(path),
-                branch: lines
-                    .find((line) => line.startsWith("branch "))
-                    ?.slice("branch ".length)
-                    .replace("refs/heads/", "") ?? null,
-            },
-        ];
-    });
-}
-function resolveAuthorizedRepository(params, requireTrustedContext = false) {
-    const { repoPath } = commonRequest(params);
-    const repoRoot = resolveRepositoryRoot(repoPath);
-    const expectedRepoRoot = requireTrustedContext
-        ? requiredString(params, "expectedRepoRoot")
-        : optionalString(params, "expectedRepoRoot");
-    if (expectedRepoRoot && resolveRepositoryRoot(resolve(expectedRepoRoot)) !== repoRoot) {
-        throw new BindingSwitchGitError("repository_path_changed", "The selected path now resolves to a different Git repository");
-    }
-    const projectPath = requireTrustedContext
-        ? requiredString(params, "projectPath")
-        : optionalString(params, "projectPath");
-    if (!projectPath)
-        return repoRoot;
-    const projectRoot = resolveRepositoryRoot(resolve(projectPath));
-    const registrations = listWorktrees(projectRoot);
-    const registered = registrations.find(({ path }) => path === repoRoot);
-    if (!registered) {
-        throw new BindingSwitchGitError("repository_path_not_authorized", "The selected repository is not the Project checkout or one of its registered worktrees");
-    }
-    const mainRoot = registrations[0]?.path;
-    if (mainRoot &&
-        repoRoot !== mainRoot &&
-        !isPathContained(repoRoot, canonicalPathWithMissingTail(alanWorktreeRoot(mainRoot)))) {
-        throw new BindingSwitchGitError("repository_path_not_authorized", "The selected worktree is outside the Alan-managed worktree directory");
-    }
-    return repoRoot;
-}
-function readRawGit(repoRoot, args, code) {
-    const result = runGitResult(repoRoot, args);
-    if (result.status !== 0) {
-        throw new BindingSwitchGitError(code, (result.stderr || result.stdout || "Git inspection failed").trim());
-    }
-    return result.stdout;
-}
-function updateLengthPrefixed(hash, value) {
-    const bytes = Buffer.from(value, "utf8");
-    hash.update(String(bytes.byteLength));
-    hash.update("\0");
-    hash.update(bytes);
-    hash.update("\0");
-}
-function proposedTreeSha(repoRoot, headSha) {
-    const tempDir = mkdtempSync(join(tmpdir(), "alan-switch-index-"));
-    const indexPath = join(tempDir, "index");
-    const options = { env: { GIT_INDEX_FILE: indexPath } };
-    try {
-        if (headSha) {
-            runGitWithOptions(repoRoot, ["read-tree", headSha], options, "git_status_unreadable");
-        }
-        else {
-            runGitWithOptions(repoRoot, ["read-tree", "--empty"], options, "git_status_unreadable");
-        }
-        runGitWithOptions(repoRoot, ["add", "--all"], options, "git_status_unreadable");
-        const treeSha = runGitWithOptions(repoRoot, ["write-tree"], options, "git_status_unreadable");
-        assertCommitSha(treeSha, "proposedTreeSha");
-        return treeSha;
-    }
-    finally {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-}
-function statusFingerprint(repoRoot, porcelain, proposedTree) {
-    const unstagedPatch = readRawGit(repoRoot, ["diff", "--binary", "--full-index", "--no-ext-diff", "--submodule=log"], "git_status_unreadable");
-    const stagedPatch = readRawGit(repoRoot, ["diff", "--cached", "--binary", "--full-index", "--no-ext-diff", "--submodule=log"], "git_status_unreadable");
-    const untrackedRaw = readRawGit(repoRoot, ["ls-files", "--others", "--exclude-standard", "-z"], "git_status_unreadable");
-    const untrackedPaths = untrackedRaw.split("\0").filter(Boolean);
-    const hash = createHash("sha256");
-    updateLengthPrefixed(hash, porcelain);
-    updateLengthPrefixed(hash, proposedTree);
-    updateLengthPrefixed(hash, unstagedPatch);
-    updateLengthPrefixed(hash, stagedPatch);
-    for (let index = 0; index < untrackedPaths.length; index += 128) {
-        const paths = untrackedPaths.slice(index, index + 128);
-        const hashes = readRawGit(repoRoot, ["hash-object", "--no-filters", "--", ...paths], "git_status_unreadable");
-        updateLengthPrefixed(hash, paths.join("\0"));
-        updateLengthPrefixed(hash, hashes);
-    }
-    return hash.digest("hex");
-}
-function readStatus(repoRoot) {
-    const headResult = runGitResult(repoRoot, ["rev-parse", "HEAD"]);
-    const headSha = headResult.status === 0 ? headResult.stdout.trim() || null : null;
-    const branchResult = runGitResult(repoRoot, ["branch", "--show-current"]);
-    const branch = branchResult.status === 0 ? branchResult.stdout.trim() || null : null;
-    const proposedTree = proposedTreeSha(repoRoot, headSha);
-    const porcelain = runGit(repoRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
-    const displayStatus = runGit(repoRoot, ["status", "--porcelain=v1", "--untracked-files=all"]);
-    const upstreamResult = runGitResult(repoRoot, [
-        "rev-parse",
-        "--abbrev-ref",
-        "--symbolic-full-name",
-        "@{upstream}",
-    ]);
-    const upstream = upstreamResult.status === 0 ? upstreamResult.stdout.trim() || null : null;
-    let ahead = null;
-    let behind = null;
-    if (upstream) {
-        const counts = runGit(repoRoot, [
-            "rev-list",
-            "--left-right",
-            "--count",
-            `${upstream}...HEAD`,
-        ]).split(/\s+/);
-        const parsedBehind = Number.parseInt(counts[0] ?? "", 10);
-        const parsedAhead = Number.parseInt(counts[1] ?? "", 10);
-        behind = Number.isNaN(parsedBehind) ? null : parsedBehind;
-        ahead = Number.isNaN(parsedAhead) ? null : parsedAhead;
-    }
-    return {
-        repoRoot,
-        remoteUrl: null,
-        branch,
-        headSha,
-        dirty: porcelain.length > 0,
-        filesChanged: displayStatus ? displayStatus.split("\n").length : 0,
-        ahead,
-        behind,
-        hasUpstream: upstream !== null,
-        upstream,
-        statusFingerprint: statusFingerprint(repoRoot, porcelain, proposedTree),
-        proposedTreeSha: proposedTree,
-    };
-}
-function assertExpectedBranch(status, expectedBranch) {
-    assertValidBranch(expectedBranch);
-    if (status.branch !== expectedBranch) {
-        throw new BindingSwitchGitError("source_changed_since_approval", `Source branch changed from ${expectedBranch} to ${status.branch ?? "detached HEAD"}`);
-    }
-}
-function assertSourcePreconditions(status, expectedHeadSha, expectedStatusFingerprint, expectedBranch) {
-    assertCommitSha(expectedHeadSha, "expectedHeadSha");
-    if (expectedBranch !== undefined)
-        assertExpectedBranch(status, expectedBranch);
-    if (status.headSha !== expectedHeadSha) {
-        throw new BindingSwitchGitError("source_changed_since_approval", `Source HEAD changed from ${expectedHeadSha} to ${status.headSha ?? "unborn"}`);
-    }
-    if (expectedStatusFingerprint !== undefined &&
-        status.statusFingerprint !== expectedStatusFingerprint) {
-        throw new BindingSwitchGitError("source_changed_since_approval", "Source files changed after the migration inspection");
-    }
-}
-function commitHasSwitchTrailers(repoRoot, switchId, repoKey) {
-    const message = runGitResult(repoRoot, ["show", "-s", "--format=%B", "HEAD"]);
-    if (message.status !== 0)
-        return false;
-    const lines = message.stdout.split(/\r?\n/);
-    return (lines.includes(`Alan-Switch-Id: ${switchId}`) &&
-        lines.includes(`Alan-Repository-Id: ${repoKey}`));
-}
-async function checkpoint(params) {
-    const { switchId, repoKey } = commonRequest(params);
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const expectedHeadSha = requiredString(params, "expectedHeadSha");
-    const expectedStatusFingerprint = requiredString(params, "expectedStatusFingerprint");
-    const expectedProposedTreeSha = requiredString(params, "expectedProposedTreeSha");
-    assertCommitSha(expectedProposedTreeSha, "expectedProposedTreeSha");
-    const expectedBranch = requiredString(params, "expectedBranch");
-    const status = readStatus(repoRoot);
-    assertExpectedBranch(status, expectedBranch);
-    if (commitHasSwitchTrailers(repoRoot, switchId, repoKey)) {
-        if (!status.headSha) {
-            throw new BindingSwitchGitError("source_head_unreadable", "Checkpoint HEAD is unreadable");
-        }
-        const expectedRef = `refs/heads/${expectedBranch}`;
-        const baseline = createCheckpointIndexBaseline(repoRoot, status.headSha);
-        let locks = null;
-        try {
-            locks = acquireCheckpointRepositoryLocks(repoRoot);
-            assertCheckpointHead(repoRoot, expectedRef, status.headSha);
-            installCheckpointIndexBaseline(locks, baseline.indexPath);
-            return { repoRoot, sha: status.headSha, replayed: true };
-        }
-        finally {
-            if (locks)
-                releaseCheckpointRepositoryLocks(locks);
-            rmSync(baseline.tempDir, { recursive: true, force: true });
-        }
-    }
-    assertSourcePreconditions(status, expectedHeadSha, expectedStatusFingerprint, expectedBranch);
-    if (status.proposedTreeSha !== expectedProposedTreeSha) {
-        throw new BindingSwitchGitError("source_changed_since_approval", "The proposed checkpoint tree changed after migration approval");
-    }
-    if (!status.dirty) {
-        if (!status.headSha) {
-            throw new BindingSwitchGitError("source_head_unreadable", "Source HEAD is unreadable");
-        }
-        return { repoRoot, sha: status.headSha, replayed: true };
-    }
-    const commitMessage = requiredCommitMessage(params).trim();
-    const authorName = requiredString(params, "authorName");
-    const authorEmail = requiredString(params, "authorEmail");
-    const expectedHeadTree = runGit(repoRoot, ["rev-parse", `${expectedHeadSha}^{tree}`], "source_head_unreadable");
-    if (expectedHeadTree === expectedProposedTreeSha) {
-        throw new BindingSwitchGitError("checkpoint_empty", "The inspected changes did not produce a checkpoint commit");
-    }
-    const proposedTreeObject = runGitResult(repoRoot, [
-        "cat-file",
-        "-e",
-        `${expectedProposedTreeSha}^{tree}`,
-    ]);
-    if (proposedTreeObject.status !== 0) {
-        throw new BindingSwitchGitError("checkpoint_tree_unavailable", "The approved checkpoint tree is no longer available");
-    }
-    await waitForCheckpointTestBarrier();
-    const currentBranch = runGit(repoRoot, ["branch", "--show-current"]);
-    const currentHead = runGit(repoRoot, ["rev-parse", "HEAD"], "source_head_unreadable");
-    if (currentBranch !== expectedBranch || currentHead !== expectedHeadSha) {
-        throw new BindingSwitchGitError("source_changed_since_approval", "Source HEAD or branch changed during checkpoint preparation");
-    }
-    const message = `${commitMessage}\n\nAlan-Switch-Id: ${switchId}\nAlan-Repository-Id: ${repoKey}`;
-    const sha = runGitWithOptions(repoRoot, ["commit-tree", expectedProposedTreeSha, "-p", expectedHeadSha], {
-        env: {
-            GIT_AUTHOR_EMAIL: authorEmail,
-            GIT_AUTHOR_NAME: authorName,
-            GIT_COMMITTER_EMAIL: authorEmail,
-            GIT_COMMITTER_NAME: authorName,
-        },
-        input: `${message}\n`,
-    }, "checkpoint_commit_failed");
-    assertCommitSha(sha, "checkpointSha");
-    const expectedRef = `refs/heads/${expectedBranch}`;
-    const currentRef = runGit(repoRoot, ["symbolic-ref", "-q", "HEAD"], "source_changed_since_approval");
-    if (currentRef !== expectedRef) {
-        throw new BindingSwitchGitError("source_changed_since_approval", "Source branch changed during checkpoint preparation");
-    }
-    await waitForCheckpointFinalizeTestBarrier();
-    const baseline = createCheckpointIndexBaseline(repoRoot, sha);
-    let locks = null;
-    let refAdvanced = false;
-    let indexInstalled = false;
-    try {
-        locks = acquireCheckpointRepositoryLocks(repoRoot);
-        assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha);
-        // update-ref maintains the reflog for the currently checked-out branch and
-        // therefore takes HEAD.lock itself. Keep index.lock held so checkout-like
-        // operations cannot switch branches while Git briefly owns HEAD.lock.
-        releaseCheckpointHeadLock(locks);
-        runGit(repoRoot, ["update-ref", expectedRef, sha, expectedHeadSha], "source_changed_since_approval");
-        refAdvanced = true;
-        acquireCheckpointHeadLock(locks);
-        assertCheckpointHead(repoRoot, expectedRef, sha);
-        installCheckpointIndexBaseline(locks, baseline.indexPath);
-        indexInstalled = true;
-        return { repoRoot, sha, replayed: false };
-    }
-    finally {
-        if (refAdvanced && !indexInstalled) {
-            if (locks)
-                releaseCheckpointHeadLock(locks);
-            runGitResult(repoRoot, ["update-ref", expectedRef, expectedHeadSha, sha]);
-        }
-        if (locks)
-            releaseCheckpointRepositoryLocks(locks);
-        rmSync(baseline.tempDir, { recursive: true, force: true });
-    }
-}
-function resolveRemoteBranch(repoRoot, params) {
-    const expectedBranch = requiredString(params, "expectedBranch");
-    const requestedBranch = optionalString(params, "branch");
-    if (requestedBranch && requestedBranch !== expectedBranch) {
-        throw new BindingSwitchGitError("invalid_git_request", "branch must match expectedBranch");
-    }
-    const currentBranch = runGit(repoRoot, ["branch", "--show-current"]);
-    const branch = expectedBranch;
-    assertValidBranch(branch);
-    if (currentBranch !== expectedBranch) {
-        throw new BindingSwitchGitError("source_changed_since_approval", `Source branch changed from ${expectedBranch} to ${currentBranch || "detached HEAD"}`);
-    }
-    const { remote } = verifiedRemote(repoRoot, params, true);
-    return { branch, remote };
-}
-async function push(params) {
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const expectedHeadSha = requiredString(params, "expectedHeadSha");
-    const expectedBranch = requiredString(params, "expectedBranch");
-    const status = readStatus(repoRoot);
-    assertSourcePreconditions(status, expectedHeadSha, undefined, expectedBranch);
-    if (status.dirty) {
-        throw new BindingSwitchGitError("source_dirty_after_checkpoint", "The source has uncommitted changes and cannot be published");
-    }
-    const { branch, remote } = resolveRemoteBranch(repoRoot, params);
-    const latest = readStatus(repoRoot);
-    assertSourcePreconditions(latest, expectedHeadSha, undefined, expectedBranch);
-    if (latest.dirty) {
-        throw new BindingSwitchGitError("source_dirty_after_checkpoint", "The source has uncommitted changes and cannot be published");
-    }
-    const before = await runNetworkGit(repoRoot, ["ls-remote", "--heads", remote, `refs/heads/${branch}`], "git_remote_unavailable");
-    const remoteBefore = before.trim().split(/\s+/)[0] || null;
-    await runNetworkGit(repoRoot, ["push", remote, `${expectedHeadSha}:refs/heads/${expectedBranch}`], "git_push_failed");
-    const remoteHead = (await runNetworkGit(repoRoot, ["ls-remote", "--heads", remote, `refs/heads/${branch}`], "push_verification_failed"))
-        .split(/\s+/)[0]
-        ?.trim();
-    if (remoteHead !== expectedHeadSha) {
-        throw new BindingSwitchGitError("push_verification_failed", `Remote branch ${branch} is at ${remoteHead || "an unreadable SHA"}, expected ${expectedHeadSha}`);
-    }
-    const afterPush = readStatus(repoRoot);
-    if (afterPush.headSha !== expectedHeadSha ||
-        afterPush.branch !== expectedBranch ||
-        afterPush.dirty ||
-        afterPush.statusFingerprint !== latest.statusFingerprint) {
-        throw new BindingSwitchGitError("source_changed_since_approval", "The source changed while the approved commit was being published", {
-            published: {
-                pushedSha: expectedHeadSha,
-                branch,
-                remote,
-                replayed: remoteBefore === expectedHeadSha,
-            },
-        });
-    }
-    return {
-        repoRoot,
-        pushedSha: expectedHeadSha,
-        branch,
-        remote,
-        replayed: remoteBefore === expectedHeadSha,
-    };
-}
-async function fetchPublishedBranch(repoRoot, branch, expectedSha, params) {
-    assertValidBranch(branch);
-    assertCommitSha(expectedSha, "expectedSha");
-    const { remote } = verifiedRemote(repoRoot, params, false);
-    await runNetworkGit(repoRoot, ["fetch", "--no-tags", remote, `refs/heads/${branch}`], "git_fetch_failed");
-    const fetchedSha = runGit(repoRoot, ["rev-parse", "FETCH_HEAD"], "target_sha_unavailable");
-    if (fetchedSha !== expectedSha) {
-        throw new BindingSwitchGitError("target_sha_mismatch", `Fetched ${branch} at ${fetchedSha}, expected the published SHA ${expectedSha}`);
-    }
-    const commit = runGitResult(repoRoot, ["cat-file", "-e", `${expectedSha}^{commit}`]);
-    if (commit.status !== 0) {
-        throw new BindingSwitchGitError("target_sha_unavailable", `The published SHA ${expectedSha} is not available in the destination repository`);
-    }
-    return { fetchedSha, remote };
-}
-async function fetchBranch(params) {
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const branch = requiredString(params, "branch");
-    const expectedSha = requiredString(params, "expectedSha");
-    const { fetchedSha, remote } = await fetchPublishedBranch(repoRoot, branch, expectedSha, params);
-    return { repoRoot, fetchedSha, branch, remote };
-}
-function isAncestor(repoRoot, ancestor, descendant) {
-    return runGitResult(repoRoot, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
-}
-function assertCleanTarget(repoRoot) {
-    if (readStatus(repoRoot).dirty) {
-        throw new BindingSwitchGitError("target_checkout_dirty", "The destination checkout has uncommitted changes");
-    }
-}
-function assertBranchAvailableAtPath(repoRoot, branch, allowedPath) {
-    const canonicalAllowedPath = canonicalPathWithMissingTail(allowedPath);
-    const conflicting = listWorktrees(repoRoot).find((worktree) => worktree.branch === branch && worktree.path !== canonicalAllowedPath);
-    if (conflicting) {
-        throw new BindingSwitchGitError("target_branch_in_use", `Branch ${branch} is already checked out at ${conflicting.path}`);
-    }
-}
-function advanceBranchAtCheckout(checkoutRoot, branch, targetSha) {
-    const before = readStatus(checkoutRoot);
-    if (before.branch === branch && before.headSha === targetSha)
-        return true;
-    assertBranchAvailableAtPath(checkoutRoot, branch, checkoutRoot);
-    const branchExists = runGitResult(checkoutRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])
-        .status === 0;
-    if (branchExists) {
-        const branchHead = runGit(checkoutRoot, ["rev-parse", `refs/heads/${branch}`]);
-        if (!isAncestor(checkoutRoot, branchHead, targetSha)) {
-            throw new BindingSwitchGitError("target_branch_diverged", `Local branch ${branch} cannot fast-forward to the published SHA`);
-        }
-        if (before.branch !== branch) {
-            runGit(checkoutRoot, ["switch", branch], "target_checkout_failed");
-        }
-    }
-    else {
-        runGit(checkoutRoot, ["switch", "-c", branch, targetSha], "target_checkout_failed");
-    }
-    const currentHead = runGit(checkoutRoot, ["rev-parse", "HEAD"]);
-    if (currentHead !== targetSha) {
-        if (!isAncestor(checkoutRoot, currentHead, targetSha)) {
-            throw new BindingSwitchGitError("target_branch_diverged", `Local branch ${branch} cannot fast-forward to the published SHA`);
-        }
-        runGit(checkoutRoot, ["merge", "--ff-only", targetSha], "target_fast_forward_failed");
-    }
-    const verified = readStatus(checkoutRoot);
-    if (verified.branch !== branch || verified.headSha !== targetSha) {
-        throw new BindingSwitchGitError("target_verification_failed", "The destination checkout did not land on the published branch and SHA");
-    }
-    return false;
-}
-async function prepareCheckout(params) {
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const branch = requiredString(params, "branch");
-    const targetSha = requiredString(params, "targetSha");
-    await fetchPublishedBranch(repoRoot, branch, targetSha, params);
-    assertCleanTarget(repoRoot);
-    const replayed = advanceBranchAtCheckout(repoRoot, branch, targetSha);
-    return {
-        repoRoot,
-        path: repoRoot,
-        branch,
-        headSha: targetSha,
-        replayed,
-    };
-}
-async function prepareWorktree(params) {
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const registrations = listWorktrees(repoRoot);
-    const projectRoot = registrations[0]?.path;
-    if (!projectRoot || projectRoot !== repoRoot) {
-        throw new BindingSwitchGitError("project_checkout_required", "Worktree preparation requires the Project's main checkout");
-    }
-    const worktreePath = resolve(requiredString(params, "worktreePath"));
-    const managedRoot = alanWorktreeRoot(projectRoot);
-    const pathError = "The destination worktree path is outside the Alan-managed worktree directory";
-    const intendedManagedRoot = join(realpathSync.native(dirname(managedRoot)), basename(managedRoot));
-    if (canonicalPathWithMissingTail(managedRoot) !== intendedManagedRoot) {
-        throw new BindingSwitchGitError("worktree_path_not_authorized", pathError);
-    }
-    assertCanonicalPathContained(worktreePath, managedRoot, "worktree_path_not_authorized", pathError);
-    const canonicalWorktreePath = canonicalPathWithMissingTail(worktreePath);
-    if (canonicalWorktreePath === canonicalPathWithMissingTail(managedRoot)) {
-        throw new BindingSwitchGitError("worktree_path_not_authorized", pathError);
-    }
-    const branch = requiredString(params, "branch");
-    const targetSha = requiredString(params, "targetSha");
-    await fetchPublishedBranch(repoRoot, branch, targetSha, params);
-    const refreshed = listWorktrees(repoRoot);
-    const registeredAtPath = refreshed.find(({ path }) => path === canonicalWorktreePath);
-    const registeredForBranch = refreshed.find(({ branch: value }) => value === branch);
-    if (registeredAtPath) {
-        if (registeredAtPath.branch !== branch) {
-            throw new BindingSwitchGitError("worktree_path_conflict", "The destination path is registered to a different branch");
-        }
-        assertCleanTarget(worktreePath);
-        const replayed = advanceBranchAtCheckout(worktreePath, branch, targetSha);
-        return {
-            repoRoot: worktreePath,
-            path: worktreePath,
-            branch,
-            headSha: targetSha,
-            replayed,
-        };
-    }
-    if (registeredForBranch) {
-        throw new BindingSwitchGitError("target_branch_in_use", `Branch ${branch} is already checked out at ${registeredForBranch.path}`);
-    }
-    if (existsSync(worktreePath)) {
-        throw new BindingSwitchGitError("worktree_path_conflict", "The destination worktree path already exists and is not registered");
-    }
-    const branchExists = runGitResult(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status ===
-        0;
-    if (branchExists) {
-        const branchHead = runGit(repoRoot, ["rev-parse", `refs/heads/${branch}`]);
-        if (!isAncestor(repoRoot, branchHead, targetSha)) {
-            throw new BindingSwitchGitError("target_branch_diverged", `Local branch ${branch} cannot fast-forward to the published SHA`);
-        }
-    }
-    mkdirSync(dirname(worktreePath), { recursive: true });
-    if (branchExists) {
-        runGit(repoRoot, ["worktree", "add", worktreePath, branch], "worktree_prepare_failed");
-        const currentHead = runGit(worktreePath, ["rev-parse", "HEAD"]);
-        if (currentHead !== targetSha) {
-            runGit(worktreePath, ["merge", "--ff-only", targetSha], "target_fast_forward_failed");
-        }
-    }
-    else {
-        runGit(repoRoot, ["worktree", "add", "-b", branch, worktreePath, targetSha], "worktree_prepare_failed");
-    }
-    const createdRoot = resolveRepositoryRoot(worktreePath);
-    assertCanonicalPathContained(createdRoot, managedRoot, "worktree_path_not_authorized", pathError);
-    if (createdRoot !== realpathSync.native(worktreePath)) {
-        throw new BindingSwitchGitError("worktree_path_changed", "The destination worktree resolved to an unexpected path after creation");
-    }
-    const verified = readStatus(createdRoot);
-    if (verified.branch !== branch || verified.headSha !== targetSha) {
-        throw new BindingSwitchGitError("target_verification_failed", "The destination worktree did not land on the published branch and SHA");
-    }
-    return {
-        repoRoot: worktreePath,
-        path: worktreePath,
-        branch,
-        headSha: targetSha,
-        replayed: false,
-    };
-}
-function verifyHead(params) {
-    const repoRoot = resolveAuthorizedRepository(params, true);
-    const expectedSha = requiredString(params, "expectedSha");
-    assertCommitSha(expectedSha, "expectedSha");
-    assertCleanTarget(repoRoot);
-    const headSha = runGit(repoRoot, ["rev-parse", "HEAD"], "target_head_unreadable");
-    if (headSha !== expectedSha) {
-        throw new BindingSwitchGitError("verify_head_mismatch", `Destination HEAD is ${headSha}, expected ${expectedSha}`);
-    }
-    return { repoRoot, headSha, verified: true };
-}
-export function statusBindingSwitchGit(params) {
-    const repoRoot = resolveAuthorizedRepository(params);
-    return {
-        ...readStatus(repoRoot),
-        remoteUrl: inspectedRemoteUrl(repoRoot, params),
-    };
-}
-export async function executeBindingSwitchGitRpc(method, params) {
-    switch (method) {
-        case "git.status":
-            return statusBindingSwitchGit(params);
-        case "git.checkpoint":
-            return checkpoint(params);
-        case "git.push":
-            return push(params);
-        case "git.fetch":
-            return fetchBranch(params);
-        case "git.prepare_checkout":
-            return prepareCheckout(params);
-        case "git.prepare_worktree":
-            return prepareWorktree(params);
-        case "git.verify_head":
-            return verifyHead(params);
-    }
-}
-//# sourceMappingURL=binding-switch-git.js.map