@astrosheep/keiyaku 2.9.8 → 2.9.10

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

@@ -0,0 +1,353 @@
+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 });
+    }
+}