@narumitw/pi-webui 0.20.2 → 0.22.0

package/src/settings.ts

@@ -9,15 +9,35 @@ import {
 } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+	DEFAULT_IMAGE_LIMITS,
+	IMAGE_HARD_LIMITS,
+	type ImageLimits,
+	imageLimits,
+} from "./image-limits.js";
 
 export const SETTINGS_FILE = "pi-webui.json";
 
-export interface WebUISettings {
+const MIB = 1024 * 1024;
+
+export interface WebUISettings extends ImageLimits {
 	startOnSessionStart: boolean;
+	retainSentImages: boolean;
+	maxRetainedImages: number;
+	maxRetainedBytes: number;
 }
 
 export const DEFAULT_SETTINGS: Readonly<WebUISettings> = Object.freeze({
 	startOnSessionStart: false,
+	retainSentImages: false,
+	maxRetainedImages: 32,
+	maxRetainedBytes: 128 * MIB,
+	...DEFAULT_IMAGE_LIMITS,
+});
+
+export const RETENTION_HARD_LIMITS = Object.freeze({
+	maxRetainedImages: 128,
+	maxRetainedBytes: 512 * MIB,
 });
 
 export interface SettingsLoadResult {
@@ -49,17 +69,66 @@ export function settingsFilePath(): string {
 export function normalizeSettings(value: unknown): WebUISettings | undefined {
 	if (!isRecord(value)) return undefined;
 	if (
-		Object.hasOwn(value, "startOnSessionStart") &&
-		typeof value.startOnSessionStart !== "boolean"
+		(Object.hasOwn(value, "startOnSessionStart") &&
+			typeof value.startOnSessionStart !== "boolean") ||
+		(Object.hasOwn(value, "retainSentImages") && typeof value.retainSentImages !== "boolean")
 	) {
 		return undefined;
 	}
-	return {
+	for (const [key, maximum] of [
+		["maxRetainedImages", RETENTION_HARD_LIMITS.maxRetainedImages],
+		["maxRetainedBytes", RETENTION_HARD_LIMITS.maxRetainedBytes],
+		["maxImages", IMAGE_HARD_LIMITS.maxImages],
+		["maxImageBytes", IMAGE_HARD_LIMITS.maxImageBytes],
+		["maxBatchBytes", IMAGE_HARD_LIMITS.maxBatchBytes],
+		["maxImagePixels", IMAGE_HARD_LIMITS.maxImagePixels],
+	] as const) {
+		if (!Object.hasOwn(value, key)) continue;
+		const candidate = value[key];
+		if (
+			typeof candidate !== "number" ||
+			!Number.isSafeInteger(candidate) ||
+			candidate <= 0 ||
+			candidate > maximum
+		) {
+			return undefined;
+		}
+	}
+	const normalized = {
 		startOnSessionStart:
 			typeof value.startOnSessionStart === "boolean"
 				? value.startOnSessionStart
 				: DEFAULT_SETTINGS.startOnSessionStart,
+		retainSentImages:
+			typeof value.retainSentImages === "boolean"
+				? value.retainSentImages
+				: DEFAULT_SETTINGS.retainSentImages,
+		maxRetainedImages:
+			typeof value.maxRetainedImages === "number"
+				? value.maxRetainedImages
+				: DEFAULT_SETTINGS.maxRetainedImages,
+		maxRetainedBytes:
+			typeof value.maxRetainedBytes === "number"
+				? value.maxRetainedBytes
+				: DEFAULT_SETTINGS.maxRetainedBytes,
+		...imageLimits({
+			maxImages: typeof value.maxImages === "number" ? value.maxImages : DEFAULT_SETTINGS.maxImages,
+			maxImageBytes:
+				typeof value.maxImageBytes === "number"
+					? value.maxImageBytes
+					: DEFAULT_SETTINGS.maxImageBytes,
+			maxBatchBytes:
+				typeof value.maxBatchBytes === "number"
+					? value.maxBatchBytes
+					: DEFAULT_SETTINGS.maxBatchBytes,
+			maxImagePixels:
+				typeof value.maxImagePixels === "number"
+					? value.maxImagePixels
+					: DEFAULT_SETTINGS.maxImagePixels,
+		}),
 	};
+	if (normalized.maxImageBytes > normalized.maxBatchBytes) return undefined;
+	return normalized;
 }
 
 export async function loadSettings(path = settingsFilePath()): Promise<SettingsLoadResult> {
@@ -86,8 +155,16 @@ export async function loadSettings(path = settingsFilePath()): Promise<SettingsL
 		const document = JSON.parse(text) as unknown;
 		if (!isRecord(document)) return invalid(path, "the top level must be a JSON object");
 		const settings = normalizeSettings(document);
-		if (!settings) return invalid(path, "startOnSessionStart must be a boolean");
-		return { kind: "loaded", path, settings, source: "settings file", document };
+		if (!settings) return invalid(path, "recognized settings have an invalid type or limit");
+		const warning = elevatedLimitWarning(settings);
+		return {
+			kind: "loaded",
+			path,
+			settings,
+			source: "settings file",
+			document,
+			...(warning ? { warning } : {}),
+		};
 	} catch (error) {
 		return invalid(path, formatError(error));
 	}
@@ -99,7 +176,17 @@ export async function saveSettings(
 	path = settingsFilePath(),
 	operations: Partial<SettingsFileOperations> = {},
 ): Promise<Record<string, unknown>> {
-	const nextDocument = { ...document, startOnSessionStart: settings.startOnSessionStart };
+	const nextDocument = {
+		...document,
+		startOnSessionStart: settings.startOnSessionStart,
+		retainSentImages: settings.retainSentImages,
+		maxRetainedImages: settings.maxRetainedImages,
+		maxRetainedBytes: settings.maxRetainedBytes,
+		maxImages: settings.maxImages,
+		maxImageBytes: settings.maxImageBytes,
+		maxBatchBytes: settings.maxBatchBytes,
+		maxImagePixels: settings.maxImagePixels,
+	};
 	const directory = dirname(path);
 	await mkdir(directory, { recursive: true });
 	const temporaryPath = temporaryFilePath(path);
@@ -147,6 +234,14 @@ export async function initializeSettings(
 	}
 }
 
+function elevatedLimitWarning(settings: WebUISettings): string | undefined {
+	const elevated = (Object.keys(DEFAULT_IMAGE_LIMITS) as Array<keyof ImageLimits>).filter(
+		(key) => settings[key] > DEFAULT_IMAGE_LIMITS[key],
+	);
+	if (elevated.length === 0) return undefined;
+	return `${SETTINGS_FILE} uses image limits above safe defaults: ${elevated.join(", ")}. Higher limits increase Pi-process memory and processing cost.`;
+}
+
 function invalid(path: string, reason: string): SettingsLoadResult {
 	return {
 		kind: "invalid",

package/src/vendor.d.ts

@@ -0,0 +1,30 @@
+declare module "bmp-js" {
+	interface DecodedBmp {
+		data: Buffer;
+		width: number;
+		height: number;
+	}
+	export function decode(buffer: Buffer, withAlpha?: boolean): DecodedBmp;
+}
+
+declare module "heic-decode" {
+	interface DecodedImage {
+		width: number;
+		height: number;
+		data: Uint8ClampedArray;
+	}
+	interface DeferredImage {
+		width: number;
+		height: number;
+		decode(): Promise<DecodedImage>;
+	}
+	interface DeferredImages extends Array<DeferredImage> {
+		dispose(): void;
+	}
+	interface Decode {
+		(options: { buffer: Uint8Array }): Promise<DecodedImage>;
+		all(options: { buffer: Uint8Array }): Promise<DeferredImages>;
+	}
+	const decode: Decode;
+	export default decode;
+}