@selesai/code 0.9.15 → 0.10.1

package/dist/extensions/pi-zentui/test/user-message-osc.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from "vitest";
+import {
+	isValidUserMessageOsc8Payload,
+	sanitizeRenderedUserMessageLines,
+	sanitizeRenderedUserMessageText,
+	sanitizeUserMessageSourceText,
+} from "../extensions/zentui/user-message-osc";
+
+const safeTerminators = ["\x07", "\x1b\\"];
+
+describe("sanitizeUserMessageSourceText", () => {
+	it.each(safeTerminators)("strips structurally valid 7-bit OSC 8 controls (%j)", (end) => {
+		const open = `\x1b]8;id=docs;https://example.test/a${end}`;
+		const close = `\x1b]8;;${end}`;
+		expect(sanitizeUserMessageSourceText(`before ${open}link${close} after`)).toBe(
+			"before link after",
+		);
+	});
+
+	it("strips a balanced link spanning source rows while preserving text", () => {
+		const open = "\x1b]8;;https://example.test\x07";
+		const close = "\x1b]8;;\x07";
+		expect(sanitizeUserMessageSourceText(`${open}first\nsecond${close}`)).toBe("first\nsecond");
+	});
+
+	it.each([
+		["unmatched open", "\x1b]8;;https://example.test\x07before link after", "before link after"],
+		["stray close", "before\x1b]8;;\x07 after", "before after"],
+		[
+			"nested open",
+			"\x1b]8;;https://first.test\x07first \x1b]8;;https://second.test\x07second\x1b]8;;\x07",
+			"first second",
+		],
+	] as const)(
+		"strips every OSC 8 control for an unbalanced %s stream",
+		(_name, source, visible) => {
+			const output = sanitizeUserMessageSourceText(source);
+			expect(output).toBe(visible);
+			expect(output).not.toContain("\x1b]8;");
+		},
+	);
+
+	it.each([
+		["C1 introducer and terminator", "\x9d", "\x9c"],
+		["C1 introducer with BEL", "\x9d", "\x07"],
+		["7-bit introducer with C1 terminator", "\x1b]", "\x9c"],
+	] as const)("strips unsupported %s OSC 8 controls", (_name, start, end) => {
+		const open = `${start}8;;https://example.test${end}`;
+		const close = `${start}8;;${end}`;
+		expect(sanitizeUserMessageSourceText(`before ${open}link${close} after`)).toBe(
+			"before link after",
+		);
+	});
+
+	it.each(["0;title", "2;title", "52;c;c2VjcmV0", "133;A", "9;text", "hello"])(
+		"removes complete non-OSC-8 command %j and its payload",
+		(payload) => {
+			expect(sanitizeUserMessageSourceText(`before\x1b]${payload}\x07after`)).toBe("beforeafter");
+			expect(sanitizeUserMessageSourceText(`before\x9d${payload}\x9cafter`)).toBe("beforeafter");
+		},
+	);
+
+	it.each([
+		"8",
+		"8;params",
+		"88;;https://example.test",
+		"8;badparam;https://example.test",
+		"8;bad key=value;https://example.test",
+		"8;;https://example.test/has space",
+		"8;id=x;",
+	])("removes malformed OSC 8 payload %j", (payload) => {
+		expect(sanitizeUserMessageSourceText(`left\x1b]${payload}\x07right`)).toBe("leftright");
+	});
+
+	it("neutralizes unterminated and nested OSC without consuming later visible text", () => {
+		expect(sanitizeUserMessageSourceText("left\x1b]133;A;visible")).toBe("leftvisible");
+		expect(
+			sanitizeUserMessageSourceText("left\x1b]2;title\x1b]8;;https://safe.test\x07right"),
+		).toBe("left2;titleright");
+	});
+
+	it.each([
+		["7-bit CSI", "a\x1b[2Jb", "ab"],
+		["C1 CSI", "a\x9b2Jb", "ab"],
+		["7-bit DCS", "a\x1bPpayload\x1b\\b", "ab"],
+		["C1 DCS", "a\x90payload\x9cb", "ab"],
+		["7-bit SOS", "a\x1bXpayload\x1b\\b", "ab"],
+		["C1 SOS", "a\x98payload\x9cb", "ab"],
+		["7-bit PM", "a\x1b^payload\x1b\\b", "ab"],
+		["C1 PM", "a\x9epayload\x9cb", "ab"],
+		["7-bit APC", "a\x1b_payload\x1b\\b", "ab"],
+		["C1 APC", "a\x9fpayload\x9cb", "ab"],
+		["BEL", "a\x07b", "ab"],
+		["C0", "a\x01b", "ab"],
+		["DEL", "a\x7fb", "ab"],
+		["standalone C1", "a\x85b", "ab"],
+		["generic escape", "a\x1b(0b", "ab"],
+	] as const)("removes %s terminal controls", (_name, source, expected) => {
+		expect(sanitizeUserMessageSourceText(source)).toBe(expected);
+	});
+
+	it("preserves Markdown-safe structural whitespace", () => {
+		expect(sanitizeUserMessageSourceText("a\tb\nc")).toBe("a\tb\nc");
+	});
+
+	it("strips many raw links in one linear source pass", () => {
+		const open = "\x1b]8;;https://example.test\x07";
+		const close = "\x1b]8;;\x07";
+		const source = Array.from({ length: 20_000 }, (_, index) => `${open}${index}${close}`).join(
+			" ",
+		);
+		const expected = Array.from({ length: 20_000 }, (_, index) => String(index)).join(" ");
+		expect(sanitizeUserMessageSourceText(source)).toBe(expected);
+	});
+});
+
+describe("sanitizeRenderedUserMessageText", () => {
+	it("preserves only SGR and structurally valid 7-bit OSC 8", () => {
+		const sgr = "\x1b[38;5;202mstyled\x1b[0m";
+		const open = "\x1b]8;;https://safe.example\x1b\\";
+		const close = "\x1b]8;;\x1b\\";
+		const source = `before ${sgr} ${open}link${close} \x1b]52;c;CLIP\x07\x1b[2J\x1bPSECRET\x1b\\\x07 after`;
+		const sanitized = sanitizeRenderedUserMessageText(source);
+		expect(sanitized).toContain(sgr);
+		expect(sanitized).toContain(`${open}link${close}`);
+		expect(sanitized).toContain("before");
+		expect(sanitized).toContain("after");
+		expect(sanitized).not.toContain("CLIP");
+		expect(sanitized).not.toContain("SECRET");
+		expect(sanitized).not.toContain("\x1b[2J");
+		expect(sanitized).not.toContain("\x07 after");
+	});
+
+	it("balances predecessor hyperlinks across rendered rows", () => {
+		const open = "\x1b]8;;https://safe.example\x07";
+		const close = "\x1b]8;;\x07";
+		const sgr = "\x1b[31mred\x1b[0m";
+		expect(sanitizeRenderedUserMessageLines([`${open}first`, `second${close} ${sgr}`])).toEqual([
+			`${open}first`,
+			`second${close} ${sgr}`,
+		]);
+		expect(sanitizeRenderedUserMessageLines([`${open}first`, `second ${sgr}`])).toEqual([
+			"first",
+			`second ${sgr}`,
+		]);
+		expect(sanitizeRenderedUserMessageLines(["first", `second\x1b]8;;\x07 ${sgr}`])).toEqual([
+			"first",
+			`second ${sgr}`,
+		]);
+	});
+});
+
+describe("isValidUserMessageOsc8Payload", () => {
+	it("accepts parameter entries and custom URI schemes", () => {
+		expect(isValidUserMessageOsc8Payload("8;id=x:foo=bar;custom:target")).toBe(true);
+	});
+
+	it.each(["8;id=x;bad\nuri", "8;i\x1bd=x;https://x", "8;id=x;https://x\x9c"])(
+		"rejects controls in params and URIs",
+		(payload) => {
+			expect(isValidUserMessageOsc8Payload(payload)).toBe(false);
+		},
+	);
+});

package/dist/extensions/pi-zentui/test/user-message-styles.test.ts

@@ -0,0 +1,292 @@
+import { stripVTControlCharacters } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it } from "vitest";
+import {
+	defaultConfig,
+	type PolishedTuiConfig,
+	type UserMessageStyle,
+} from "../extensions/zentui/config";
+import {
+	sanitizeRenderedUserMessageText,
+	sanitizeUserMessageSourceText,
+} from "../extensions/zentui/user-message-osc";
+import {
+	renderUserMessageStyle,
+	userMessageStyleCacheKey,
+} from "../extensions/zentui/user-message-styles";
+
+const userMessageStyles = ["framed", "framed-copy-friendly", "compact", "labeled"] as const;
+
+function config(style: UserMessageStyle): PolishedTuiConfig {
+	const value = structuredClone(defaultConfig);
+	value.components.userMessages.style = style;
+	return value;
+}
+
+function render(style: UserMessageStyle, text: string, width: number, theme?: Theme): string[] {
+	return renderUserMessageStyle({ text, width, theme, config: config(style) });
+}
+
+function plain(value: string): string {
+	return value.replaceAll(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+function ansiTheme(): Theme {
+	return {
+		fg: (_color: string, text: string) => `\x1b[34m${text}\x1b[0m`,
+		bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+	} as Theme;
+}
+
+describe("pure user-message styles", () => {
+	it("preserves exact framed chrome and padding", () => {
+		expect(render("framed", "Hello", 12)).toEqual([
+			"────────────",
+			"│           ",
+			"│ Hello     ",
+			"│           ",
+			"────────────",
+		]);
+	});
+
+	it("adds one leading space to copy-friendly framed message text", () => {
+		expect(render("framed-copy-friendly", "Hello", 12)).toEqual([
+			"────────────",
+			"",
+			" Hello      ",
+			"",
+			"────────────",
+		]);
+	});
+
+	it("keeps copy-friendly ANSI and wide-Unicode body rows padded within width", () => {
+		for (let width = 2; width <= 24; width += 1) {
+			const lines = render("framed-copy-friendly", "界🙂 \x1b[31mwide\x1b[0m", width, ansiTheme());
+			const body = lines.slice(2, -2);
+			expect(body.length).toBeGreaterThan(0);
+			expect(body.every((line) => visibleWidth(line) === width)).toBe(true);
+		}
+	});
+
+	it("renders compact multiline and blank Markdown rows with an unpadded rail", () => {
+		const lines = render("compact", "First\n\nFinal", 16);
+		expect(lines).toEqual(["│ First", "│ ", "│ Final"]);
+		expect(lines.every((line) => !line.endsWith("  "))).toBe(true);
+	});
+
+	it("renders a fixed User label and no extra body padding", () => {
+		expect(render("labeled", "Hello\nContinued", 20)).toEqual([
+			"╭─ User ───────────╮",
+			"│ Hello            │",
+			"│ Continued        │",
+			"╰──────────────────╯",
+		]);
+	});
+
+	it("preserves Markdown rendering across all styles", () => {
+		for (const style of userMessageStyles) {
+			const output = plain(
+				render(style, "**bold**\n\n- item\n\n> quote\n\n```ts\ncode\n```", 40).join("\n"),
+			);
+			expect(output).toContain("bold");
+			expect(output).toContain("item");
+			expect(output).toContain("quote");
+			expect(output).toContain("code");
+			expect(output).not.toContain("**bold**");
+		}
+	});
+
+	it("degrades atomically at compact and labeled narrow thresholds", () => {
+		expect(render("compact", "界a", 2)).toEqual(["界", "a"]);
+		expect(render("compact", "abc", 3)[0]).toBe("│ a");
+		for (const width of [3, 4, 5, 6, 7, 8]) {
+			const lines = render("labeled", "abc", width);
+			const body = lines.slice(1, -1);
+			expect(lines[0]).toMatch(/^╭─*╮$/);
+			expect(lines.at(-1)).toMatch(/^╰─*╯$/);
+			expect(lines.join("\n")).not.toContain("User");
+			expect(lines.every((line) => visibleWidth(line) === width)).toBe(true);
+			expect(body.every((line) => line.startsWith("│") && line.endsWith("│"))).toBe(true);
+			expect(body.map((line) => line.slice(1, -1).trim()).join("")).toContain("abc");
+		}
+		for (const width of [1, 2]) {
+			const joined = render("labeled", "abc", width).join("\n");
+			expect(joined).not.toMatch(/[╭╮╰╯│]/);
+		}
+		expect(render("labeled", "abc", 9)[0]).toBe("╭─ User ╮");
+	});
+
+	it("returns a marker-safe row at non-positive widths and clamps ANSI/wide Unicode", () => {
+		for (const style of userMessageStyles) {
+			expect(render(style, "hello", 0)).toEqual([""]);
+			for (let width = 1; width <= 24; width += 1) {
+				const lines = render(style, "界🙂 \x1b[31mwide\x1b[0m", width, ansiTheme());
+				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
+			}
+		}
+	});
+
+	it("throws rendering failures for the shared adapter to handle", () => {
+		const failingTheme = {
+			...ansiTheme(),
+			fg() {
+				throw new Error("theme failed");
+			},
+		} as unknown as Theme;
+		for (const style of userMessageStyles) {
+			expect(() => render(style, "hello", 20, failingTheme)).toThrow("theme failed");
+		}
+	});
+
+	it("strips every raw OSC 8 control while preserving visible text", () => {
+		const pairs = [
+			["\x1b]8;;https://example.com\x07", "\x1b]8;;\x07"],
+			["\x1b]8;;https://example.com\x1b\\", "\x1b]8;;\x1b\\"],
+			["\x9d8;;https://example.com\x9c", "\x9d8;;\x9c"],
+		] as const;
+		for (const style of userMessageStyles) {
+			for (const [open, close] of pairs) {
+				const output = render(style, `before ${open}VISIBLE${close}\nafter`, 80).join("\n");
+				expect(output).not.toContain(open);
+				expect(output).not.toContain(close);
+				expect(plain(output).replaceAll(/[^\p{L}]/gu, "")).toContain("beforeVISIBLEafter");
+			}
+		}
+	});
+
+	it("strips raw OSC 8 independently of Markdown source context", () => {
+		const open = "\x1b]8;;https://raw.example\x07";
+		const close = "\x1b]8;;\x07";
+		const contexts = [
+			`${open}VISIBLE${close}`,
+			`[docs](https://markdown.example/${open}VISIBLE${close})`,
+			`![image](https://markdown.example/${open}VISIBLE${close})`,
+			`\` ${open}VISIBLE${close} \``,
+			`\`\`foo \`\`\` bar \` ${open}VISIBLE${close} \`\``,
+			`~~~\n${open}VISIBLE${close}\n~~~`,
+			`[foo\nbar]: ${open}VISIBLE${close}\n\n[foo bar]`,
+			`<https://markdown.example/${open}VISIBLE${close}>`,
+			`See,https://markdown.example/a_(b)/${open}VISIBLE${close}!`,
+			`[broken](https://markdown.example/${open}VISIBLE${close}`,
+			`（https://markdown.example/${open}VISIBLE${close}）`,
+		];
+		for (const style of userMessageStyles) {
+			for (const source of contexts) {
+				const output = render(style, `${source} TAIL`, 160).join("\n");
+				expect(output).not.toContain(open);
+				expect(output).not.toContain(close);
+				expect(output).toContain("TAIL");
+			}
+		}
+	});
+
+	it("preserves Pi Markdown link rendering after raw-source sanitization", () => {
+		const markdown = "[docs](https://markdown.example) <https://autolink.example>";
+		const hostile = "\x1b]52;c;c2VjcmV0\x07";
+		expect(sanitizeUserMessageSourceText(markdown)).toBe(markdown);
+		for (const style of userMessageStyles) {
+			const clean = render(style, markdown, 160).join("\n");
+			const mixed = render(style, `${hostile}${markdown}`, 160).join("\n");
+			expect(mixed).toBe(clean);
+			expect(stripVTControlCharacters(mixed)).toContain("docs");
+			expect(mixed).toContain("https://markdown.example");
+			expect(mixed).toContain("https://autolink.example");
+			if (clean.includes("\x1b]8;")) expect(sanitizeRenderedUserMessageText(clean)).toBe(clean);
+			expect(mixed).not.toContain("\x1b]52");
+			expect(mixed).not.toContain("c2VjcmV0");
+		}
+	});
+
+	it.each([
+		["unmatched open", "\x1b]8;;https://example.com\x07raw"],
+		["stray close", "raw\x1b]8;;\x07"],
+		["C1 unmatched open", "\x9d8;;https://example.com\x9craw"],
+		[
+			"nested open",
+			"\x1b]8;;https://first.example\x07one \x1b]8;;https://second.example\x07two\x1b]8;;\x07",
+		],
+	] as const)("strips raw %s OSC 8 streams", (_name, source) => {
+		for (const style of userMessageStyles) {
+			const output = render(style, source, 80).join("\n");
+			expect(output).not.toContain("\x1b]8;");
+			expect(output).not.toContain("\x9d");
+			expect(output).toMatch(/raw|one/);
+		}
+	});
+
+	it("removes raw non-OSC terminal controls before Markdown", () => {
+		const hostile = [
+			"\x1b[2J",
+			"\x9b2J",
+			"\x1bPsecret\x1b\\",
+			"\x90secret\x9c",
+			"\x1bXsecret\x1b\\",
+			"\x1b^secret\x1b\\",
+			"\x1b_secret\x1b\\",
+			"\x07",
+			"\x01",
+			"\x7f",
+		].join("");
+		for (const style of userMessageStyles) {
+			const output = render(style, `before${hostile}after`, 80).join("\n");
+			expect(output).toContain("beforeafter");
+			expect(output).not.toMatch(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/);
+			expect(output).not.toContain("secret");
+		}
+	});
+
+	it("supports theme and terminal color sources", () => {
+		const themed = config("labeled");
+		const themeLines = renderUserMessageStyle({
+			text: "hello",
+			width: 20,
+			theme: ansiTheme(),
+			config: themed,
+		});
+		expect(themeLines.join("\n")).toContain("\x1b[");
+
+		const terminal = config("compact");
+		terminal.components.userMessages.colorSource = "terminal";
+		terminal.colors.editorAccent = "fg:202";
+		const terminalLines = renderUserMessageStyle({
+			text: "hello",
+			width: 20,
+			theme: ansiTheme(),
+			config: terminal,
+		});
+		expect(terminalLines.join("\n")).toContain("\x1b[");
+	});
+
+	it("uses only style-relevant cache-key inputs", () => {
+		for (const style of userMessageStyles) {
+			const base = config(style);
+			const key = userMessageStyleCacheKey(base);
+			const unrelated = structuredClone(base);
+			unrelated.components.footer.style =
+				unrelated.components.footer.style === "hidden" ? "native" : "hidden";
+			expect(userMessageStyleCacheKey(unrelated)).toBe(key);
+
+			const accent = structuredClone(base);
+			accent.colors.editorAccent = "red";
+			expect(userMessageStyleCacheKey(accent) === key).toBe(style === "framed-copy-friendly");
+
+			const border = structuredClone(base);
+			border.colors.editorBorder = "blue";
+			expect(userMessageStyleCacheKey(border) === key).toBe(style === "compact");
+
+			const rail = structuredClone(base);
+			rail.icons.rail = "┃";
+			expect(userMessageStyleCacheKey(rail) === key).toBe(
+				style === "labeled" || style === "framed-copy-friendly",
+			);
+		}
+
+		expect(userMessageStyleCacheKey(config("framed-copy-friendly"))).not.toBe(
+			userMessageStyleCacheKey(config("framed")),
+		);
+	});
+});