@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/repository-ledger/publication.js

@@ -1,353 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { runGitProcess } from "../../git/core.js";
-import { commitRefTransaction, resolveLocalBranchHead } from "../../git/refs.js";
-import { REPOSITORY_LEDGER_REF, formatStructuralJoin, } from "./codec.js";
-import { admitJoin, cleanTip } from "./publication-admission.js";
-import { assertHostObjectId, assertReadableCommitClosure, deriveHostGitCoordinates, writeCommitObject, } from "./git-object-store.js";
-import { traverseRepositoryLedger, } from "./traversal.js";
-import { readRepositoryLifecycle } from "./read-model.js";
-import { readPinnedAcceptedTraversal } from "./current-state-store.js";
-const VIRTUAL_JOIN_OBJECT_ID = "publication-admission:join";
-const ADOPTED_REMOTE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const NO_PROMPT_ENV = {
-    GIT_NO_LAZY_FETCH: "1",
-    GIT_TERMINAL_PROMPT: "0",
-    GCM_INTERACTIVE: "Never",
-};
-async function recoverPublicationTip(cwd, head) {
-    return traverseRepositoryLedger(cwd, head, undefined, { historicalSemanticEvidence: false });
-}
-function gitFailure(result) {
-    return result.stderr.trim() || result.error?.message || `git exited ${String(result.status)}`;
-}
-async function successfulGit(cwd, args) {
-    const result = await runGitProcess(cwd, args, { env: NO_PROMPT_ENV });
-    if (result.status !== 0 || result.error)
-        throw new Error(gitFailure(result), { cause: result.error });
-    return result.stdout;
-}
-async function observeLocalTip(cwd) {
-    return (await resolveLocalBranchHead(cwd, REPOSITORY_LEDGER_REF))?.head ?? null;
-}
-async function resolveConfiguredRemote(cwd, remote) {
-    if (!ADOPTED_REMOTE_NAME.test(remote.name)) {
-        throw new Error("adopted remote name is not a canonical configured Git remote name");
-    }
-    const output = await successfulGit(cwd, ["remote", "get-url", "--push", "--all", remote.name]);
-    const endpoints = output.split(/\r?\n/);
-    if (endpoints.at(-1) === "")
-        endpoints.pop();
-    if (endpoints.length !== 1 || endpoints[0].trim() === "") {
-        throw new Error(`adopted remote ${remote.name} must resolve exactly one publication endpoint`);
-    }
-    return { publicationEndpoint: endpoints[0] };
-}
-async function targetObjectDirectory(cwd) {
-    const observed = (await successfulGit(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "objects"])).trim();
-    if (!path.isAbsolute(observed))
-        throw new Error("Git returned a non-absolute object directory");
-    const canonical = await fs.realpath(observed);
-    if (canonical.includes("\n") || canonical.includes("\r")) {
-        throw new Error("Git object directory cannot be represented by an alternates file");
-    }
-    return canonical;
-}
-async function observeRemoteTip(cwd, endpoint, coordinates) {
-    const result = await runGitProcess(cwd, ["ls-remote", "--refs", "--", endpoint, REPOSITORY_LEDGER_REF], {
-        env: NO_PROMPT_ENV,
-    });
-    if (result.status !== 0 || result.error)
-        throw new Error(gitFailure(result), { cause: result.error });
-    if (result.stdout === "")
-        return null;
-    const rows = result.stdout.trimEnd().split(/\r?\n/);
-    if (rows.length !== 1)
-        throw new Error("adopted remote advertised more than one exact ledger ref");
-    const [objectId, ref, extra] = rows[0].split("\t");
-    if (!objectId || ref !== REPOSITORY_LEDGER_REF || extra !== undefined) {
-        throw new Error("adopted remote returned an invalid exact ledger advertisement");
-    }
-    assertHostObjectId(coordinates, objectId);
-    return objectId;
-}
-async function prepareScratch(input) {
-    const scratch = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-publication-observation-"));
-    try {
-        await successfulGit(scratch, ["init", "--quiet", "--bare", `--object-format=${input.coordinates.objectFormat}`, "."]);
-        const alternate = await targetObjectDirectory(input.cwd);
-        await fs.writeFile(path.join(scratch, "objects", "info", "alternates"), `${alternate}\n`, { encoding: "utf8", mode: 0o600 });
-        return scratch;
-    }
-    catch (error) {
-        await fs.rm(scratch, { recursive: true, force: true });
-        throw error;
-    }
-}
-async function observeStableRemoteInScratch(cwd, scratch, endpoint, coordinates) {
-    const before = await observeRemoteTip(cwd, endpoint, coordinates);
-    if (before !== null) {
-        await successfulGit(cwd, [
-            `--git-dir=${scratch}`,
-            "fetch",
-            "--quiet",
-            "--no-tags",
-            "--no-write-fetch-head",
-            "--",
-            endpoint,
-            REPOSITORY_LEDGER_REF,
-        ]);
-    }
-    const after = await observeRemoteTip(cwd, endpoint, coordinates);
-    return before === after ? { status: "stable", tip: after } : { status: "changed", before, after };
-}
-async function promoteRemoteClosure(input) {
-    await successfulGit(input.cwd, [
-        "fetch",
-        "--quiet",
-        "--no-tags",
-        "--no-write-fetch-head",
-        "--",
-        input.endpoint,
-        REPOSITORY_LEDGER_REF,
-    ]);
-    return await observeRemoteTip(input.cwd, input.endpoint, input.coordinates) === input.expectedTip
-        ? "promoted"
-        : "changed";
-}
-async function publishRemote(input) {
-    const pushed = await runGitProcess(input.cwd, [
-        "push",
-        "--porcelain",
-        "--",
-        input.endpoint,
-        `${input.newTip}:${REPOSITORY_LEDGER_REF}`,
-    ], { env: NO_PROMPT_ENV });
-    if (pushed.status !== 0 || pushed.error)
-        return "failed";
-    return await observeRemoteTip(input.cwd, input.endpoint, input.coordinates) === input.newTip
-        ? "published"
-        : "unconfirmed";
-}
-/**
- * Internal adopted-remote convergence. The caller supplies the sole authority
- * name explicitly; this owner never scans tracking refs or user-visible state.
- */
-export async function publishAdoptedRepositoryLedger(input) {
-    formatStructuralJoin(input.join);
-    const coordinates = await deriveHostGitCoordinates(input.cwd);
-    const initialLocalTip = await observeLocalTip(input.cwd);
-    let configured;
-    try {
-        configured = await resolveConfiguredRemote(input.cwd, input.remote);
-    }
-    catch (error) {
-        return {
-            status: "lag",
-            code: "REMOTE_CONFIGURATION_INVALID",
-            localTip: initialLocalTip,
-            remoteTip: null,
-            cause: error instanceof Error ? error.message : String(error),
-        };
-    }
-    let scratch;
-    try {
-        scratch = await prepareScratch({ cwd: input.cwd, coordinates });
-    }
-    catch (error) {
-        return {
-            status: "lag",
-            code: "REMOTE_OBSERVATION_FAILED",
-            localTip: initialLocalTip,
-            remoteTip: null,
-            cause: error instanceof Error ? error.message : String(error),
-        };
-    }
-    try {
-        let remoteObservation;
-        try {
-            remoteObservation = await observeStableRemoteInScratch(input.cwd, scratch, configured.publicationEndpoint, coordinates);
-        }
-        catch (error) {
-            return {
-                status: "lag",
-                code: "REMOTE_OBSERVATION_FAILED",
-                localTip: initialLocalTip,
-                remoteTip: null,
-                cause: error instanceof Error ? error.message : String(error),
-            };
-        }
-        if (remoteObservation.status === "changed") {
-            return {
-                status: "lag",
-                code: "REMOTE_OBSERVATION_CHANGED",
-                localTip: initialLocalTip,
-                remoteTip: remoteObservation.after,
-                cause: "adopted remote ledger changed during observation",
-            };
-        }
-        const remoteTip = remoteObservation.tip;
-        if (initialLocalTip === null && remoteTip === null) {
-            return { status: "current", localTip: null, remoteTip: null };
-        }
-        let local = null;
-        if (initialLocalTip !== null) {
-            const current = await readRepositoryLifecycle(input.cwd);
-            if (current.observedLedgerHead !== initialLocalTip) {
-                return { status: "refused", code: "LEDGER_LOCAL_CAS_CONFLICT", localTip: current.observedLedgerHead, remoteTip, cause: "local ledger changed during publication admission" };
-            }
-            const traversal = await readPinnedAcceptedTraversal(input.cwd, initialLocalTip) ?? await recoverPublicationTip(input.cwd, initialLocalTip);
-            const clean = cleanTip(initialLocalTip, traversal);
-            if (clean.status === "refused")
-                return { ...clean, localTip: initialLocalTip, remoteTip };
-            local = clean;
-        }
-        let remote = null;
-        if (remoteTip !== null) {
-            const clean = cleanTip(remoteTip, await recoverPublicationTip(scratch, remoteTip));
-            if (clean.status === "refused")
-                return { ...clean, localTip: initialLocalTip, remoteTip };
-            remote = clean;
-        }
-        if (initialLocalTip === remoteTip) {
-            return { status: "current", localTip: initialLocalTip, remoteTip };
-        }
-        if (remote !== null && local !== null) {
-            const admission = admitJoin(remote, local, input.join);
-            if (admission.status === "refused")
-                return admission;
-        }
-        if (remoteTip !== null) {
-            try {
-                if (await promoteRemoteClosure({
-                    cwd: input.cwd,
-                    endpoint: configured.publicationEndpoint,
-                    coordinates,
-                    expectedTip: remoteTip,
-                }) === "changed") {
-                    return {
-                        status: "lag",
-                        code: "REMOTE_OBSERVATION_CHANGED",
-                        localTip: initialLocalTip,
-                        remoteTip,
-                        cause: "adopted remote ledger changed before closure promotion",
-                    };
-                }
-                await assertReadableCommitClosure(input.cwd, remoteTip);
-            }
-            catch (error) {
-                return {
-                    status: "lag",
-                    code: "REMOTE_CLOSURE_PROMOTION_FAILED",
-                    localTip: initialLocalTip,
-                    remoteTip,
-                    cause: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-        if (local === null && remote !== null) {
-            const transaction = await commitRefTransaction(input.cwd, [{
-                    kind: "update",
-                    ref: REPOSITORY_LEDGER_REF,
-                    newOid: remote.head,
-                    expectedOldOid: null,
-                }], coordinates.objectIdLength);
-            if (transaction.status === "refused") {
-                return {
-                    status: "refused",
-                    code: "LEDGER_LOCAL_CAS_CONFLICT",
-                    localTip: await observeLocalTip(input.cwd),
-                    remoteTip: remote.head,
-                    cause: transaction.cause,
-                };
-            }
-            if (transaction.status === "indeterminate") {
-                return {
-                    status: "indeterminate",
-                    code: "LEDGER_LOCAL_CAS_INDETERMINATE",
-                    localTip: await observeLocalTip(input.cwd),
-                    remoteTip: remote.head,
-                    cause: transaction.cause,
-                };
-            }
-            return { status: "seeded", localTip: remote.head, remoteTip: remote.head };
-        }
-        let publishTip = local.head;
-        let joinObjectId;
-        if (remote !== null) {
-            joinObjectId = await writeCommitObject({
-                cwd: input.cwd,
-                coordinates,
-                tree: coordinates.emptyTree,
-                parents: [remote.head, local.head],
-                author: { name: "Keiyaku", email: "keiyaku@localhost", date: input.join.at },
-                committer: { name: "Keiyaku", email: "keiyaku@localhost", date: input.join.at },
-                message: formatStructuralJoin(input.join),
-            });
-            const transaction = await commitRefTransaction(input.cwd, [{
-                    kind: "update",
-                    ref: REPOSITORY_LEDGER_REF,
-                    newOid: joinObjectId,
-                    expectedOldOid: local.head,
-                }], coordinates.objectIdLength);
-            if (transaction.status === "refused") {
-                return {
-                    status: "refused",
-                    code: "LEDGER_LOCAL_CAS_CONFLICT",
-                    localTip: await observeLocalTip(input.cwd),
-                    remoteTip: remote.head,
-                    cause: transaction.cause,
-                };
-            }
-            if (transaction.status === "indeterminate") {
-                return {
-                    status: "indeterminate",
-                    code: "LEDGER_LOCAL_CAS_INDETERMINATE",
-                    localTip: await observeLocalTip(input.cwd),
-                    remoteTip: remote.head,
-                    cause: transaction.cause,
-                };
-            }
-            publishTip = joinObjectId;
-        }
-        let publication;
-        try {
-            publication = await publishRemote({
-                cwd: input.cwd,
-                endpoint: configured.publicationEndpoint,
-                coordinates,
-                newTip: publishTip,
-            });
-        }
-        catch (error) {
-            return {
-                status: "lag",
-                code: "REMOTE_PUBLICATION_FAILED",
-                localTip: publishTip,
-                remoteTip,
-                cause: error instanceof Error ? error.message : String(error),
-            };
-        }
-        if (publication !== "published") {
-            return {
-                status: "lag",
-                code: publication === "failed" ? "REMOTE_PUBLICATION_FAILED" : "REMOTE_PUBLICATION_UNCONFIRMED",
-                localTip: publishTip,
-                remoteTip,
-                cause: publication === "failed"
-                    ? "adopted remote rejected or could not complete ledger publication"
-                    : "adopted remote did not read back the published ledger tip",
-            };
-        }
-        return {
-            status: "published",
-            localTip: publishTip,
-            remoteTip: publishTip,
-            ...(joinObjectId === undefined ? {} : { joinObjectId }),
-        };
-    }
-    finally {
-        await fs.rm(scratch, { recursive: true, force: true });
-    }
-}