@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/git/process.js

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

@@ -61,10 +61,35 @@ export async function resolveLocalBranchHead(cwd, branch, run = runGitProcess) {
     }
     return throwGitProcessFailure(`show-ref ${ref}`, result, cwd);
 }
-async function validateTransactionOperation(cwd, operation, objectIdLength) {
-    const refCheck = await runGitProcess(cwd, ["check-ref-format", operation.ref]);
-    if (refCheck.status !== 0 || refCheck.error) {
-        throw new RefTransactionError(`invalid transaction ref ${JSON.stringify(operation.ref)}`, { cause: refCheck.error });
+/** 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]]
@@ -160,7 +185,7 @@ export async function commitRefTransaction(cwd, operations, objectIdLength, opti
         throw new RefTransactionError("a ref transaction requires at least one operation");
     const seen = new Set();
     for (const operation of operations) {
-        await validateTransactionOperation(cwd, operation, objectIdLength);
+        await validateTransactionOperation(operation, objectIdLength);
         if (seen.has(operation.ref))
             throw new RefTransactionError(`duplicate transaction ref ${operation.ref}`);
         seen.add(operation.ref);

package/build/git/staging.js

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

package/build/git/streaming-batch.js

@@ -1,7 +1,5 @@
-import { spawn } from "node:child_process";
 import { isFullGitObjectId } from "./core.js";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-import { gitProcessEnv, resolveGitTimeoutMs, terminateGitChild, } from "./core.js";
+import { openGitProcess, terminateGitChild, } from "./process.js";
 /** Default long-lived batch argv. One-shot calls must not use this gate. */
 export const GIT_STREAMING_BATCH_DEFAULT_ARGS = ["cat-file", "--batch"];
 /** Safety cap for a single response header line before the body frame. */
@@ -43,7 +41,8 @@ class BufferedReader {
                 if (newline > maxBytes) {
                     throw new GitStreamingBatchFramingError(`git streaming batch header exceeds ${maxBytes} bytes`);
                 }
-                const line = this.#buffer.subarray(0, newline).toString("ascii");
+                const rawLine = this.#buffer.subarray(0, newline);
+                const line = rawLine.subarray(0, rawLine.length > 0 && rawLine[rawLine.length - 1] === 0x0d ? -1 : rawLine.length).toString("ascii");
                 this.#buffer = this.#buffer.subarray(newline + 1);
                 return line;
             }
@@ -114,10 +113,6 @@ export class GitStreamingBatchSession {
         });
         this.#maxHeaderBytes = maxHeaderBytes;
         this.#signal = signal;
-        this.#abortListener = () => this.abort();
-        signal?.addEventListener("abort", this.#abortListener, { once: true });
-        if (signal?.aborted)
-            this.abort();
         this.#child.stderr.on("data", (chunk) => this.#stderr.push(chunk));
         this.#child.stdin.on("error", (error) => {
             this.#inputError = error;
@@ -130,6 +125,10 @@ export class GitStreamingBatchSession {
                 resolve({ code, signal });
             });
         });
+        this.#abortListener = () => this.abort();
+        signal?.addEventListener("abort", this.#abortListener, { once: true });
+        if (signal?.aborted)
+            this.abort();
     }
     #armTimeout(owner) {
         this.#clearTimeout();
@@ -158,15 +157,9 @@ export class GitStreamingBatchSession {
      */
     static open(cwd, options) {
         const args = options?.args ?? GIT_STREAMING_BATCH_DEFAULT_ARGS;
-        const timeoutMs = options?.timeoutMs ?? resolveGitTimeoutMs();
+        const process = openGitProcess(cwd, args, options);
         const maxHeaderBytes = options?.maxHeaderBytes ?? GIT_STREAMING_BATCH_MAX_HEADER_BYTES;
-        const child = spawn("git", [...args], {
-            cwd: normalizeFilesystemCoordinate(cwd),
-            env: gitProcessEnv(options?.env),
-            shell: false,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        return new GitStreamingBatchSession(cwd, child, timeoutMs, maxHeaderBytes, options?.signal);
+        return new GitStreamingBatchSession(process.cwd, process.child, process.timeoutMs, maxHeaderBytes, options?.signal);
     }
     /**
      * Write one request line and read one framed response record.