@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/git/process.js

@@ -1,229 +0,0 @@
-import { spawn } from "node:child_process";
-import { getConfig } from "../config/env.js";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-export const GIT_ABORT_FORCE_KILL_MS = 250;
-const ADMITTED_GIT_ENV_KEYS = new Set([
-    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-    "GIT_AUTHOR_DATE",
-    "GIT_AUTHOR_EMAIL",
-    "GIT_AUTHOR_NAME",
-    "GIT_COMMITTER_DATE",
-    "GIT_COMMITTER_EMAIL",
-    "GIT_COMMITTER_NAME",
-    "GIT_INDEX_FILE",
-    "GIT_NO_LAZY_FETCH",
-    "GIT_OBJECT_DIRECTORY",
-    "GIT_SHALLOW_FILE",
-]);
-const GIT_HOST_ENV_KEYS = [
-    "APPDATA",
-    "COMSPEC",
-    "ComSpec",
-    "HOME",
-    "HOMEDRIVE",
-    "HOMEPATH",
-    "LOCALAPPDATA",
-    "PATH",
-    "PATHEXT",
-    "SYSTEMDRIVE",
-    "SYSTEMROOT",
-    "SystemRoot",
-    "TEMP",
-    "TMP",
-    "TMPDIR",
-    "USER",
-    "USERNAME",
-    "WINDIR",
-];
-function initializedRuntimeEnv() {
-    try {
-        return getConfig().runtimeEnv;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Resolve one initialized executable coordinate. Values are never split into shell words. */
-export function resolveGitExecutable() {
-    const configured = initializedRuntimeEnv()?.KEIYAKU_GIT;
-    return configured !== undefined && configured.trim().length > 0 ? configured : "git";
-}
-/** Configured Git timeout, with a bootstrap-safe default before env loads. */
-export function resolveGitTimeoutMs() {
-    try {
-        return getConfig().git.timeoutMs;
-    }
-    catch {
-        return 60_000;
-    }
-}
-function isAdmittedGitEnvironmentKey(key) {
-    return ADMITTED_GIT_ENV_KEYS.has(key) || key.startsWith("GIT_TRACE2");
-}
-/** Non-interactive controlled Git environment shared by all owned Git processes. */
-export function gitProcessEnv(extra) {
-    const runtimeEnv = initializedRuntimeEnv() ?? process.env;
-    const environment = {};
-    for (const key of GIT_HOST_ENV_KEYS) {
-        const value = runtimeEnv[key];
-        if (typeof value === "string")
-            environment[key] = value;
-    }
-    for (const [key, value] of Object.entries(process.env)) {
-        if (typeof value === "string" && key.startsWith("GIT_TRACE2"))
-            environment[key] = value;
-    }
-    for (const [key, value] of Object.entries(runtimeEnv)) {
-        if (typeof value === "string" && key.startsWith("GIT_TRACE2"))
-            environment[key] = value;
-    }
-    for (const [key, value] of Object.entries(extra ?? {})) {
-        if (typeof value === "string" && isAdmittedGitEnvironmentKey(key))
-            environment[key] = value;
-    }
-    return {
-        ...environment,
-        GIT_TERMINAL_PROMPT: "0",
-        GCM_INTERACTIVE: "Never",
-        GIT_MERGE_AUTOEDIT: "no",
-        LC_ALL: "C",
-        PATH: runtimeEnv.PATH ?? "",
-    };
-}
-/**
- * The only physical Git process factory. It resolves the executable once and
- * preserves normalized cwd, inherited environment, argv, and timeout facts.
- */
-export function openGitProcess(cwd, args, options = {}) {
-    const normalizedCwd = normalizeFilesystemCoordinate(cwd);
-    const env = gitProcessEnv(options.env);
-    const executable = resolveGitExecutable();
-    return {
-        child: spawn(executable, [...args], {
-            cwd: normalizedCwd,
-            env,
-            shell: false,
-            stdio: ["pipe", "pipe", "pipe"],
-        }),
-        cwd: normalizedCwd,
-        executable,
-        env,
-        timeoutMs: options.timeoutMs ?? resolveGitTimeoutMs(),
-    };
-}
-/** Terminate one non-detached Git child and wait until Node drains its stdio close. */
-export async function terminateGitChild(child, closed, graceMs = GIT_ABORT_FORCE_KILL_MS) {
-    if (child.exitCode === null && child.signalCode === null)
-        child.kill("SIGTERM");
-    let grace;
-    const exited = await Promise.race([
-        closed.then(() => true),
-        new Promise((resolve) => {
-            grace = setTimeout(() => resolve(false), graceMs);
-            grace.unref();
-        }),
-    ]);
-    if (grace)
-        clearTimeout(grace);
-    if (!exited)
-        child.kill("SIGKILL");
-    await closed;
-}
-function processError(result) {
-    if (result.error)
-        return result.error;
-    if (result.status === 0)
-        return undefined;
-    const error = new Error(`git exited with status ${result.status ?? "unknown"}`);
-    Object.assign(error, {
-        stdout: result.stdout.toString("utf8"),
-        stderr: result.stderr.toString("utf8"),
-        status: result.status,
-    });
-    return error;
-}
-/** Soft-result Git process mouth: preserves output, exit, spawn, timeout, and abort facts. */
-export async function runGitProcessBytes(cwd, args, options = {}) {
-    options.signal?.throwIfAborted();
-    const process = openGitProcess(cwd, args, options);
-    const { child } = process;
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    return await new Promise((resolve) => {
-        let settled = false;
-        let timedOut = false;
-        let aborting = false;
-        let termination;
-        const closed = new Promise((resolveClosed) => child.once("close", () => resolveClosed()));
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            options.signal?.removeEventListener("abort", abort);
-            resolve(result);
-        };
-        const abort = () => {
-            if (aborting)
-                return;
-            aborting = true;
-            termination = terminateGitChild(child, closed);
-        };
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGKILL");
-        }, process.timeoutMs);
-        options.signal?.addEventListener("abort", abort, { once: true });
-        if (options.signal?.aborted)
-            abort();
-        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-        child.on("error", (error) => {
-            Object.assign(error, { gitCwd: process.cwd });
-            finish({ stdout: Buffer.concat(stdoutChunks), stderr: Buffer.concat(stderrChunks), status: null, error });
-        });
-        child.on("close", async (code, signal) => {
-            if (termination)
-                await termination;
-            const stdout = Buffer.concat(stdoutChunks);
-            const stderr = Buffer.concat(stderrChunks);
-            if (timedOut)
-                return finish({ stdout, stderr, status: null, error: new Error("git timed out") });
-            if (signal) {
-                const error = options.signal?.aborted
-                    ? options.signal.reason instanceof Error ? options.signal.reason : new DOMException("The operation was aborted", "AbortError")
-                    : new Error(`git exited from signal ${signal}`);
-                return finish({ stdout, stderr, status: null, error });
-            }
-            finish({ stdout, stderr, status: code });
-        });
-        if (options.input === undefined)
-            child.stdin?.end();
-        else if (typeof options.input === "string")
-            child.stdin?.end(options.input, "utf8");
-        else
-            child.stdin?.end(options.input);
-    });
-}
-export async function runGitProcess(cwd, args, options = {}) {
-    const result = await runGitProcessBytes(cwd, args, options);
-    return {
-        stdout: result.stdout.toString("utf8"),
-        stderr: result.stderr.toString("utf8"),
-        status: result.status,
-        ...(result.error ? { error: result.error } : {}),
-    };
-}
-/** Throwing Git process mouth for commands whose non-zero exit is exceptional. */
-export async function runGitOrThrow(cwd, args, options = {}) {
-    const result = await runGitProcess(cwd, args, options);
-    const error = processError({
-        stdout: Buffer.from(result.stdout),
-        stderr: Buffer.from(result.stderr),
-        status: result.status,
-        ...(result.error ? { error: result.error } : {}),
-    });
-    if (error)
-        throw error;
-    return result;
-}

package/build/git/refs.js

@@ -1,250 +0,0 @@
-import { isFullGitObjectId, runGitProcess, wrapGitError, } from "./core.js";
-/** Normalize a configured branch to the sole local-branch ref spelling. */
-export function normalizeLocalBranchRef(branch) {
-    return branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`;
-}
-export const REF_TRANSACTION_CAS_MISMATCH = "REF_TRANSACTION_CAS_MISMATCH";
-export const REF_TRANSACTION_NOT_COMMITTED = "REF_TRANSACTION_NOT_COMMITTED";
-export const REF_TRANSACTION_INDETERMINATE = "REF_TRANSACTION_INDETERMINATE";
-export class RefTransactionError extends Error {
-    code = "REF_TRANSACTION_FAILED";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "RefTransactionError";
-    }
-}
-function isMissingExactRef(result) {
-    return !result.error
-        && result.stdout === ""
-        && result.status === 1;
-}
-function parseShowRefRows(output) {
-    const lines = output.split(/\r?\n/);
-    if (lines.at(-1) === "")
-        lines.pop();
-    if (lines.length === 0 || lines.some((line) => line.length === 0))
-        return null;
-    const rows = [];
-    for (const line of lines) {
-        const separator = line.indexOf(" ");
-        const objectId = separator < 0 ? "" : line.slice(0, separator);
-        const ref = separator < 0 ? "" : line.slice(separator + 1);
-        if (!isFullGitObjectId(objectId) || !/^refs\/\S+$/.test(ref))
-            return null;
-        rows.push({ objectId, ref });
-    }
-    return rows;
-}
-function throwGitProcessFailure(commandLabel, result, cwd) {
-    if (result.error?.name === "AbortError")
-        throw result.error;
-    const failure = result.error ?? Object.assign(new Error(result.stderr || `git ${commandLabel} exited ${result.status}`), {
-        stderr: result.stderr,
-        stdout: result.stdout,
-    });
-    throw wrapGitError(commandLabel, failure, cwd);
-}
-/**
- * Resolve only a local branch through the argv-based Git boundary. A configured
- * short name is never allowed to fall through Git's revision search rules.
- */
-export async function resolveLocalBranchHead(cwd, branch, run = runGitProcess) {
-    const ref = normalizeLocalBranchRef(branch);
-    const result = await run(cwd, ["show-ref", ref]);
-    if (isMissingExactRef(result))
-        return null;
-    if (result.status === 0) {
-        const exactRows = parseShowRefRows(result.stdout)?.filter((row) => row.ref === ref);
-        if (exactRows?.length === 1) {
-            return { ref, head: exactRows[0].objectId };
-        }
-    }
-    return throwGitProcessFailure(`show-ref ${ref}`, result, cwd);
-}
-/** Resolve an exact set of direct refs with one Git process. */
-export async function resolveExactRefHeads(cwd, refs, run = runGitProcess) {
-    const unique = [...new Set(refs.map((ref) => normalizeLocalBranchRef(ref)))];
-    if (unique.length === 0)
-        return new Map();
-    const result = await run(cwd, ["show-ref", ...unique]);
-    if (result.error || (result.status !== 0 && result.status !== 1)) {
-        return throwGitProcessFailure(`show-ref ${unique.join(" ")}`, result, cwd);
-    }
-    const rows = result.stdout === "" ? [] : parseShowRefRows(result.stdout);
-    if (rows === null)
-        return throwGitProcessFailure(`show-ref ${unique.join(" ")}`, result, cwd);
-    const requested = new Set(unique);
-    const found = new Map();
-    for (const row of rows) {
-        if (!requested.has(row.ref) || found.has(row.ref)) {
-            return throwGitProcessFailure(`show-ref ${unique.join(" ")}`, {
-                ...result,
-                status: 2,
-                stderr: `show-ref returned an invalid exact value for ${row.ref}`,
-            }, cwd);
-        }
-        found.set(row.ref, row.objectId);
-    }
-    return new Map(unique.map((ref) => [ref, found.get(ref) ?? null]));
-}
-async function validateTransactionOperation(operation, objectIdLength) {
-    if (!/^refs\/(?![./])(?!.*(?:\.\.|@\{|[~^:?*\\\[\x00-\x20\x7f]))(?!.*\/\.)(?!.*\.lock(?:\/|$))(?!.*\/$).+$/.test(operation.ref)) {
-        throw new RefTransactionError(`invalid transaction ref ${JSON.stringify(operation.ref)}`);
-    }
-    const objectIds = operation.kind === "update"
-        ? [["new", operation.newOid], ["old", operation.expectedOldOid]]
-        : [["old", operation.expectedOldOid]];
-    for (const [label, oid] of objectIds) {
-        if (oid !== null && (oid.length !== objectIdLength || !isFullGitObjectId(oid))) {
-            throw new RefTransactionError(`invalid ${label} object ID for ${operation.ref}`);
-        }
-    }
-}
-function formatTransactionOperation(operation, zero) {
-    if (operation.kind === "delete")
-        return `delete ${operation.ref} ${operation.expectedOldOid}`;
-    if (operation.kind === "verify")
-        return `verify ${operation.ref} ${operation.expectedOldOid ?? zero}`;
-    return `update ${operation.ref} ${operation.newOid} ${operation.expectedOldOid ?? zero}`;
-}
-function isUnambiguousCasRefusal(result) {
-    if (result.status === null || result.status === 0 || result.error)
-        return false;
-    return /cannot lock ref '[^']+': (?:is at [0-9a-f]+ but expected [0-9a-f]+|reference already exists|reference is missing but expected [0-9a-f]+)/i.test(result.stderr);
-}
-function isUnableToResolveReference(result) {
-    return result.status !== null
-        && result.status !== 0
-        && !result.error
-        && /cannot lock ref '[^']+': unable to resolve reference/i.test(result.stderr);
-}
-function hasConclusiveMissingExpectedReference(observations) {
-    return observations.some((observation) => (observation.expectedOldOid !== null
-        && observation.observed.status === "absent"));
-}
-function transactionFailureCause(result) {
-    return result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-}
-function requestedNewOid(operation) {
-    if (operation.kind === "update")
-        return operation.newOid;
-    if (operation.kind === "delete")
-        return null;
-    return operation.expectedOldOid;
-}
-function observationMatches(observation, expectedOid) {
-    if (observation.observed.status === "unknown")
-        return false;
-    if (expectedOid === null)
-        return observation.observed.status === "absent";
-    return observation.observed.status === "present" && observation.observed.objectId === expectedOid;
-}
-async function observeExactRef(cwd, ref) {
-    try {
-        const symbolic = await runGitProcess(cwd, ["symbolic-ref", "--quiet", ref]);
-        if (symbolic.status === 0 && !symbolic.error) {
-            const target = symbolic.stdout.trim();
-            return { status: "unknown", cause: `symbolic ref targets ${target || "an unreported ref"}` };
-        }
-        if (symbolic.error || (symbolic.status !== 1 && symbolic.status !== 0)) {
-            const cause = symbolic.stderr.trim() || symbolic.error?.message || `symbolic-ref exited ${String(symbolic.status)}`;
-            return { status: "unknown", cause };
-        }
-        const exact = await runGitProcess(cwd, ["show-ref", ref]);
-        if (exact.status === 0 && !exact.error) {
-            const exactRows = parseShowRefRows(exact.stdout)?.filter((row) => row.ref === ref);
-            if (exactRows?.length === 1) {
-                return { status: "present", objectId: exactRows[0].objectId };
-            }
-            return { status: "unknown", cause: `show-ref returned an invalid exact value for ${ref}` };
-        }
-        if (!exact.error && exact.status === 1 && exact.stdout === "")
-            return { status: "absent" };
-        const cause = exact.stderr.trim() || exact.error?.message || `show-ref exited ${String(exact.status)}`;
-        return { status: "unknown", cause };
-    }
-    catch (error) {
-        return { status: "unknown", cause: error instanceof Error ? error.message : String(error) };
-    }
-}
-async function observeTransactionRefs(cwd, operations) {
-    return await Promise.all(operations.map(async (operation) => ({
-        ref: operation.ref,
-        expectedOldOid: operation.expectedOldOid,
-        requestedNewOid: requestedNewOid(operation),
-        observed: await observeExactRef(cwd, operation.ref),
-    })));
-}
-/**
- * Atomically apply a closed set of ref operations. Every old-OID assertion is
- * submitted inside the same update-ref transaction as its operation; no
- * preflight read is used as authority.
- */
-export async function commitRefTransaction(cwd, operations, objectIdLength, options = {}) {
-    if (operations.length === 0)
-        throw new RefTransactionError("a ref transaction requires at least one operation");
-    const seen = new Set();
-    for (const operation of operations) {
-        await validateTransactionOperation(operation, objectIdLength);
-        if (seen.has(operation.ref))
-            throw new RefTransactionError(`duplicate transaction ref ${operation.ref}`);
-        seen.add(operation.ref);
-    }
-    const zero = "0".repeat(objectIdLength);
-    const input = [
-        "start",
-        ...operations.map((operation) => formatTransactionOperation(operation, zero)),
-        "prepare",
-        "commit",
-        "",
-    ].join("\n");
-    let result;
-    try {
-        result = await (options.run ?? runGitProcess)(cwd, ["update-ref", "--no-deref", "--stdin"], { input });
-    }
-    catch (error) {
-        result = {
-            stdout: "",
-            stderr: "",
-            status: null,
-            error: error instanceof Error ? error : new Error(String(error)),
-        };
-    }
-    if (result.status === 0 && !result.error) {
-        return { status: "committed", proof: "process-success", operations, observations: [] };
-    }
-    const observations = await observeTransactionRefs(cwd, operations);
-    const allPre = observations.every((observation) => observationMatches(observation, observation.expectedOldOid));
-    const allPost = observations.every((observation) => observationMatches(observation, observation.requestedNewOid));
-    const changesAuthority = operations.some((operation) => requestedNewOid(operation) !== operation.expectedOldOid);
-    const cause = transactionFailureCause(result);
-    if (allPost && changesAuthority) {
-        return { status: "committed", proof: "observed-post-state", operations, observations };
-    }
-    if (isUnambiguousCasRefusal(result)
-        || (isUnableToResolveReference(result) && hasConclusiveMissingExpectedReference(observations))) {
-        return {
-            status: "refused",
-            code: REF_TRANSACTION_CAS_MISMATCH,
-            operations,
-            observations,
-            cause,
-        };
-    }
-    if (allPre && changesAuthority) {
-        return {
-            status: "refused",
-            code: REF_TRANSACTION_NOT_COMMITTED,
-            operations,
-            observations,
-            cause,
-        };
-    }
-    return {
-        status: "indeterminate",
-        code: REF_TRANSACTION_INDETERMINATE,
-        operations,
-        observations,
-        cause,
-    };
-}

package/build/git/staging.js

@@ -1,79 +0,0 @@
-import { getConfig } from "../config/env.js";
-import { wrapGitError } from "./core.js";
-import { runGitOrThrow } from "./process.js";
-async function run(cwd, args, label) {
-    try {
-        return (await runGitOrThrow(cwd, args)).stdout;
-    }
-    catch (error) {
-        throw wrapGitError(label, error, cwd);
-    }
-}
-export async function addFiles(cwd, files) {
-    await run(cwd, ["add", "--", ...(typeof files === "string" ? [files] : files)], "add");
-}
-export async function addFilesForce(cwd, files) {
-    await run(cwd, ["add", "--force", "--", ...files], "add --force");
-}
-export async function addUpdatedFiles(cwd) {
-    await run(cwd, ["add", "-u"], "add -u");
-}
-export async function resetStaging(cwd) {
-    await run(cwd, ["reset"], "reset");
-}
-function commitArgs(message, allowEmpty = false) {
-    const { noVerify: skipVerify, noGpgSign } = getConfig().git;
-    const args = ["commit", ...(allowEmpty ? ["--allow-empty"] : []), "-m", message];
-    if (skipVerify)
-        args.push("--no-verify");
-    if (noGpgSign)
-        args.push("--no-gpg-sign");
-    return args;
-}
-export async function commit(cwd, message) {
-    const args = commitArgs(message);
-    await run(cwd, args, args.join(" "));
-}
-export async function commitAllowEmpty(cwd, message) {
-    const args = commitArgs(message, true);
-    await run(cwd, args, args.join(" "));
-}
-export async function revertCommit(cwd, commitHash, message) {
-    await run(cwd, ["revert", "--no-commit", commitHash], `revert --no-commit ${commitHash}`);
-    await commit(cwd, message);
-}
-export async function merge(cwd, branchName, message, options = {}) {
-    const { squash = true } = options;
-    const { noVerify: skipVerify, noGpgSign } = getConfig().git;
-    if (squash) {
-        await mergeSquashStaged(cwd, branchName);
-        await commitAllowEmpty(cwd, message);
-        return;
-    }
-    const args = ["merge", branchName, "--no-ff", "--no-edit", "-m", message];
-    if (skipVerify)
-        args.push("--no-verify");
-    if (noGpgSign)
-        args.push("--no-gpg-sign");
-    await run(cwd, args, `merge ${args.slice(1).join(" ")}`);
-}
-export async function mergeSquashStaged(cwd, branchName) {
-    const args = ["merge", "--squash", branchName];
-    await run(cwd, args, args.join(" "));
-}
-export async function restoreFilesFromHead(cwd, files) {
-    if (files.length === 0)
-        return;
-    const args = ["restore", "--source=HEAD", "--staged", "--worktree", "--", ...files];
-    await run(cwd, args, args.join(" "));
-}
-export async function getUnmergedFiles(cwd) {
-    const output = await run(cwd, ["diff", "--name-only", "--diff-filter=U", "-z"], "diff --name-only --diff-filter=U");
-    return Array.from(new Set(output.split("\0").filter((file) => file.length > 0)));
-}
-export async function getLatestCommitHash(cwd) {
-    return (await run(cwd, ["rev-parse", "--short", "HEAD"], "rev-parse --short HEAD")).trim();
-}
-export async function createTagAtHead(cwd, tagName) {
-    await run(cwd, ["tag", tagName, "HEAD"], `tag ${tagName} HEAD`);
-}