claudeup 5.0.1 → 6.1.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-tool-commands.test.ts

@@ -0,0 +1,239 @@
+/**
+ * The CLI-tools catalogue can no longer emit a bare `pip`, or shell syntax.
+ *
+ * Two defects lived in this screen, and both were data problems dressed as code
+ * problems:
+ *
+ *  1. **Bare `pip`.** `getUpdateCommand`'s `pip` and `default` arms returned the
+ *     catalogue's `installCommand` verbatim, and `getUninstallCommand` emitted
+ *     `pip uninstall -y`. `pip` is frequently a zsh alias rather than an
+ *     executable, and a machine that manages Python tools with uv or pipx may
+ *     have no `pip` at all. `services/toolchain.ts` already knew how to answer
+ *     "how does Python work here"; this screen was not asking it.
+ *  2. **Shell syntax in data.** `aider`'s entry was
+ *     `pip install aider-install && aider-install` — a `&&` chain in a catalogue
+ *     field that got handed to `/bin/bash`.
+ *
+ * Both are now unrepresentable: the field is gone and the command is derived.
+ * These tests assert that over the whole catalogue rather than over an example,
+ * so a new entry cannot reintroduce either.
+ *
+ * Pure — no React, no network, no PATH dependency. Every Python installer is
+ * pinned explicitly, per the convention `toolchain.test.ts` established: the
+ * production default is resolved from PATH, so an unpinned assertion would
+ * encode whatever happens to be installed on the machine running the suite.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { cliTools } from "../data/cli-tools.js";
+import {
+	type InstallMethod,
+	cliToolInstall,
+	cliToolUninstall,
+	cliToolUpdate,
+} from "../services/cli-tool-commands.js";
+import {
+	PYTHON_CLI_INSTALLERS,
+	type PythonCliInstaller,
+	resolvePythonCliInstaller,
+} from "../services/toolchain.js";
+import { versionFromPypiJson } from "../ui/screens/CliToolsScreen.js";
+import { type Command, formatCommand } from "../utils/command-utils.js";
+
+const byProbe = (probe: string): PythonCliInstaller => {
+	const found = PYTHON_CLI_INSTALLERS.find((i) => i.probe === probe);
+	if (!found) throw new Error(`no python installer with probe ${probe}`);
+	return found;
+};
+const PYTHON_PROBES = PYTHON_CLI_INSTALLERS.map((i) => i.probe);
+
+/** The methods the resolver models, i.e. the ones that reach toolchain.ts. */
+const RESOLVED_METHODS: InstallMethod[] = ["npm", "bun", "brew", "pip"];
+
+describe("the catalogue is well-formed", () => {
+	test("it has entries, and each names a package manager and a package", () => {
+		// Guard: every assertion below iterates the catalogue, so an empty or
+		// malformed one would make them all pass vacuously.
+		expect(cliTools.length).toBeGreaterThan(5);
+		for (const tool of cliTools) {
+			expect(typeof tool.packageName).toBe("string");
+			expect(tool.packageName.length).toBeGreaterThan(0);
+			expect(["bun", "npm", "pip", "brew", "go"]).toContain(
+				tool.packageManager,
+			);
+		}
+	});
+});
+
+describe("no builder ever emits a bare `pip`", () => {
+	test("install: cmd is the resolver's probe, never `pip`", () => {
+		for (const tool of cliTools) {
+			const cmd = cliToolInstall(tool);
+			expect(cmd.cmd).not.toBe("pip");
+			if (tool.packageManager === "pip") {
+				// Whatever the machine running this resolved to, it must be one of
+				// the three modelled installers — and `cmd` must BE that probe,
+				// since that is the executable the syscall looks up.
+				expect(PYTHON_PROBES).toContain(cmd.cmd);
+				expect(cmd.cmd).toBe(resolvePythonCliInstaller().probe);
+			}
+		}
+	});
+
+	test("update and uninstall: cmd is never `pip`, for any method", () => {
+		for (const tool of cliTools) {
+			for (const method of RESOLVED_METHODS) {
+				for (const cmd of [
+					cliToolUpdate(tool, method),
+					cliToolUninstall(tool, method),
+				]) {
+					if (!cmd) continue;
+					expect(cmd.cmd).not.toBe("pip");
+				}
+			}
+		}
+	});
+
+	test("each pinned Python installer drives all three of its own commands", () => {
+		// Pinned explicitly so this holds on a runner with no uv. The `pip`
+		// method must route to the SAME executable for install, update and
+		// uninstall — installing with uv and uninstalling with python3 would look
+		// like it worked and leave the tool on disk.
+		for (const probe of PYTHON_PROBES) {
+			const python = byProbe(probe);
+			expect(python.install("x").cmd).toBe(probe);
+			expect(python.upgrade("x").cmd).toBe(probe);
+			expect(python.uninstall("x").cmd).toBe(probe);
+		}
+	});
+});
+
+describe("no builder can emit shell syntax", () => {
+	test("no argv element of any command contains &&, | or ;", () => {
+		// The catalogue's only `&&` chain was aider's installCommand. With the
+		// field gone there is nowhere left for shell syntax to enter, and this
+		// asserts that over every entry and every method rather than over that
+		// one case.
+		const all: Command[] = [];
+		for (const tool of cliTools) {
+			all.push(cliToolInstall(tool));
+			for (const method of [
+				...RESOLVED_METHODS,
+				"pnpm" as const,
+				"yarn" as const,
+			]) {
+				const u = cliToolUpdate(tool, method);
+				const r = cliToolUninstall(tool, method);
+				if (u) all.push(u);
+				if (r) all.push(r);
+			}
+		}
+		expect(all.length).toBeGreaterThan(0);
+
+		for (const cmd of all) {
+			for (const token of [cmd.cmd, ...cmd.args]) {
+				expect(token).not.toContain("&&");
+				expect(token).not.toContain("|");
+				expect(token).not.toContain(";");
+			}
+		}
+	});
+});
+
+describe("the detected method is followed, not the catalogue's", () => {
+	test("pnpm and yarn keep their own shapes", () => {
+		// A tool the catalogue calls npm can still have been installed with
+		// pnpm. Updating it as npm would install a second copy beside the first,
+		// which is the conflict this screen exists to report.
+		const tool = cliTools.find((t) => t.packageManager === "npm")!;
+		expect(cliToolUpdate(tool, "pnpm")).toEqual({
+			cmd: "pnpm",
+			args: ["install", "-g", tool.packageName],
+		});
+		expect(cliToolUpdate(tool, "yarn")).toEqual({
+			cmd: "yarn",
+			args: ["global", "add", tool.packageName],
+		});
+		expect(cliToolUninstall(tool, "pnpm")).toEqual({
+			cmd: "pnpm",
+			args: ["remove", "-g", tool.packageName],
+		});
+		expect(cliToolUninstall(tool, "yarn")).toEqual({
+			cmd: "yarn",
+			args: ["global", "remove", tool.packageName],
+		});
+	});
+
+	test("`unknown` returns null rather than guessing", () => {
+		// Preserves the observable behaviour: handleInstall reads
+		// `installed && updateCommand ? updateCommand : install…`, so null falls
+		// back to a plain install — which is what the old `default:` arm did by
+		// returning `tool.installCommand`.
+		const tool = cliTools[0]!;
+		expect(cliToolUpdate(tool, "unknown")).toBeNull();
+		expect(cliToolUninstall(tool, "unknown")).toBeNull();
+	});
+
+	test("brew and go arms are pinned, since no catalogue entry exercises them", () => {
+		// Every entry today is bun/npm/pip, so these two ship untouched by real
+		// data. `go` has no uninstaller — `go install` writes a binary and
+		// records nothing — so null is correct rather than an invented `rm`.
+		const tool = cliTools[0]!;
+		expect(cliToolUpdate(tool, "brew", "some-formula")).toEqual({
+			cmd: "brew",
+			args: ["upgrade", "some-formula"],
+		});
+		expect(cliToolUninstall(tool, "brew", "some-formula")).toEqual({
+			cmd: "brew",
+			args: ["uninstall", "some-formula"],
+		});
+	});
+});
+
+describe("derived commands still read as they did", () => {
+	test("claude renders exactly the literal the catalogue used to carry", () => {
+		// The entry whose command SHOULD not change. Its old
+		// `installCommand: "npm install -g @anthropic-ai/claude-code"` is now
+		// derived from packageManager + packageName, and must render identically.
+		const claude = cliTools.find((t) => t.name === "claude")!;
+		expect(formatCommand(cliToolInstall(claude))).toBe(
+			"npm install -g @anthropic-ai/claude-code",
+		);
+	});
+
+	test("aider now installs the package its own fields already named", () => {
+		// The one deliberate behaviour change. The old command installed
+		// `aider-install`, a bootstrapper whose version nothing here ever read,
+		// while `packageName`, `checkCommand` and the PyPI query all said
+		// `aider-chat`. The installCommand was the field that was out of step.
+		const aider = cliTools.find((t) => t.name === "aider")!;
+		expect(aider.packageName).toBe("aider-chat");
+		expect(cliToolInstall(aider).args).toContain("aider-chat");
+		expect(formatCommand(cliToolInstall(aider))).not.toContain("aider-install");
+	});
+});
+
+describe("versionFromPypiJson", () => {
+	// The shape of a real https://pypi.org/pypi/<pkg>/json body, trimmed to the
+	// two fields that matter. Captured rather than mocked so the parser is
+	// tested against what the endpoint actually returns.
+	const body = {
+		info: { name: "aider-chat", version: "0.86.1" },
+		releases: {},
+	};
+
+	test("reads info.version", () => {
+		expect(versionFromPypiJson(body)).toBe("0.86.1");
+	});
+
+	test("anything unexpected yields undefined, never a throw", () => {
+		// A version check is advisory: it must degrade to "no update badge",
+		// never take the screen down. PyPI returning an error object, a 404 body,
+		// or nothing at all all land here.
+		expect(versionFromPypiJson({})).toBeUndefined();
+		expect(versionFromPypiJson({ info: {} })).toBeUndefined();
+		expect(versionFromPypiJson({ info: { version: 42 } })).toBeUndefined();
+		expect(versionFromPypiJson(null)).toBeUndefined();
+		expect(versionFromPypiJson("not json at all")).toBeUndefined();
+	});
+});