claudeup 5.0.1 → 6.0.0

package/src/__tests__/cli-live.test.ts

@@ -0,0 +1,384 @@
+/**
+ * Tests for the live region.
+ *
+ * The invariant worth defending is the ORDER of writes around a permanent line.
+ * `note()` must erase the animated block, write, then repaint. Writing first
+ * puts the line inside the block, where the next repaint's cursor-up counts it
+ * as a frame row and starts eating the scrollback record — a data-loss bug that
+ * looks like a flicker.
+ *
+ * The console-capture suite exists because that ordering was documented as a
+ * rule and the rule was broken in production by code two call layers away
+ * (`plugin-manager`'s stale-marketplace advisory, reached through
+ * `getAvailablePlugins`). A rule spanning a call graph this module does not own
+ * has to be a mechanism, so these tests pin the mechanism.
+ *
+ * The clamps are the other half. A frame line that reaches the terminal's last
+ * column auto-wraps into two rows while the repainter still counts it as one,
+ * so the block walks down the screen a row per frame.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { LiveRegion, withPaused } from "../cli/live.js";
+
+/** A write stream that records instead of drawing. */
+function fakeStream(
+	opts: { isTTY?: boolean; columns?: number; rows?: number } = {},
+) {
+	const writes: string[] = [];
+	const listeners = new Map<string, Array<() => void>>();
+	const stream = {
+		write: (chunk: string) => {
+			writes.push(chunk);
+			return true;
+		},
+		on(event: string, fn: () => void) {
+			const list = listeners.get(event) ?? [];
+			list.push(fn);
+			listeners.set(event, list);
+			return this;
+		},
+		off(event: string, fn: () => void) {
+			const list = (listeners.get(event) ?? []).filter((f) => f !== fn);
+			listeners.set(event, list);
+			return this;
+		},
+		isTTY: opts.isTTY ?? true,
+		columns: opts.columns ?? 80,
+		rows: opts.rows ?? 24,
+	} as unknown as NodeJS.WriteStream & {
+		columns: number;
+		rows: number;
+	};
+	const emit = (event: string) => {
+		for (const fn of listeners.get(event) ?? []) fn();
+	};
+	return { stream, writes, emit, all: () => writes.join("") };
+}
+
+/**
+ * An animated region that needs no timer: paint via `refresh()`.
+ *
+ * `captureConsole` is OFF here. These tests assert on stream writes, and a
+ * region that hijacks the global console would also hijack the test runner's
+ * own reporting. The capture suite below opts back in deliberately.
+ */
+function region(opts: Parameters<typeof fakeStream>[0] = {}) {
+	const fake = fakeStream(opts);
+	const live = new LiveRegion({
+		stream: fake.stream,
+		animate: true,
+		fps: 1000,
+		captureConsole: false,
+	});
+	return { ...fake, live };
+}
+
+describe("non-animated mode — a pipe, CI, or NO_COLOR", () => {
+	test("the transient block is never painted, but the record still prints", () => {
+		const fake = fakeStream({ isTTY: false });
+		const live = new LiveRegion({ stream: fake.stream, animate: false });
+		live.start(() => ["spinning"]);
+		live.refresh();
+		live.note("permanent one");
+		live.stop(["final"]);
+
+		expect(fake.writes).toEqual(["permanent one\n", "final\n"]);
+	});
+
+	test("no escape sequence of any kind reaches a pipe", () => {
+		const fake = fakeStream({ isTTY: false });
+		const live = new LiveRegion({ stream: fake.stream, animate: false });
+		live.start(() => ["frame"]);
+		live.note("line");
+		live.pause();
+		live.resume();
+		live.stop(["done"]);
+		expect(fake.all()).not.toContain("\x1b");
+	});
+
+	test("console is never captured when nothing is being painted", () => {
+		const fake = fakeStream({ isTTY: false });
+		const original = console.log;
+		const live = new LiveRegion({ stream: fake.stream, animate: false });
+		live.start(() => ["frame"]);
+		try {
+			expect(console.log).toBe(original);
+		} finally {
+			live.stop();
+		}
+	});
+});
+
+describe("animated mode", () => {
+	test("start hides the cursor and paints the frame", () => {
+		const { live, all } = region();
+		live.start(() => ["row one", "row two"]);
+		expect(all()).toContain("\x1b[?25l");
+		expect(all()).toContain("row one\nrow two\n");
+		live.stop();
+	});
+
+	test("a repaint erases exactly the rows it painted", () => {
+		const { live, writes } = region();
+		live.start(() => ["a", "b", "c"]);
+		writes.length = 0;
+		live.refresh();
+		// Three rows painted, so three rows up and erase below.
+		expect(writes[0]).toBe("\x1b[3A\x1b[0J");
+		live.stop();
+	});
+
+	test("note erases BEFORE writing, then repaints", () => {
+		const { live, writes } = region();
+		live.start(() => ["frame"]);
+		writes.length = 0;
+		live.note("kept");
+
+		expect(writes[0]).toBe("\x1b[1A\x1b[0J");
+		expect(writes[1]).toBe("kept\n");
+		expect(writes[2]).toBe("frame\n");
+	});
+
+	test("a frame that shrinks does not leave orphaned rows", () => {
+		let rows = ["a", "b", "c"];
+		const { live, writes } = region();
+		live.start(() => rows);
+		rows = ["a"];
+		writes.length = 0;
+		live.refresh();
+		// Erase-below clears the two rows the shorter frame no longer covers.
+		expect(writes[0]).toBe("\x1b[3A\x1b[0J");
+		expect(writes[1]).toBe("a\n");
+		live.stop();
+	});
+
+	test("a line is clipped one column short of the terminal width", () => {
+		const { live, writes } = region({ columns: 20 });
+		live.start(() => ["x".repeat(40)]);
+		const painted = writes.at(-1) ?? "";
+		expect(painted.replace(/\n$/, "")).toHaveLength(19);
+		live.stop();
+	});
+
+	test("the block is capped one row short of the terminal height", () => {
+		const { live, writes } = region({ rows: 6 });
+		live.start(() => Array.from({ length: 20 }, (_, i) => `row ${i}`));
+		const painted = (writes.at(-1) ?? "").split("\n").filter(Boolean);
+		expect(painted).toHaveLength(5);
+		live.stop();
+	});
+
+	test("stop erases the frame and restores the cursor", () => {
+		const { live, writes } = region();
+		live.start(() => ["frame"]);
+		writes.length = 0;
+		live.stop(["record"]);
+		expect(writes[0]).toBe("\x1b[1A\x1b[0J");
+		expect(writes[1]).toBe("record\n");
+		expect(writes[2]).toBe("\x1b[?25h");
+	});
+
+	test("stop with nothing painted still shows the cursor", () => {
+		const { live, all } = region();
+		live.start(() => []);
+		live.stop();
+		expect(all()).toContain("\x1b[?25h");
+	});
+});
+
+describe("resize", () => {
+	test("a resize abandons the old block instead of mis-erasing it", () => {
+		// `painted` is a row count measured at the OLD width. After a narrowing,
+		// the block occupies more rows than it says, so a cursor-up of `painted`
+		// lands inside it and smears. The only safe move is to stop claiming
+		// ownership of those rows.
+		const { live, writes, emit, stream } = region({ columns: 80 });
+		live.start(() => ["x".repeat(70)]);
+		writes.length = 0;
+		(stream as unknown as { columns: number }).columns = 40;
+		emit("resize");
+
+		// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
+		const CURSOR_UP = /\x1b\[\d+A/;
+		expect(writes.some((w) => CURSOR_UP.test(w))).toBe(false);
+		expect(writes.at(-1)?.replace(/\n$/, "")).toHaveLength(39);
+		live.stop();
+	});
+
+	test("the resize listener is removed on stop", () => {
+		const { live, writes, emit } = region();
+		live.start(() => ["frame"]);
+		live.stop();
+		writes.length = 0;
+		emit("resize");
+		expect(writes).toEqual([]);
+	});
+});
+
+describe("handing the terminal over", () => {
+	test("pause erases the block and shows the cursor before the subprocess", () => {
+		const { live, writes } = region();
+		live.start(() => ["frame"]);
+		writes.length = 0;
+		live.pause();
+		expect(writes).toEqual(["\x1b[1A\x1b[0J", "\x1b[?25h"]);
+	});
+
+	test("note does NOT repaint while paused", () => {
+		// A repaint here draws the block underneath output from whatever now owns
+		// the terminal — corrupt, and in the way of a readline prompt.
+		const { live, writes } = region();
+		live.start(() => ["FRAME"]);
+		live.pause();
+		writes.length = 0;
+		live.note("subprocess said something");
+		expect(writes).toEqual(["subprocess said something\n"]);
+	});
+
+	test("resume repaints and re-hides", () => {
+		const { live, writes } = region();
+		live.start(() => ["frame"]);
+		live.pause();
+		writes.length = 0;
+		live.resume();
+		expect(writes[0]).toBe("\x1b[?25l");
+		expect(writes[1]).toBe("frame\n");
+		live.stop();
+	});
+
+	test("withPaused resumes even when the work throws", async () => {
+		const { live, writes } = region();
+		live.start(() => ["frame"]);
+		await expect(
+			withPaused(live, async () => {
+				throw new Error("installer failed");
+			}),
+		).rejects.toThrow("installer failed");
+		// A resume repaint after the throw proves the region was handed back.
+		expect(writes.at(-1)).toBe("frame\n");
+		live.stop();
+	});
+
+	test("withPaused returns the work's value", async () => {
+		const { live } = region();
+		live.start(() => ["frame"]);
+		expect(await withPaused(live, async () => 42)).toBe(42);
+		live.stop();
+	});
+});
+
+describe("console capture — the invariant as a mechanism", () => {
+	/** Console is process-global: every test here must put it back. */
+	let restore: (() => void) | null = null;
+	afterEach(() => {
+		restore?.();
+		restore = null;
+	});
+
+	function capturing(opts: Parameters<typeof fakeStream>[0] = {}) {
+		const out = fakeStream(opts);
+		const err = fakeStream(opts);
+		const live = new LiveRegion({
+			stream: out.stream,
+			errorStream: err.stream,
+			animate: true,
+			fps: 1000,
+		});
+		const original = {
+			log: console.log,
+			info: console.info,
+			warn: console.warn,
+			error: console.error,
+		};
+		restore = () => {
+			live.stop();
+			Object.assign(console, original);
+		};
+		return { live, out, err };
+	}
+
+	test("a bare console.log from anywhere is routed, not left inside the block", () => {
+		// This is the production bug: plugin-manager's stale-marketplace advisory
+		// prints from two call layers below the catalog step. Without capture it
+		// lands under the block, the next cursor-up is short by a row, and the
+		// advisory is erased unread.
+		const { live, out } = capturing();
+		live.start(() => ["FRAME"]);
+		out.writes.length = 0;
+		console.log("ℹ Marketplace magus is stale");
+
+		expect(out.writes).toEqual([
+			"\x1b[1A\x1b[0J",
+			"ℹ Marketplace magus is stale\n",
+			"FRAME\n",
+		]);
+	});
+
+	test("without capture the same call corrupts the block", () => {
+		// The negative control. This is what the code did before the fix, and it
+		// is why documenting the rule was not enough.
+		const out = fakeStream();
+		const live = new LiveRegion({
+			stream: out.stream,
+			animate: true,
+			fps: 1000,
+			captureConsole: false,
+		});
+		live.start(() => ["FRAME"]);
+		out.writes.length = 0;
+		out.stream.write("ℹ Marketplace magus is stale\n"); // an uncaptured write
+		live.refresh();
+		// One row up from a cursor now two rows below the block's start: the
+		// erase begins inside the frame rather than at its top.
+		expect(out.writes[1]).toBe("\x1b[1A\x1b[0J");
+		live.stop();
+	});
+
+	test("stderr stays on stderr", () => {
+		// Silently moving warn/error to stdout would break `2>err.log`.
+		const { live, out, err } = capturing();
+		live.start(() => ["FRAME"]);
+		out.writes.length = 0;
+		err.writes.length = 0;
+		console.warn("a warning");
+		console.error("an error");
+
+		expect(err.writes.filter((w) => !w.startsWith("\x1b"))).toEqual([
+			"a warning\n",
+			"an error\n",
+		]);
+		expect(out.writes.some((w) => w.includes("a warning"))).toBe(false);
+	});
+
+	test("format specifiers and multi-line writes survive", () => {
+		// A newline inside one write is a row the erase arithmetic cannot see,
+		// so it has to be split into separate notes.
+		const { live, out } = capturing();
+		live.start(() => ["FRAME"]);
+		out.writes.length = 0;
+		console.log("%s has %d plugins\nsecond line", "magus", 12);
+
+		expect(out.writes).toContain("magus has 12 plugins\n");
+		expect(out.writes).toContain("second line\n");
+	});
+
+	test("console is released on stop", () => {
+		const original = console.log;
+		const { live } = capturing();
+		live.start(() => ["FRAME"]);
+		expect(console.log).not.toBe(original);
+		live.stop();
+		expect(console.log).toBe(original);
+	});
+
+	test("console is released while paused, so a subprocess writes directly", () => {
+		const original = console.log;
+		const { live } = capturing();
+		live.start(() => ["FRAME"]);
+		live.pause();
+		expect(console.log).toBe(original);
+		live.resume();
+		expect(console.log).not.toBe(original);
+	});
+});

package/src/__tests__/cli-update-view.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for the `claudeup update` report.
+ *
+ * These assert the things a screenshot cannot: that every row lines up at every
+ * data shape, that turning colour off leaves a report someone can still read,
+ * and that no bar lies about what it measures.
+ *
+ * The alignment tests exist because the old report built each row with string
+ * concatenation and `String.padEnd`, which counts escape bytes as columns. Add
+ * one colour to one cell and every column below it shifts — invisible to a
+ * character-level assertion, obvious and ugly on screen.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { setColorEnabled, stripAnsi, width } from "../cli/ansi.js";
+import type { UpdatePlan } from "../services/update-plan.js";
+import {
+	type ApplyState,
+	type Step,
+	applyFrame,
+	applyRow,
+	header,
+	planReport,
+	stepFrame,
+	stepRecord,
+	summaryLine,
+} from "../cli/update-view.js";
+
+afterEach(() => setColorEnabled(null));
+
+// -- fixtures -----------------------------------------------------------------
+
+function plan(over: Partial<UpdatePlan> = {}): UpdatePlan {
+	return {
+		profileId: "default",
+		plugins: [
+			{
+				pluginId: "agentdev@magus",
+				pinned: "latest",
+				installed: "1.7.0",
+				available: "1.7.0",
+				target: null,
+				action: "current",
+				scopes: ["project"],
+			},
+			{
+				pluginId: "dev@magus",
+				pinned: "latest",
+				installed: "4.6.1",
+				available: "5.0.0",
+				target: "5.0.0",
+				action: "update",
+				scopes: ["project"],
+			},
+			{
+				pluginId: "feature-dev@claude-plugins-official",
+				pinned: "latest",
+				installed: null,
+				available: null,
+				target: null,
+				action: "install",
+				scopes: [],
+			},
+			{
+				pluginId: "seo@magus",
+				pinned: "latest",
+				installed: "1.8.0",
+				available: null,
+				target: null,
+				action: "unknown",
+				scopes: ["project"],
+				note: "catalog unreachable",
+			},
+		],
+		bins: [
+			{ name: "tmux-mcp", action: "current", version: "v1.7.1", sources: [] },
+			{ name: "tmux", action: "upgrade", sources: [] },
+		],
+		skills: [
+			{
+				name: "release",
+				action: "install",
+				ref: { name: "release", repo: "MadAppGang/magus", path: "s/SKILL.md" },
+			},
+		],
+		binSpecs: new Map([
+			["tmux-mcp", { name: "tmux-mcp", via: "bun", sources: [] }],
+			["tmux", { name: "tmux", via: "brew", formula: "tmux", sources: [] }],
+		]),
+		...over,
+	} as UpdatePlan;
+}
+
+function steps(): Step[] {
+	return [
+		{
+			label: "profile",
+			state: "done",
+			detail: "4 plugins",
+			startedAt: 0,
+			endedAt: 100,
+		},
+		{
+			label: "marketplaces",
+			state: "running",
+			detail: "pulling magus",
+			startedAt: 100,
+			progress: { done: 1, total: 4 },
+		},
+		{ label: "catalog", state: "pending", detail: "" },
+	];
+}
+
+// -- alignment ----------------------------------------------------------------
+
+describe("alignment", () => {
+	test("every plugin row shares one column layout, colour or not", () => {
+		setColorEnabled(true);
+		const rows = planReport(plan())
+			.filter((l) => /@/.test(stripAnsi(l)))
+			.map((l) => stripAnsi(l));
+		// Every row's version column starts at the same visible offset, whatever
+		// mix of badges, dim text and notes the rows carry.
+		const offsets = rows.map((r) => r.indexOf("1.") + r.indexOf("latest"));
+		expect(offsets.length).toBeGreaterThan(0);
+		const versionCol = rows.map((r) =>
+			r.search(/(1\.7\.0|4\.6\.1|latest|1\.8\.0)/),
+		);
+		expect(new Set(versionCol).size).toBe(1);
+	});
+
+	test("the same row is the same visible width with colour on and off", () => {
+		setColorEnabled(false);
+		const plain = planReport(plan()).map((l) => width(l));
+		setColorEnabled(true);
+		const painted = planReport(plan()).map((l) => width(l));
+		expect(painted).toEqual(plain);
+	});
+
+	test("a very long plugin id widens the column for every row", () => {
+		setColorEnabled(false);
+		const long = "a-very-long-plugin-name-indeed@some-marketplace";
+		const p = plan();
+		p.plugins[0]!.pluginId = long;
+		const rows = planReport(p).filter((l) => l.includes("@"));
+		const cols = rows.map((r) => r.search(/(1\.7\.0|4\.6\.1|latest|1\.8\.0)/));
+		expect(new Set(cols).size).toBe(1);
+		expect(rows[0]).toContain(long);
+	});
+});
+
+// -- readability without colour ----------------------------------------------
+
+describe("NO_COLOR", () => {
+	test("the report emits no escape sequence at all", () => {
+		setColorEnabled(false);
+		const out = [
+			...header("default"),
+			...stepFrame(steps(), 3, 500),
+			...stepRecord(steps(), 500),
+			...planReport(plan()),
+			...applyFrame({ done: 1, total: 4, current: "dev@magus", startedAt: 0 }, 2, 900),
+			applyRow(true, "dev@magus", 20, "project", 400),
+			...summaryLine(2, 5, 1, 0, 9000),
+		].join("\n");
+		expect(out).not.toContain("\x1b");
+	});
+
+	test("every action stays distinguishable without colour", () => {
+		setColorEnabled(false);
+		const out = planReport(plan()).join("\n");
+		// Colour never carries meaning alone: each action has its own word AND
+		// its own glyph, so the report survives a pipe and colour blindness.
+		for (const label of ["CURRENT", "UPDATE", "INSTALL", "UNKNOWN", "UPGRADE"])
+			expect(out).toContain(label);
+		for (const glyph of ["=", "↑", "+", "?"]) expect(out).toContain(glyph);
+	});
+
+	test("a note rides along on the row it explains", () => {
+		setColorEnabled(false);
+		const row = planReport(plan()).find((l) => l.includes("seo@magus"))!;
+		expect(row).toContain("catalog unreachable");
+	});
+});
+
+// -- the bars tell the truth --------------------------------------------------
+
+describe("bars", () => {
+	test("a running step with a denominator gets a determinate meter", () => {
+		setColorEnabled(false);
+		const frame = stepFrame(steps(), 0, 500);
+		// 1 of 4 → a quarter of the 18-cell bar filled.
+		const bar = frame[1]!.match(/[█░]+/)?.[0] ?? "";
+		expect(bar).toHaveLength(18);
+		expect(bar.split("█").length - 1).toBe(5);
+	});
+
+	test("a running step with no denominator gets a sweep, not a fake meter", () => {
+		setColorEnabled(false);
+		const s = steps();
+		s[1]!.progress = undefined;
+		const bar = stepFrame(s, 3, 500)[1]!.match(/[█░]+/)?.[0] ?? "";
+		expect(bar).toHaveLength(18);
+		// A sweep is partly filled at every tick; a "0%" meter would be all track.
+		expect(bar).toContain("█");
+		expect(bar).toContain("░");
+	});
+
+	test("only the running row carries a bar in the live frame", () => {
+		setColorEnabled(false);
+		const frame = stepFrame(steps(), 0, 500);
+		expect(frame[0]).not.toMatch(/[█░]/);
+		expect(frame[1]).toMatch(/[█░]/);
+		expect(frame[2]).not.toMatch(/[█░]/);
+	});
+
+	test("the record scales each step against the slowest, not the total", () => {
+		setColorEnabled(false);
+		const record = stepRecord(
+			[
+				{ label: "fast", state: "done", detail: "", startedAt: 0, endedAt: 100 },
+				{ label: "slow", state: "done", detail: "", startedAt: 0, endedAt: 1000 },
+			],
+			1000,
+		);
+		const bars = record.map((r) => r.match(/[█░]+/)![0]);
+		expect(bars[1]!.split("█").length - 1).toBe(18);
+		expect(bars[0]!.split("█").length - 1).toBe(2);
+	});
+
+	test("a step that never ran does not divide by zero", () => {
+		setColorEnabled(false);
+		const record = stepRecord([{ label: "x", state: "pending", detail: "" }], 0);
+		expect(record[0]).toContain("░");
+	});
+
+	test("the apply meter is full exactly when the work is done", () => {
+		setColorEnabled(false);
+		const state: ApplyState = { done: 4, total: 4, current: "", startedAt: 0 };
+		const bar = applyFrame(state, 0, 100)[1]!.match(/[█░]+/)![0];
+		expect(bar).toBe("█".repeat(36));
+	});
+
+	test("an empty apply reads as complete rather than as stuck at zero", () => {
+		setColorEnabled(false);
+		const state: ApplyState = { done: 0, total: 0, current: "", startedAt: 0 };
+		expect(applyFrame(state, 0, 100)[1]).toContain("█".repeat(36));
+	});
+
+	test("the summary bar survives an all-zero run", () => {
+		setColorEnabled(false);
+		const line = summaryLine(0, 0, 0, 0, 100)[1]!;
+		expect(line.match(/[█░]+/)![0]).toHaveLength(36);
+	});
+});
+
+// -- misc ---------------------------------------------------------------------
+
+describe("sections", () => {
+	test("an empty section is omitted entirely, not printed as a heading", () => {
+		setColorEnabled(false);
+		const out = planReport(
+			plan({ bins: [], skills: [] }) as UpdatePlan,
+		).join("\n");
+		expect(out).toContain("Plugins");
+		expect(out).not.toContain("CLI");
+		expect(out).not.toContain("Skills");
+	});
+
+	test("a section legend counts every action it contains", () => {
+		setColorEnabled(false);
+		const line = planReport(plan()).find((l) => l.includes("Plugins"))!;
+		expect(line).toContain("1 current");
+		expect(line).toContain("1 update");
+		expect(line).toContain("1 install");
+		expect(line).toContain("1 unknown");
+	});
+
+	test("a CLI upgrade shows the command that will run", () => {
+		setColorEnabled(false);
+		const row = planReport(plan()).find(
+			(l) => l.includes("tmux ") && l.includes("UPGRADE"),
+		)!;
+		expect(row).toContain("brew upgrade tmux");
+	});
+});

package/src/__tests__/gitignore-fixer.test.ts

@@ -10,8 +10,27 @@ import {
 } from "../services/gitignore-fixer";
 import type { Violation } from "../types/gitignore";
 
+// `commit.gpgsign=false` is not tidiness — without it these tests HANG.
+//
+// Two tests here run `git commit` in a temp repo, which inherits the
+// developer's global config. On any machine with commit signing enabled and a
+// GUI signer (`gpg.format=ssh` pointing at 1Password's `op-ssh-sign` is the
+// common setup here), the commit blocks waiting for an approval dialog nobody
+// is watching, and both tests fail on a 5s timeout. It presents as a flake
+// because the approval is cached once granted, so the suite goes green until
+// the cache expires. `marketplace-refresh.test.ts` already guards this the same
+// way; this file did not.
+const GIT_CFG = [
+  "-c",
+  "core.excludesFile=/dev/null",
+  "-c",
+  "commit.gpgsign=false",
+  "-c",
+  "init.defaultBranch=main",
+];
+
 function git(cwd: string, ...args: string[]): { stdout: string; status: number } {
-  const r = spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], {
+  const r = spawnSync("git", [...GIT_CFG, ...args], {
     cwd,
     encoding: "utf8",
   });