@xynogen/pix-pretty 1.7.17 → 1.7.19

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.7.17",
+	"version": "1.7.19",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, diff rendering, and FFF search",
 	"type": "module",
 	"main": "src/index.ts",

package/src/gate-overlay.test.ts

@@ -160,6 +160,44 @@ describe("showOverlay — sudo mode", () => {
 		expect(result.password).toBeUndefined();
 	});
 
+	test("wrong password retries inside the same overlay", async () => {
+		let component: Wired | undefined;
+		let overlayCount = 0;
+		const attempts: string[] = [];
+		const ui: OverlayUI = {
+			custom: <T>(cb: Parameters<OverlayUI["custom"]>[0]): Promise<T | undefined> => {
+				overlayCount += 1;
+				return new Promise((resolve) => {
+					component = cb({ requestRender: () => {} }, theme, undefined, (value) =>
+						resolve(value as T),
+					);
+				});
+			},
+		};
+
+		const pending = showOverlay(ui, {
+			mode: "sudo",
+			title: "ROOT",
+			timeoutMs: 0,
+			maxPasswordAttempts: 3,
+			validatePassword: async (password) => {
+				attempts.push(password);
+				return password === "correct";
+			},
+		});
+		component?.handleInput(ENTER);
+		component?.handleInput("wrong");
+		component?.handleInput(ENTER);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(component?.render(80).join("\n")).toContain("Incorrect password — attempt 1 of 3");
+		component?.handleInput("correct");
+		component?.handleInput(ENTER);
+
+		expect(await pending).toEqual({ action: "approved", password: "correct" });
+		expect(attempts).toEqual(["wrong", "correct"]);
+		expect(overlayCount).toBe(1);
+	});
+
 	test("password is masked in render (● not plaintext)", async () => {
 		let pwFrame: string[] = [];
 		await showOverlay(

package/src/gate-overlay.ts

@@ -25,6 +25,8 @@ export interface OverlayResult {
 	action: OverlayAction;
 	/** Only present when action === "approved" and mode === "sudo". */
 	password?: string;
+	/** True when password validation exhausted every allowed attempt. */
+	passwordAttemptsExhausted?: boolean;
 }
 
 export interface OverlayChoice {
@@ -64,6 +66,10 @@ export interface SudoConfig extends BaseConfig {
 	mode: "sudo";
 	/** Label for the password input hint. Default "Sudo password:" */
 	passwordLabel?: string;
+	/** Validate an entered password without closing the overlay. */
+	validatePassword?: (password: string) => Promise<boolean>;
+	/** Number of validation attempts before closing as exhausted. Default 3. */
+	maxPasswordAttempts?: number;
 }
 
 export type OverlayConfig = ConfirmConfig | SudoConfig;
@@ -128,9 +134,20 @@ function buildLines(opts: {
 	selectList: SelectList;
 	maskedInput: MaskedInput;
 	countdownLine: string | undefined;
+	passwordStatus: string | undefined;
 	width: number;
 }): string[] {
-	const { theme, accent, config, stage, selectList, maskedInput, countdownLine, width } = opts;
+	const {
+		theme,
+		accent,
+		config,
+		stage,
+		selectList,
+		maskedInput,
+		countdownLine,
+		passwordStatus,
+		width,
+	} = opts;
 	const inner = width - 4; // CHROME = 2 border + 2 padding
 	const lines: string[] = [];
 
@@ -160,6 +177,7 @@ function buildLines(opts: {
 	} else {
 		const label = config.mode === "sudo" ? (config.passwordLabel ?? "Sudo password:") : "Password:";
 		lines.push(theme.fg("muted", label));
+		if (passwordStatus) lines.push(theme.fg("error", passwordStatus));
 		const inputLines = maskedInput.render(inner);
 		for (const l of inputLines) lines.push(l);
 		lines.push("");
@@ -211,6 +229,9 @@ export function showOverlay(ui: OverlayUI, config: OverlayConfig): Promise<Overl
 				type Stage = "select" | "password";
 				let stage: Stage = "select";
 				let countdownLine: string | undefined;
+				let passwordStatus: string | undefined;
+				let passwordAttempts = 0;
+				let validatingPassword = false;
 
 				// Dead-man's-switch timer: counts down only while untouched. The
 				// first keypress cancels it (user is present → let them decide). If
@@ -271,8 +292,36 @@ export function showOverlay(ui: OverlayUI, config: OverlayConfig): Promise<Overl
 				};
 				selectList.onCancel = () => finish({ action: "denied" });
 
-				maskedInput.onSubmit = (pw) => finish({ action: "approved", password: pw });
-				maskedInput.onEscape = () => finish({ action: "denied" });
+				maskedInput.onSubmit = async (pw) => {
+					if (config.mode !== "sudo" || !config.validatePassword) {
+						finish({ action: "approved", password: pw });
+						return;
+					}
+					if (!pw.trim() || validatingPassword) return;
+
+					validatingPassword = true;
+					passwordStatus = "Checking password…";
+					tui.requestRender();
+					const valid = await config.validatePassword(pw);
+					validatingPassword = false;
+					if (valid) {
+						finish({ action: "approved", password: pw });
+						return;
+					}
+
+					passwordAttempts += 1;
+					const maxAttempts = config.maxPasswordAttempts ?? 3;
+					if (passwordAttempts >= maxAttempts) {
+						finish({ action: "approved", password: pw, passwordAttemptsExhausted: true });
+						return;
+					}
+					maskedInput.setValue("");
+					passwordStatus = `Incorrect password — attempt ${passwordAttempts} of ${maxAttempts}`;
+					tui.requestRender();
+				};
+				maskedInput.onEscape = () => {
+					if (!validatingPassword) finish({ action: "denied" });
+				};
 
 				// ── component interface ──────────────────────────────────────────
 				return {
@@ -286,6 +335,7 @@ export function showOverlay(ui: OverlayUI, config: OverlayConfig): Promise<Overl
 							selectList,
 							maskedInput,
 							countdownLine,
+							passwordStatus,
 							width: mw,
 						});
 						return frameLines({
@@ -298,6 +348,7 @@ export function showOverlay(ui: OverlayUI, config: OverlayConfig): Promise<Overl
 					invalidate: () => {},
 					handleInput: (data) => {
 						cancelTimer(); // user is present — stop the auto-deny countdown
+						if (validatingPassword) return;
 						if (stage === "select") selectList.handleInput(data);
 						else maskedInput.handleInput(data);
 						tui.requestRender();

package/src/utils.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "bun:test";
 
 import { MAX_PREVIEW_LINES } from "./config.js";
 import type { FgTheme } from "./types.js";
-import { pluralize, renderDimPreview } from "./utils.js";
+import { pluralize, renderDimPreview, setResultDetails } from "./utils.js";
 
 // Strip ANSI escapes so assertions test content, not color codes.
 const ANSI = /\x1b\[[0-9;]*m/g;
@@ -29,6 +29,27 @@ describe("pluralize", () => {
 	});
 });
 
+describe("setResultDetails", () => {
+	it("preserves upstream metadata while adding renderer details", () => {
+		const result = {
+			content: [{ type: "text" as const, text: "output" }],
+			details: {
+				truncation: { truncated: true, totalLines: 500 },
+				fullOutputPath: "/tmp/full.log",
+			},
+		};
+
+		setResultDetails(result, { _type: "bashResult", exitCode: 0 });
+
+		expect(result.details as Record<string, unknown>).toEqual({
+			truncation: { truncated: true, totalLines: 500 },
+			fullOutputPath: "/tmp/full.log",
+			_type: "bashResult",
+			exitCode: 0,
+		});
+	});
+});
+
 describe("renderDimPreview", () => {
 	it("renders 'done' for empty input", () => {
 		expect(plain(renderDimPreview("", theme))).toContain("done");
@@ -79,7 +100,9 @@ describe("renderDimPreview", () => {
 		expect(plain(raw)).toContain("foo bar foo");
 	});
 
-	it("does not throw on an invalid highlight regex", () => {
-		expect(() => renderDimPreview("text", theme, { highlight: "(" })).not.toThrow();
+	it("treats regex metacharacters as literal highlight text", () => {
+		const raw = renderDimPreview("call(foo)", theme, { highlight: "(" });
+		expect(plain(raw)).toContain("call(foo)");
+		expect(raw).toContain("\x1b[");
 	});
 });

package/src/utils.ts

@@ -59,21 +59,23 @@ export type DimPreviewOptions = {
 	highlight?: string;
 };
 
-function safeHighlightRegex(pattern: string): RegExp | null {
-	try {
-		return new RegExp(`(${pattern})`, "gi");
-	} catch {
-		return null;
+function dimLineWithHighlight(line: string, theme: FgTheme, pattern?: string): string {
+	if (!pattern) return theme.fg("dim", line);
+	const foldedLine = line.toLocaleLowerCase();
+	const foldedPattern = pattern.toLocaleLowerCase();
+	if (!foldedPattern) return theme.fg("dim", line);
+
+	const parts: string[] = [];
+	let start = 0;
+	for (;;) {
+		const match = foldedLine.indexOf(foldedPattern, start);
+		if (match < 0) break;
+		if (match > start) parts.push(theme.fg("dim", line.slice(start, match)));
+		parts.push(`${FG_GREEN}${BOLD}${line.slice(match, match + pattern.length)}${RST}`);
+		start = match + pattern.length;
 	}
-}
-
-function dimLineWithHighlight(line: string, theme: FgTheme, re: RegExp | null): string {
-	if (!re) return theme.fg("dim", line);
-	// split with capture group: odd indexes are matches
-	return line
-		.split(re)
-		.map((part, i) => (i % 2 ? `${FG_GREEN}${BOLD}${part}${RST}` : theme.fg("dim", part)))
-		.join("");
+	if (start < line.length) parts.push(theme.fg("dim", line.slice(start)));
+	return parts.length > 0 ? parts.join("") : theme.fg("dim", line);
 }
 
 export function renderDimPreview(
@@ -82,12 +84,12 @@ export function renderDimPreview(
 	opts: DimPreviewOptions = {},
 ): string {
 	const maxLines = opts.maxLines ?? MAX_PREVIEW_LINES;
-	const re = opts.highlight ? safeHighlightRegex(opts.highlight) : null;
+	const highlight = opts.highlight;
 	const output = normalizeLineEndings(text).trim() || "done";
 	const lines = output.split("\n");
 	const preview = lines
 		.slice(0, maxLines)
-		.map((line) => `  ${dimLineWithHighlight(line, theme, re)}`);
+		.map((line) => `  ${dimLineWithHighlight(line, theme, highlight)}`);
 	if (opts.header) preview.unshift(`  ${theme.fg("dim", opts.header)}`);
 	if (lines.length > maxLines) {
 		const more = pluralize(lines.length - maxLines, "more line");
@@ -208,8 +210,13 @@ export function getTextContent(result: ToolResultLike): string {
 	);
 }
 
+/** Add renderer metadata without discarding execution metadata from the upstream tool. */
 export function setResultDetails<T>(result: ToolResultLike, details: T): void {
-	result.details = details;
+	const upstream =
+		result.details && typeof result.details === "object"
+			? (result.details as Record<string, unknown>)
+			: undefined;
+	result.details = upstream ? { ...upstream, ...details } : details;
 }
 
 export function makeTextResult<TDetails>(