claudeup 4.37.0 → 4.38.0

package/src/__tests__/open-file.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { openInDefaultApp, openerFor } from "../utils/open-file.js";
+
+describe("openerFor", () => {
+	test("uses the macOS opener on darwin", () => {
+		expect(openerFor("darwin")).toEqual({ command: "open", args: [] });
+	});
+
+	test("uses xdg-open on linux", () => {
+		// claudeup ships a linux-x64 binary, and the pre-existing `open "${url}"`
+		// call elsewhere in the UI silently does nothing there.
+		expect(openerFor("linux")).toEqual({ command: "xdg-open", args: [] });
+	});
+
+	test("passes an empty window title to cmd start on windows", () => {
+		// `start` treats its first quoted argument as the window title, so
+		// without the empty string a quoted path is consumed as one.
+		expect(openerFor("win32")).toEqual({
+			command: "cmd",
+			args: ["/c", "start", ""],
+		});
+	});
+
+	test("falls back to xdg-open on anything else", () => {
+		expect(openerFor("freebsd").command).toBe("xdg-open");
+	});
+});
+
+describe("openInDefaultApp", () => {
+	const missingOpener = {
+		command: "claudeup-test-opener-that-cannot-exist",
+		args: [],
+	};
+
+	test("reports a missing opener rather than failing silently", async () => {
+		// An injected command that cannot exist, NOT a real platform's opener.
+		// The first version assumed `xdg-open` was absent — true on a Mac dev
+		// box, false on the Ubuntu CI runner, where it both failed the
+		// assertion and spawned a real opener on the build machine.
+		await expect(
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener),
+		).rejects.toThrow(/not on PATH/);
+	});
+
+	test("settles promptly instead of hanging", async () => {
+		// The promise must settle when the child is spawned, not when the viewer
+		// is closed — waiting for exit would freeze the TUI for as long as the
+		// user's editor stayed open. Asserted on the error path so the suite
+		// never launches a real application on the developer's desktop.
+		const settled = await Promise.race([
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener).then(
+				() => "resolved",
+				() => "rejected",
+			),
+			new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
+		]);
+		expect(settled).not.toBe("timeout");
+	});
+});

package/src/__tests__/style-wrap.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, test } from "bun:test";
+import {
+	formatBody,
+	toBlocks,
+	upstreamLine,
+	wrapText,
+} from "../ui/renderers/styleRenderers.js";
+import { theme } from "../ui/theme.js";
+
+describe("the Upstream line", () => {
+	const NOW = Date.parse("2026-08-18T12:00:00Z");
+
+	test("says up to date, with when it was checked", () => {
+		const line = upstreamLine(
+			{
+				state: "up-to-date",
+				detail: "up to date",
+				checkedAt: NOW - 3 * 3600_000,
+			},
+			NOW,
+		);
+		expect(line.text).toBe("up to date (checked 3h ago)");
+		expect(line.tone).toBe(theme.colors.success);
+	});
+
+	test("an UNKNOWN state never renders as anything like currency", () => {
+		// The fail-closed clause, in the one place a user actually reads it. A
+		// rate-limited check, an offline box and a check that aged past its window
+		// all land here, and none of them is evidence of freshness.
+		for (const detail of [
+			"GitHub rate limit resets in 4m",
+			"no network — the styles you already fetched still work",
+			"not checked in the last 24h — press u",
+		]) {
+			const line = upstreamLine(
+				{ state: "unknown", detail, checkedAt: null },
+				NOW,
+			);
+			expect(line.text).toBe(`not checked — ${detail}`);
+			expect(line.text).not.toMatch(/up to date/);
+			expect(line.tone).not.toBe(theme.colors.success);
+		}
+	});
+
+	test("a style that was never checked says so, and names the key", () => {
+		const line = upstreamLine(undefined, NOW);
+		expect(line.text).toBe("not checked — press u");
+		expect(line.tone).not.toBe(theme.colors.success);
+	});
+
+	test("an available update carries its own wording through verbatim", () => {
+		const line = upstreamLine(
+			{
+				state: "update-available",
+				detail: "newer version available — 12 lines changed, press f to accept",
+				checkedAt: NOW,
+				changedLines: 12,
+			},
+			NOW,
+		);
+		expect(line.text).toMatch(/12 lines changed/);
+		expect(line.tone).toBe(theme.colors.warning);
+	});
+});
+
+describe("wrapText", () => {
+	test("leaves short lines exactly as they are", () => {
+		expect(wrapText("short line", 40)).toEqual(["short line"]);
+	});
+
+	test("never exceeds the column width", () => {
+		const text =
+			"Lead with the answer. The first sentence resolves the question; everything after it is support.";
+		for (const line of wrapText(text, 40)) {
+			expect(line.length).toBeLessThanOrEqual(40);
+		}
+	});
+
+	test("emits a bullet once, not on every wrapped row", () => {
+		// The regression: extracting "- " as the indent and then re-prefixing it
+		// onto content that still began with "- " rendered "- - Lead with…".
+		const wrapped = wrapText(
+			"- Lead with the answer. The first sentence resolves the question; everything after it is support.",
+			40,
+		);
+		expect(wrapped.length).toBeGreaterThan(1);
+		expect(wrapped[0].startsWith("- ")).toBe(true);
+		expect(wrapped[0]).not.toContain("- - ");
+		for (const line of wrapped.slice(1)) {
+			expect(line.trimStart().startsWith("- ")).toBe(false);
+		}
+	});
+
+	test("aligns continuation lines under the bullet text", () => {
+		const wrapped = wrapText(
+			"- Recommend, do not survey. When there are three viable approaches, name the one to take.",
+			40,
+		);
+		// "- " is two columns, so continuations are indented by two.
+		for (const line of wrapped.slice(1)) {
+			expect(line.startsWith("  ")).toBe(true);
+			expect(line.startsWith("   ")).toBe(false);
+		}
+	});
+
+	test("fills the available width rather than breaking early", () => {
+		// The other half of the old bug: the per-line budget drifted with how much
+		// output had already been produced, so lines got progressively shorter.
+		const wrapped = wrapText(
+			"one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen",
+			40,
+		);
+		// Every line except the last should be within one word of the limit.
+		for (const line of wrapped.slice(0, -1)) {
+			expect(line.length).toBeGreaterThan(28);
+		}
+	});
+
+	test("preserves blank lines between paragraphs", () => {
+		expect(wrapText("a\n\nb", 40)).toEqual(["a", "", "b"]);
+	});
+
+	test("does not drop a word that is longer than the width", () => {
+		const long = "x".repeat(60);
+		expect(wrapText(`- ${long}`, 40).join(" ")).toContain(long);
+	});
+
+	test("keeps nested indentation", () => {
+		const wrapped = wrapText(
+			"    deeply indented text that goes on long enough to need wrapping across lines",
+			40,
+		);
+		for (const line of wrapped) {
+			expect(line.startsWith("    ")).toBe(true);
+		}
+	});
+});
+
+describe("toBlocks", () => {
+	test("rejoins a bullet that the source hard-wrapped across lines", () => {
+		// Style presets ship wrapped at ~76 columns. Without rejoining, a 40-char
+		// continuation line already fits the panel and is emitted as its own
+		// ragged row — which is what the detail panel actually looked like.
+		expect(
+			toBlocks(
+				"- Lead with the answer. The first sentence resolves\n  the question; everything after it is support.",
+			),
+		).toEqual([
+			"- Lead with the answer. The first sentence resolves the question; everything after it is support.",
+		]);
+	});
+
+	test("a blank line separates blocks", () => {
+		expect(toBlocks("one\ntwo\n\nthree")).toEqual(["one two", "", "three"]);
+	});
+
+	test("each bullet is its own block", () => {
+		expect(toBlocks("- a\n  cont\n- b")).toEqual(["- a cont", "- b"]);
+	});
+
+	test("a heading never absorbs the line that follows it", () => {
+		expect(toBlocks("### Direct\nsome text")).toEqual([
+			"### Direct",
+			"some text",
+		]);
+	});
+
+	test("table rows are passed through untouched", () => {
+		// Reflowing a table destroys its column alignment entirely.
+		expect(toBlocks("| a | b |\n| - | - |")).toEqual([
+			"| a | b |",
+			"| - | - |",
+		]);
+	});
+
+	test("fenced code is preserved line by line", () => {
+		expect(toBlocks("```ts\nconst a = 1\nconst b = 2\n```")).toEqual([
+			"```ts",
+			"const a = 1",
+			"const b = 2",
+			"```",
+		]);
+	});
+});
+
+describe("formatBody", () => {
+	test("produces even lines from hard-wrapped source", () => {
+		const body = [
+			"### Direct",
+			"",
+			"- Lead with the answer. The first sentence resolves the question;",
+			"  everything after it is support. Never open with a restatement of",
+			"  what was asked.",
+		].join("\n");
+
+		const lines = formatBody(body, 50);
+		for (const line of lines) expect(line.length).toBeLessThanOrEqual(50);
+
+		// The bullet's continuation rows should be full lines, not fragments
+		// inherited from the original 76-column source.
+		const continuations = lines.filter((l) => l.startsWith("  "));
+		expect(continuations.length).toBeGreaterThan(0);
+		for (const row of continuations.slice(0, -1)) {
+			expect(row.length).toBeGreaterThan(35);
+		}
+	});
+
+	test("keeps the blank line between a heading and the list", () => {
+		expect(formatBody("### Direct\n\n- a", 50)).toEqual([
+			"### Direct",
+			"",
+			"- a",
+		]);
+	});
+
+	test("does not clip a table even when it overflows the width", () => {
+		const row = "| a very wide column | another very wide column |";
+		expect(formatBody(row, 20)).toEqual([row]);
+	});
+});