@oh-my-pi/pi-coding-agent 4.8.1 → 4.9.0

package/CHANGELOG.md

@@ -2,11 +2,13 @@
 
 ## [Unreleased]
 
-## [4.8.1] - 2026-01-12
+## [4.9.0] - 2026-01-12
 
-### Fixed
+## [4.8.3] - 2026-01-12
+
+### Changed
 
-- Prevent bun from statically resolving sharp import to fix runtime errors on arm64
+- Replace sharp with wasm-vips for cross-platform image processing without native dependencies
 
 ## [4.8.0] - 2026-01-12
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.8.1",
+	"version": "4.9.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.8.1",
-		"@oh-my-pi/pi-agent-core": "4.8.1",
-		"@oh-my-pi/pi-git-tool": "4.8.1",
-		"@oh-my-pi/pi-tui": "4.8.1",
+		"@oh-my-pi/pi-agent-core": "4.9.0",
+		"@oh-my-pi/pi-ai": "4.9.0",
+		"@oh-my-pi/pi-git-tool": "4.9.0",
+		"@oh-my-pi/pi-tui": "4.9.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
@@ -60,6 +60,7 @@
 		"node-html-parser": "^6.1.13",
 		"smol-toml": "^1.6.0",
 		"strip-ansi": "^7.1.2",
+		"wasm-vips": "^0.0.16",
 		"winston": "^3.17.0",
 		"winston-daily-rotate-file": "^5.0.0",
 		"zod": "^4.3.5"
@@ -71,9 +72,6 @@
 		"@types/node": "^24.3.0",
 		"ms": "^2.1.3"
 	},
-	"optionalDependencies": {
-		"sharp": "^0.34.2"
-	},
 	"keywords": [
 		"coding-agent",
 		"ai",

package/src/utils/image-convert.ts

@@ -1,9 +1,11 @@
+import { logger } from "../core/logger";
 import { convertToPngWithImageMagick } from "./image-magick";
+import { Vips } from "./vips";
 
 /**
  * Convert image to PNG format for terminal display.
  * Kitty graphics protocol requires PNG format (f=100).
- * Uses sharp if available, falls back to ImageMagick (magick/convert).
+ * Uses wasm-vips if available, falls back to ImageMagick (magick/convert).
  */
 export async function convertToPng(
 	base64Data: string,
@@ -14,19 +16,23 @@ export async function convertToPng(
 		return { data: base64Data, mimeType };
 	}
 
-	// Try sharp first
 	try {
-		// Use variable to prevent bun from statically analyzing the import
-		const sharpModule = "sharp";
-		const sharp = (await import(/* @vite-ignore */ sharpModule)).default;
-		const buffer = Buffer.from(base64Data, "base64");
-		const pngBuffer = await sharp(buffer).png().toBuffer();
-		return {
-			data: pngBuffer.toString("base64"),
-			mimeType: "image/png",
-		};
-	} catch {
-		// Sharp not available, try ImageMagick fallback
+		const { Image } = await Vips();
+		const image = Image.newFromBuffer(Buffer.from(base64Data, "base64"));
+		try {
+			const pngBuffer = image.writeToBuffer(".png");
+			return {
+				data: Buffer.from(pngBuffer).toString("base64"),
+				mimeType: "image/png",
+			};
+		} finally {
+			image.delete();
+		}
+	} catch (error) {
+		// wasm-vips failed, try ImageMagick fallback
+		logger.error("Failed to convert image to PNG with wasm-vips", {
+			error: error instanceof Error ? error.message : String(error),
+		});
 	}
 
 	// Fall back to ImageMagick

package/src/utils/image-resize.ts

@@ -1,5 +1,7 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { logger } from "../core/logger";
 import { getImageDimensionsWithImageMagick, resizeWithImageMagick } from "./image-magick";
+import { Vips } from "./vips";
 
 export interface ImageResizeOptions {
 	maxWidth?: number; // Default: 2000
@@ -29,18 +31,16 @@ const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
 };
 
 /**
- * Fallback resize using ImageMagick when sharp is unavailable.
+ * Fallback resize using ImageMagick when wasm-vips is unavailable.
  */
 async function resizeImageWithImageMagick(
 	img: ImageContent,
 	opts: Required<ImageResizeOptions>,
 ): Promise<ResizedImage> {
-	// Try to get dimensions first
 	const dims = await getImageDimensionsWithImageMagick(img.data);
 	const originalWidth = dims?.width ?? 0;
 	const originalHeight = dims?.height ?? 0;
 
-	// Try to resize
 	const result = await resizeWithImageMagick(
 		img.data,
 		img.mimeType,
@@ -62,7 +62,6 @@ async function resizeImageWithImageMagick(
 		};
 	}
 
-	// ImageMagick not available or resize not needed - return original
 	return {
 		data: img.data,
 		mimeType: img.mimeType,
@@ -76,9 +75,9 @@ async function resizeImageWithImageMagick(
 
 /** Helper to pick the smaller of two buffers */
 function pickSmaller(
-	a: { buffer: Buffer; mimeType: string },
-	b: { buffer: Buffer; mimeType: string },
-): { buffer: Buffer; mimeType: string } {
+	a: { buffer: Uint8Array; mimeType: string },
+	b: { buffer: Uint8Array; mimeType: string },
+): { buffer: Uint8Array; mimeType: string } {
 	return a.buffer.length <= b.buffer.length ? a : b;
 }
 
@@ -86,8 +85,7 @@ function pickSmaller(
  * Resize an image to fit within the specified max dimensions and file size.
  * Returns the original image if it already fits within the limits.
  *
- * Uses sharp for image processing. If sharp is not available (e.g., in some
- * environments), returns the original image unchanged.
+ * Uses wasm-vips for image processing. Falls back to ImageMagick if unavailable.
  *
  * Strategy for staying under maxBytes:
  * 1. First resize to maxWidth/maxHeight
@@ -99,97 +97,130 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const buffer = Buffer.from(img.data, "base64");
 
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	let sharp: any;
 	try {
-		// Use variable to prevent bun from statically analyzing the import
-		const sharpModule = "sharp";
-		sharp = (await import(/* @vite-ignore */ sharpModule)).default;
-	} catch {
-		// Sharp not available - try ImageMagick fallback
-		return resizeImageWithImageMagick(img, opts);
-	}
-
-	const sharpImg = sharp(buffer);
-	const metadata = await sharpImg.metadata();
+		const { Image } = await Vips();
+		const image = Image.newFromBuffer(buffer);
+		try {
+			const originalWidth = image.width;
+			const originalHeight = image.height;
+			const format = img.mimeType?.split("/")[1] ?? "png";
+
+			// Check if already within all limits (dimensions AND size)
+			const originalSize = buffer.length;
+			if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= opts.maxBytes) {
+				return {
+					data: img.data,
+					mimeType: img.mimeType ?? `image/${format}`,
+					originalWidth,
+					originalHeight,
+					width: originalWidth,
+					height: originalHeight,
+					wasResized: false,
+				};
+			}
 
-	const originalWidth = metadata.width ?? 0;
-	const originalHeight = metadata.height ?? 0;
-	const format = metadata.format ?? img.mimeType?.split("/")[1] ?? "png";
+			// Calculate initial dimensions respecting max limits
+			let targetWidth = originalWidth;
+			let targetHeight = originalHeight;
 
-	// Check if already within all limits (dimensions AND size)
-	const originalSize = buffer.length;
-	if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= opts.maxBytes) {
-		return {
-			data: img.data,
-			mimeType: img.mimeType ?? `image/${format}`,
-			originalWidth,
-			originalHeight,
-			width: originalWidth,
-			height: originalHeight,
-			wasResized: false,
-		};
-	}
+			if (targetWidth > opts.maxWidth) {
+				targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
+				targetWidth = opts.maxWidth;
+			}
+			if (targetHeight > opts.maxHeight) {
+				targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
+				targetHeight = opts.maxHeight;
+			}
 
-	// Calculate initial dimensions respecting max limits
-	let targetWidth = originalWidth;
-	let targetHeight = originalHeight;
+			// Helper to resize and encode in both formats, returning the smaller one
+			function tryBothFormats(
+				width: number,
+				height: number,
+				jpegQuality: number,
+			): { buffer: Uint8Array; mimeType: string } {
+				const scale = Math.min(width / originalWidth, height / originalHeight);
+				const resized = image!.resize(scale);
 
-	if (targetWidth > opts.maxWidth) {
-		targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
-		targetWidth = opts.maxWidth;
-	}
-	if (targetHeight > opts.maxHeight) {
-		targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
-		targetHeight = opts.maxHeight;
-	}
+				const pngBuffer = resized.writeToBuffer(".png");
+				const jpegBuffer = resized.writeToBuffer(".jpg", { Q: jpegQuality });
 
-	// Helper to resize and encode in both formats, returning the smaller one
-	async function tryBothFormats(
-		width: number,
-		height: number,
-		jpegQuality: number,
-	): Promise<{ buffer: Buffer; mimeType: string }> {
-		const resized = await sharp(buffer).resize(width, height, { fit: "inside", withoutEnlargement: true }).toBuffer();
+				resized.delete();
 
-		const [pngBuffer, jpegBuffer] = await Promise.all([
-			sharp(resized).png({ compressionLevel: 9 }).toBuffer(),
-			sharp(resized).jpeg({ quality: jpegQuality }).toBuffer(),
-		]);
+				return pickSmaller(
+					{ buffer: pngBuffer, mimeType: "image/png" },
+					{ buffer: jpegBuffer, mimeType: "image/jpeg" },
+				);
+			}
 
-		return pickSmaller({ buffer: pngBuffer, mimeType: "image/png" }, { buffer: jpegBuffer, mimeType: "image/jpeg" });
-	}
+			// Try to produce an image under maxBytes
+			const qualitySteps = [85, 70, 55, 40];
+			const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
 
-	// Try to produce an image under maxBytes
-	const qualitySteps = [85, 70, 55, 40];
-	const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
+			let best: { buffer: Uint8Array; mimeType: string };
+			let finalWidth = targetWidth;
+			let finalHeight = targetHeight;
 
-	let best: { buffer: Buffer; mimeType: string };
-	let finalWidth = targetWidth;
-	let finalHeight = targetHeight;
+			// First attempt: resize to target dimensions, try both formats
+			best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
 
-	// First attempt: resize to target dimensions, try both formats
-	best = await tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+			if (best.buffer.length <= opts.maxBytes) {
+				return {
+					data: Buffer.from(best.buffer).toString("base64"),
+					mimeType: best.mimeType,
+					originalWidth,
+					originalHeight,
+					width: finalWidth,
+					height: finalHeight,
+					wasResized: true,
+				};
+			}
 
-	if (best.buffer.length <= opts.maxBytes) {
-		return {
-			data: best.buffer.toString("base64"),
-			mimeType: best.mimeType,
-			originalWidth,
-			originalHeight,
-			width: finalWidth,
-			height: finalHeight,
-			wasResized: true,
-		};
-	}
+			// Still too large - try JPEG with decreasing quality
+			for (const quality of qualitySteps) {
+				best = tryBothFormats(targetWidth, targetHeight, quality);
+
+				if (best.buffer.length <= opts.maxBytes) {
+					return {
+						data: Buffer.from(best.buffer).toString("base64"),
+						mimeType: best.mimeType,
+						originalWidth,
+						originalHeight,
+						width: finalWidth,
+						height: finalHeight,
+						wasResized: true,
+					};
+				}
+			}
 
-	// Still too large - try JPEG with decreasing quality (and compare to PNG each time)
-	for (const quality of qualitySteps) {
-		best = await tryBothFormats(targetWidth, targetHeight, quality);
+			// Still too large - reduce dimensions progressively
+			for (const scale of scaleSteps) {
+				finalWidth = Math.round(targetWidth * scale);
+				finalHeight = Math.round(targetHeight * scale);
+
+				if (finalWidth < 100 || finalHeight < 100) {
+					break;
+				}
+
+				for (const quality of qualitySteps) {
+					best = tryBothFormats(finalWidth, finalHeight, quality);
+
+					if (best.buffer.length <= opts.maxBytes) {
+						return {
+							data: Buffer.from(best.buffer).toString("base64"),
+							mimeType: best.mimeType,
+							originalWidth,
+							originalHeight,
+							width: finalWidth,
+							height: finalHeight,
+							wasResized: true,
+						};
+					}
+				}
+			}
 
-		if (best.buffer.length <= opts.maxBytes) {
+			// Last resort: return smallest version we produced
 			return {
-				data: best.buffer.toString("base64"),
+				data: Buffer.from(best.buffer).toString("base64"),
 				mimeType: best.mimeType,
 				originalWidth,
 				originalHeight,
@@ -197,47 +228,15 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 				height: finalHeight,
 				wasResized: true,
 			};
+		} finally {
+			image.delete();
 		}
+	} catch (error) {
+		logger.error("Failed to resize image with wasm-vips", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return resizeImageWithImageMagick(img, opts);
 	}
-
-	// Still too large - reduce dimensions progressively
-	for (const scale of scaleSteps) {
-		finalWidth = Math.round(targetWidth * scale);
-		finalHeight = Math.round(targetHeight * scale);
-
-		// Skip if dimensions are too small
-		if (finalWidth < 100 || finalHeight < 100) {
-			break;
-		}
-
-		for (const quality of qualitySteps) {
-			best = await tryBothFormats(finalWidth, finalHeight, quality);
-
-			if (best.buffer.length <= opts.maxBytes) {
-				return {
-					data: best.buffer.toString("base64"),
-					mimeType: best.mimeType,
-					originalWidth,
-					originalHeight,
-					width: finalWidth,
-					height: finalHeight,
-					wasResized: true,
-				};
-			}
-		}
-	}
-
-	// Last resort: return smallest version we produced even if over limit
-	// (the API will reject it, but at least we tried everything)
-	return {
-		data: best.buffer.toString("base64"),
-		mimeType: best.mimeType,
-		originalWidth,
-		originalHeight,
-		width: finalWidth,
-		height: finalHeight,
-		wasResized: true,
-	};
 }
 
 /**

package/src/utils/vips.ts

@@ -0,0 +1,23 @@
+import type realVips from "wasm-vips";
+import { logger } from "../core/logger";
+
+// Cached vips instance
+let _vips: Promise<typeof realVips> | undefined;
+
+/**
+ * Get the vips instance.
+ * @returns The vips instance.
+ */
+export function Vips(): Promise<typeof realVips> {
+	if (_vips) return _vips;
+
+	let instance: Promise<typeof realVips> | undefined;
+	try {
+		instance = import("wasm-vips").then((mod) => (mod.default ?? mod)());
+	} catch (error) {
+		logger.error("Failed to import wasm-vips", { error: error instanceof Error ? error.message : String(error) });
+		instance = Promise.reject(error);
+	}
+	_vips = instance;
+	return instance;
+}