@narumitw/pi-sync 0.50.2 → 0.51.0

package/src/backends/git/git-runner.ts

@@ -5,272 +5,255 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_OUTPUT_LIMIT = 1024 * 1024;
 
 export interface GitRunOptions {
-	gitDir?: string;
-	cwd?: string;
-	input?: Buffer | string;
-	env?: NodeJS.ProcessEnv;
-	signal?: AbortSignal;
-	timeoutMs?: number;
-	maxOutputBytes?: number;
-	allowFileProtocol?: boolean;
+  gitDir?: string;
+  cwd?: string;
+  input?: Buffer | string;
+  env?: NodeJS.ProcessEnv;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+  allowFileProtocol?: boolean;
 }
 
 export interface GitRunResult {
-	stdout: Buffer;
-	stderr: Buffer;
+  stdout: Buffer;
+  stderr: Buffer;
 }
 
 export class GitCommandError extends Error {
-	readonly code = "GIT_COMMAND_FAILED";
-	constructor(
-		message: string,
-		readonly exitCode: number | null,
-		readonly stderr: string,
-		options?: ErrorOptions,
-	) {
-		super(message, options);
-		this.name = "GitCommandError";
-	}
+  readonly code = "GIT_COMMAND_FAILED";
+  constructor(
+    message: string,
+    readonly exitCode: number | null,
+    readonly stderr: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "GitCommandError";
+  }
 }
 
 export async function runGit(args: string[], options: GitRunOptions = {}): Promise<GitRunResult> {
-	throwIfAborted(options.signal);
-	const hooksPath = process.platform === "win32" ? "NUL" : "/dev/null";
-	const protocolArgs = [
-		"-c",
-		`core.hooksPath=${hooksPath}`,
-		"-c",
-		"gc.auto=0",
-		"-c",
-		"maintenance.auto=false",
-		"-c",
-		"protocol.allow=never",
-		"-c",
-		"protocol.https.allow=always",
-		"-c",
-		"protocol.ssh.allow=always",
-	];
-	if (options.allowFileProtocol) protocolArgs.push("-c", "protocol.file.allow=always");
-	const commandArgs = [
-		...(options.gitDir ? [`--git-dir=${options.gitDir}`] : []),
-		...protocolArgs,
-		...args,
-	];
-	const inheritedEnvironment = Object.fromEntries(
-		Object.entries(process.env).filter(
-			([key]) =>
-				!key.startsWith("GIT_") &&
-				key !== "PAGER" &&
-				key !== "EDITOR" &&
-				key !== "VISUAL" &&
-				key !== "SSH_ASKPASS" &&
-				key !== "SSH_ASKPASS_REQUIRE",
-		),
-	);
-	const allowedGitOverrides = new Set([
-		"GIT_INDEX_FILE",
-		"GIT_AUTHOR_NAME",
-		"GIT_AUTHOR_EMAIL",
-		"GIT_AUTHOR_DATE",
-		"GIT_COMMITTER_NAME",
-		"GIT_COMMITTER_EMAIL",
-		"GIT_COMMITTER_DATE",
-	]);
-	const suppliedEnvironment = Object.fromEntries(
-		Object.entries(options.env ?? {}).filter(
-			([key]) => !key.startsWith("GIT_") || allowedGitOverrides.has(key),
-		),
-	);
-	const env: NodeJS.ProcessEnv = {
-		...inheritedEnvironment,
-		...suppliedEnvironment,
-		LC_ALL: "C",
-		LANG: "C",
-		GIT_CONFIG_NOSYSTEM: "1",
-		GIT_TERMINAL_PROMPT: "0",
-		GCM_INTERACTIVE: "Never",
-		GIT_PAGER: "cat",
-		PAGER: "cat",
-		GIT_EDITOR: "true",
-		EDITOR: "true",
-		VISUAL: "true",
-		GIT_ASKPASS: "",
-		SSH_ASKPASS: "",
-		SSH_ASKPASS_REQUIRE: "never",
-		GIT_SSH_COMMAND: "ssh -oBatchMode=yes",
-	};
-	const child = spawn("git", commandArgs, {
-		cwd: options.cwd,
-		env,
-		stdio: ["pipe", "pipe", "pipe"],
-		detached: process.platform !== "win32",
-		windowsHide: true,
-	});
-	const stdout: Buffer[] = [];
-	const stderr: Buffer[] = [];
-	let total = 0;
-	let settled = false;
-	let terminationError: Error | undefined;
-	let escalationTimer: NodeJS.Timeout | undefined;
-	const limit = options.maxOutputBytes ?? DEFAULT_OUTPUT_LIMIT;
+  throwIfAborted(options.signal);
+  const hooksPath = process.platform === "win32" ? "NUL" : "/dev/null";
+  const protocolArgs = [
+    "-c",
+    `core.hooksPath=${hooksPath}`,
+    "-c",
+    "gc.auto=0",
+    "-c",
+    "maintenance.auto=false",
+    "-c",
+    "protocol.allow=never",
+    "-c",
+    "protocol.https.allow=always",
+    "-c",
+    "protocol.ssh.allow=always",
+  ];
+  if (options.allowFileProtocol) protocolArgs.push("-c", "protocol.file.allow=always");
+  const commandArgs = [...(options.gitDir ? [`--git-dir=${options.gitDir}`] : []), ...protocolArgs, ...args];
+  const inheritedEnvironment = Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([key]) =>
+        !key.startsWith("GIT_") &&
+        key !== "PAGER" &&
+        key !== "EDITOR" &&
+        key !== "VISUAL" &&
+        key !== "SSH_ASKPASS" &&
+        key !== "SSH_ASKPASS_REQUIRE",
+    ),
+  );
+  const allowedGitOverrides = new Set([
+    "GIT_INDEX_FILE",
+    "GIT_AUTHOR_NAME",
+    "GIT_AUTHOR_EMAIL",
+    "GIT_AUTHOR_DATE",
+    "GIT_COMMITTER_NAME",
+    "GIT_COMMITTER_EMAIL",
+    "GIT_COMMITTER_DATE",
+  ]);
+  const suppliedEnvironment = Object.fromEntries(
+    Object.entries(options.env ?? {}).filter(([key]) => !key.startsWith("GIT_") || allowedGitOverrides.has(key)),
+  );
+  const env: NodeJS.ProcessEnv = {
+    ...inheritedEnvironment,
+    ...suppliedEnvironment,
+    LC_ALL: "C",
+    LANG: "C",
+    GIT_CONFIG_NOSYSTEM: "1",
+    GIT_TERMINAL_PROMPT: "0",
+    GCM_INTERACTIVE: "Never",
+    GIT_PAGER: "cat",
+    PAGER: "cat",
+    GIT_EDITOR: "true",
+    EDITOR: "true",
+    VISUAL: "true",
+    GIT_ASKPASS: "",
+    SSH_ASKPASS: "",
+    SSH_ASKPASS_REQUIRE: "never",
+    GIT_SSH_COMMAND: "ssh -oBatchMode=yes",
+  };
+  const child = spawn("git", commandArgs, {
+    cwd: options.cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: process.platform !== "win32",
+    windowsHide: true,
+  });
+  const stdout: Buffer[] = [];
+  const stderr: Buffer[] = [];
+  let total = 0;
+  let settled = false;
+  let terminationError: Error | undefined;
+  let escalationTimer: NodeJS.Timeout | undefined;
+  const limit = options.maxOutputBytes ?? DEFAULT_OUTPUT_LIMIT;
 
-	const terminate = (error: Error) => {
-		if (settled || terminationError) return;
-		terminationError = error;
-		if (child.pid && process.platform !== "win32") {
-			try {
-				process.kill(-child.pid, "SIGTERM");
-			} catch {
-				child.kill("SIGTERM");
-			}
-		} else {
-			child.kill("SIGTERM");
-			if (child.pid && process.platform === "win32") {
-				const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
-					stdio: "ignore",
-					windowsHide: true,
-				});
-				killer.on("error", () => undefined);
-				killer.unref();
-			}
-		}
-		escalationTimer = setTimeout(() => {
-			if (settled) return;
-			if (child.pid && process.platform !== "win32") {
-				try {
-					process.kill(-child.pid, "SIGKILL");
-				} catch {
-					child.kill("SIGKILL");
-				}
-			} else {
-				child.kill("SIGKILL");
-			}
-		}, 2_000);
-	};
-	const collect = (target: Buffer[]) => (chunk: Buffer) => {
-		total += chunk.byteLength;
-		if (total > limit) {
-			terminate(new Error(`Git output exceeds the ${limit}-byte limit.`));
-			return;
-		}
-		target.push(Buffer.from(chunk));
-	};
-	child.stdout.on("data", collect(stdout));
-	child.stderr.on("data", collect(stderr));
-	child.stdin.on("error", () => undefined);
-	child.stdin.end(options.input);
-	const onAbort = () =>
-		terminate(
-			options.signal?.reason instanceof Error
-				? options.signal.reason
-				: new DOMException("The operation was aborted", "AbortError"),
-		);
-	options.signal?.addEventListener("abort", onAbort, { once: true });
-	const timer = setTimeout(
-		() =>
-			terminate(
-				new Error(`Git command timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms.`),
-			),
-		options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-	);
+  const terminate = (error: Error) => {
+    if (settled || terminationError) return;
+    terminationError = error;
+    if (child.pid && process.platform !== "win32") {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+    } else {
+      child.kill("SIGTERM");
+      if (child.pid && process.platform === "win32") {
+        const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+          stdio: "ignore",
+          windowsHide: true,
+        });
+        killer.on("error", () => undefined);
+        killer.unref();
+      }
+    }
+    escalationTimer = setTimeout(() => {
+      if (settled) return;
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      } else {
+        child.kill("SIGKILL");
+      }
+    }, 2_000);
+  };
+  const collect = (target: Buffer[]) => (chunk: Buffer) => {
+    total += chunk.byteLength;
+    if (total > limit) {
+      terminate(new Error(`Git output exceeds the ${limit}-byte limit.`));
+      return;
+    }
+    target.push(Buffer.from(chunk));
+  };
+  child.stdout.on("data", collect(stdout));
+  child.stderr.on("data", collect(stderr));
+  child.stdin.on("error", () => undefined);
+  child.stdin.end(options.input);
+  const onAbort = () =>
+    terminate(
+      options.signal?.reason instanceof Error
+        ? options.signal.reason
+        : new DOMException("The operation was aborted", "AbortError"),
+    );
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(
+    () => terminate(new Error(`Git command timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms.`)),
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+  );
 
-	let result: GitRunResult;
-	try {
-		result = await new Promise<GitRunResult>((resolve, reject) => {
-			child.once("error", reject);
-			child.once("close", (code) => {
-				settled = true;
-				if (escalationTimer) clearTimeout(escalationTimer);
-				const stdoutBuffer = Buffer.concat(stdout);
-				const stderrBuffer = Buffer.concat(stderr);
-				if (terminationError) {
-					reject(terminationError);
-					return;
-				}
-				if (code !== 0) {
-					const stderrText = stderrBuffer.toString("utf8").trim();
-					reject(
-						new GitCommandError(
-							stderrText || `Git exited with status ${code ?? "unknown"}.`,
-							code,
-							stderrText,
-						),
-					);
-					return;
-				}
-				resolve({ stdout: stdoutBuffer, stderr: stderrBuffer });
-			});
-		});
-	} finally {
-		clearTimeout(timer);
-		if (escalationTimer) clearTimeout(escalationTimer);
-		options.signal?.removeEventListener("abort", onAbort);
-	}
-	return result;
+  let result: GitRunResult;
+  try {
+    result = await new Promise<GitRunResult>((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", (code) => {
+        settled = true;
+        if (escalationTimer) clearTimeout(escalationTimer);
+        const stdoutBuffer = Buffer.concat(stdout);
+        const stderrBuffer = Buffer.concat(stderr);
+        if (terminationError) {
+          reject(terminationError);
+          return;
+        }
+        if (code !== 0) {
+          const stderrText = stderrBuffer.toString("utf8").trim();
+          reject(new GitCommandError(stderrText || `Git exited with status ${code ?? "unknown"}.`, code, stderrText));
+          return;
+        }
+        resolve({ stdout: stdoutBuffer, stderr: stderrBuffer });
+      });
+    });
+  } finally {
+    clearTimeout(timer);
+    if (escalationTimer) clearTimeout(escalationTimer);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+  return result;
 }
 
 export function parseGitBlobBatch(output: Buffer, expectedCount: number, maxContentBytes: number) {
-	if (!Number.isSafeInteger(expectedCount) || expectedCount < 0) {
-		throw new Error("Invalid Git batch object count.");
-	}
-	if (!Number.isSafeInteger(maxContentBytes) || maxContentBytes < 0) {
-		throw new Error("Invalid Git batch content limit.");
-	}
-	const blobs: Buffer[] = [];
-	let offset = 0;
-	let contentBytes = 0;
-	for (let index = 0; index < expectedCount; index += 1) {
-		const headerEnd = output.indexOf(0x0a, offset);
-		if (headerEnd < 0) throw new Error("Git cat-file batch response is truncated.");
-		const header = output.subarray(offset, headerEnd).toString("utf8");
-		if (header.endsWith(" missing")) throw new Error("Git cat-file batch object is missing.");
-		const match = /^(?<object>[0-9a-f]{40}) blob (?<size>0|[1-9][0-9]*)$/u.exec(header);
-		if (!match?.groups) throw new Error("Git cat-file batch response is malformed.");
-		const size = Number(match.groups.size);
-		if (!Number.isSafeInteger(size)) throw new Error("Git cat-file batch size is malformed.");
-		contentBytes += size;
-		if (contentBytes > maxContentBytes) {
-			throw new Error(`Git cat-file batch content exceeds the ${maxContentBytes}-byte limit.`);
-		}
-		const contentStart = headerEnd + 1;
-		const contentEnd = contentStart + size;
-		if (contentEnd >= output.length) throw new Error("Git cat-file batch response is truncated.");
-		if (output[contentEnd] !== 0x0a) {
-			throw new Error("Git cat-file batch response is malformed.");
-		}
-		blobs.push(Buffer.from(output.subarray(contentStart, contentEnd)));
-		offset = contentEnd + 1;
-	}
-	if (offset !== output.length) throw new Error("Git cat-file batch response has trailing data.");
-	return blobs;
+  if (!Number.isSafeInteger(expectedCount) || expectedCount < 0) {
+    throw new Error("Invalid Git batch object count.");
+  }
+  if (!Number.isSafeInteger(maxContentBytes) || maxContentBytes < 0) {
+    throw new Error("Invalid Git batch content limit.");
+  }
+  const blobs: Buffer[] = [];
+  let offset = 0;
+  let contentBytes = 0;
+  for (let index = 0; index < expectedCount; index += 1) {
+    const headerEnd = output.indexOf(0x0a, offset);
+    if (headerEnd < 0) throw new Error("Git cat-file batch response is truncated.");
+    const header = output.subarray(offset, headerEnd).toString("utf8");
+    if (header.endsWith(" missing")) throw new Error("Git cat-file batch object is missing.");
+    const match = /^(?<object>[0-9a-f]{40}) blob (?<size>0|[1-9][0-9]*)$/u.exec(header);
+    if (!match?.groups) throw new Error("Git cat-file batch response is malformed.");
+    const size = Number(match.groups.size);
+    if (!Number.isSafeInteger(size)) throw new Error("Git cat-file batch size is malformed.");
+    contentBytes += size;
+    if (contentBytes > maxContentBytes) {
+      throw new Error(`Git cat-file batch content exceeds the ${maxContentBytes}-byte limit.`);
+    }
+    const contentStart = headerEnd + 1;
+    const contentEnd = contentStart + size;
+    if (contentEnd >= output.length) throw new Error("Git cat-file batch response is truncated.");
+    if (output[contentEnd] !== 0x0a) {
+      throw new Error("Git cat-file batch response is malformed.");
+    }
+    blobs.push(Buffer.from(output.subarray(contentStart, contentEnd)));
+    offset = contentEnd + 1;
+  }
+  if (offset !== output.length) throw new Error("Git cat-file batch response has trailing data.");
+  return blobs;
 }
 
 export async function readGitBlobs(
-	objects: string[],
-	options: Omit<GitRunOptions, "input" | "maxOutputBytes"> & { maxOutputBytes: number },
+  objects: string[],
+  options: Omit<GitRunOptions, "input" | "maxOutputBytes"> & { maxOutputBytes: number },
 ) {
-	if (objects.length === 0) return [];
-	if (!Number.isSafeInteger(options.maxOutputBytes) || options.maxOutputBytes < 0) {
-		throw new Error("Invalid Git batch output limit.");
-	}
-	if (objects.some((object) => !/^[0-9a-f]{40}$/u.test(object))) {
-		throw new Error("Invalid Git blob object id.");
-	}
-	const protocolOverhead = objects.length * 96;
-	if (!Number.isSafeInteger(protocolOverhead + options.maxOutputBytes)) {
-		throw new Error("Invalid Git batch output limit.");
-	}
-	const result = await runGit(["cat-file", "--batch"], {
-		...options,
-		input: `${objects.join("\n")}\n`,
-		maxOutputBytes: options.maxOutputBytes + protocolOverhead,
-	});
-	return parseGitBlobBatch(result.stdout, objects.length, options.maxOutputBytes);
+  if (objects.length === 0) return [];
+  if (!Number.isSafeInteger(options.maxOutputBytes) || options.maxOutputBytes < 0) {
+    throw new Error("Invalid Git batch output limit.");
+  }
+  if (objects.some((object) => !/^[0-9a-f]{40}$/u.test(object))) {
+    throw new Error("Invalid Git blob object id.");
+  }
+  const protocolOverhead = objects.length * 96;
+  if (!Number.isSafeInteger(protocolOverhead + options.maxOutputBytes)) {
+    throw new Error("Invalid Git batch output limit.");
+  }
+  const result = await runGit(["cat-file", "--batch"], {
+    ...options,
+    input: `${objects.join("\n")}\n`,
+    maxOutputBytes: options.maxOutputBytes + protocolOverhead,
+  });
+  return parseGitBlobBatch(result.stdout, objects.length, options.maxOutputBytes);
 }
 
 function throwIfAborted(signal?: AbortSignal) {
-	if (!signal?.aborted) return;
-	throw signal.reason instanceof Error
-		? signal.reason
-		: new DOMException("The operation was aborted", "AbortError");
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
 }