@oh-my-pi/pi-coding-agent 5.0.1 → 5.1.1

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [5.1.1] - 2026-01-14
+
+### Fixed
+
+- Fixed clipboard image paste getting stuck on Wayland when no image is present (was falling back to X11 and timing out)
+
+## [5.1.0] - 2026-01-14
+
+### Changed
+
+- Updated light theme colors for WCAG AA compliance (4.5:1 contrast against white background)
+- Changed dequeue hint text from "restore" to "edit all queued messages"
+
+### Fixed
+
+- Fixed session selector staying open when current folder has no sessions (shows hint to press Tab)
+- Fixed print mode JSON output to emit session header at start
+- Fixed "database is locked" SQLite errors when running subagents by serializing settings to workers instead of opening the database
+- Fixed `/new` command to create a new session file (previously reused the same file when `--session` was specified)
+- Fixed session selector page up/down navigation
+
 ## [5.0.1] - 2026-01-12
 ### Changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "5.0.1",
+	"version": "5.1.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,12 +39,12 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "5.0.1",
-		"@oh-my-pi/pi-ai": "5.0.1",
-		"@oh-my-pi/pi-git-tool": "5.0.1",
-		"@oh-my-pi/pi-tui": "5.0.1",
+		"@oh-my-pi/pi-agent-core": "5.1.1",
+		"@oh-my-pi/pi-ai": "5.1.1",
+		"@oh-my-pi/pi-git-tool": "5.1.1",
+		"@oh-my-pi/pi-tui": "5.1.1",
 		"@openai/agents": "^0.3.7",
-		"@silvia-odwyer/photon": "^0.3.3",
+		"@silvia-odwyer/photon-node": "^0.3.4",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
 		"chalk": "^5.5.0",

package/src/core/agent-storage.ts

@@ -173,6 +173,7 @@ export class AgentStorage {
 		this.db.exec(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
+PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS auth_credentials (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,

package/src/core/history-storage.ts

@@ -42,6 +42,7 @@ export class HistoryStorage {
 		this.db.exec(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
+PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS history (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,

package/src/core/model-registry.ts

@@ -8,7 +8,6 @@ import {
 	getGitHubCopilotBaseUrl,
 	getModels,
 	getProviders,
-	type KnownProvider,
 	type Model,
 	normalizeDomain,
 } from "@oh-my-pi/pi-ai";
@@ -250,7 +249,7 @@ export class ModelRegistry {
 		return getProviders()
 			.filter((provider) => !replacedProviders.has(provider))
 			.flatMap((provider) => {
-				const models = getModels(provider as KnownProvider) as Model<Api>[];
+				const models = getModels(provider as any) as Model<Api>[];
 				const override = overrides.get(provider);
 				if (!override) return models;
 

package/src/core/model-resolver.ts

@@ -11,6 +11,7 @@ import type { ModelRegistry } from "./model-registry";
 
 /** Default model IDs for each known provider */
 export const defaultModelPerProvider: Record<KnownProvider, string> = {
+	"amazon-bedrock": "us.anthropic.claude-sonnet-4-5-20250514-v1:0",
 	anthropic: "claude-sonnet-4-5",
 	openai: "gpt-5.1-codex",
 	"openai-codex": "codex-max",
@@ -21,11 +22,13 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	"github-copilot": "gpt-4o",
 	cursor: "claude-sonnet-4-5",
 	openrouter: "openai/gpt-5.1-codex",
+	"vercel-ai-gateway": "claude-sonnet-4-5",
 	xai: "grok-4-fast-non-reasoning",
 	groq: "openai/gpt-oss-120b",
 	cerebras: "zai-glm-4.6",
 	zai: "glm-4.6",
 	mistral: "devstral-medium-latest",
+	minimax: "MiniMax-M2",
 	opencode: "claude-opus-4-5",
 };
 

package/src/core/sdk.ts

@@ -689,6 +689,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return activeModel ? formatModelString(activeModel) : undefined;
 		},
 		settings: settingsManager,
+		settingsManager,
 		authStorage,
 		modelRegistry,
 	};

package/src/core/session-manager.ts

@@ -894,7 +894,9 @@ export class SessionManager {
 			this._buildIndex();
 			this.flushed = true;
 		} else {
+			const explicitPath = this.sessionFile;
 			this._newSessionSync();
+			this.sessionFile = explicitPath; // preserve explicit path from --session flag
 		}
 	}
 
@@ -921,12 +923,12 @@ export class SessionManager {
 		};
 		this.fileEntries = [header];
 		this.byId.clear();
+		this.labelsById.clear();
 		this.leafId = null;
 		this.flushed = false;
 		this.usageStatistics = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
 
-		// Only generate filename if persisting and not already set (e.g., via --session flag)
-		if (this.persist && !this.sessionFile) {
+		if (this.persist) {
 			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 			this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
 		}

package/src/core/settings-manager.ts

@@ -506,6 +506,14 @@ export class SettingsManager {
 		return new SettingsManager(null, null, settings, false, {});
 	}
 
+	/**
+	 * Serialize settings for passing to subagent workers.
+	 * Returns the merged settings (global + project + overrides).
+	 */
+	serialize(): Settings {
+		return { ...this.settings };
+	}
+
 	/**
 	 * Load settings from SQLite storage, applying any schema migrations.
 	 * @param storage - AgentStorage instance, or null for in-memory mode

package/src/core/tools/index.ts

@@ -116,6 +116,8 @@ export interface ToolSession {
 	modelRegistry?: import("../model-registry").ModelRegistry;
 	/** MCP manager for proxying MCP calls through parent */
 	mcpManager?: import("../mcp/manager").MCPManager;
+	/** Settings manager for passing to subagents (avoids SQLite access in workers) */
+	settingsManager?: { serialize: () => import("../settings-manager").Settings };
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;

package/src/core/tools/task/executor.ts

@@ -52,6 +52,7 @@ export interface ExecutorOptions {
 	mcpManager?: MCPManager;
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
+	settingsManager?: { serialize: () => import("../../settings-manager").Settings };
 }
 
 /**
@@ -600,6 +601,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			enableLsp,
 			serializedAuth: options.authStorage?.serialize(),
 			serializedModels: options.modelRegistry?.serialize(),
+			serializedSettings: options.settingsManager?.serialize(),
 			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
 		},
 	};

package/src/core/tools/task/index.ts

@@ -364,6 +364,7 @@ export async function createTaskTool(
 							},
 							authStorage: session.authStorage,
 							modelRegistry: session.modelRegistry,
+							settingsManager: session.settingsManager,
 							mcpManager: session.mcpManager,
 						});
 					},

package/src/core/tools/task/worker-protocol.ts

@@ -1,6 +1,7 @@
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { SerializedAuthStorage } from "../../auth-storage";
 import type { SerializedModelRegistry } from "../../model-registry";
+import type { Settings } from "../../settings-manager";
 
 /**
  * MCP tool metadata passed from parent to worker for proxy tool creation.
@@ -51,6 +52,7 @@ export interface SubagentWorkerStartPayload {
 	spawnsEnv?: string;
 	serializedAuth?: SerializedAuthStorage;
 	serializedModels?: SerializedModelRegistry;
+	serializedSettings?: Settings;
 	mcpTools?: MCPToolMetadata[];
 }
 

package/src/core/tools/task/worker.ts

@@ -23,6 +23,7 @@ import { ModelRegistry } from "../../model-registry";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
+import { SettingsManager } from "../../settings-manager";
 import { untilAborted } from "../../utils";
 import type {
 	MCPToolCallResponse,
@@ -296,6 +297,10 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			: SessionManager.inMemory(payload.cwd);
 		checkAbort();
 
+		// Use serialized settings if provided, otherwise use empty in-memory settings
+		// This avoids opening the SQLite database in worker threads
+		const settingsManager = SettingsManager.inMemory(payload.serializedSettings ?? {});
+
 		// Create agent session (equivalent to CLI's createAgentSession)
 		// Note: hasUI: false disables interactive features
 		const completionInstruction =
@@ -305,6 +310,7 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			cwd: payload.cwd,
 			authStorage,
 			modelRegistry,
+			settingsManager,
 			model,
 			thinkingLevel,
 			toolNames: payload.toolNames,

package/src/index.ts

@@ -260,9 +260,11 @@ export {
 } from "./modes/interactive/components/index";
 // Theme utilities for custom tools
 export {
+	getLanguageFromPath,
 	getMarkdownTheme,
 	getSelectListTheme,
 	getSettingsListTheme,
+	highlightCode,
 	initTheme,
 	Theme,
 	type ThemeColor,

package/src/modes/interactive/components/session-selector.ts

@@ -7,6 +7,8 @@ import {
 	isCtrlC,
 	isEnter,
 	isEscape,
+	isPageDown,
+	isPageUp,
 	Spacer,
 	Text,
 	truncateToWidth,
@@ -25,14 +27,16 @@ class SessionList implements Component {
 	private filteredSessions: SessionInfo[] = [];
 	private selectedIndex: number = 0;
 	private searchInput: Input;
+	private showCwd = false;
 	public onSelect?: (sessionPath: string) => void;
 	public onCancel?: () => void;
 	public onExit: () => void = () => {};
 	private maxVisible: number = 5; // Max sessions visible (each session is 3 lines: msg + metadata + blank)
 
-	constructor(sessions: SessionInfo[]) {
+	constructor(sessions: SessionInfo[], showCwd = false) {
 		this.allSessions = sessions;
 		this.filteredSessions = sessions;
+		this.showCwd = showCwd;
 		this.searchInput = new Input();
 
 		// Handle Enter in search input - select current item
@@ -67,7 +71,13 @@ class SessionList implements Component {
 		lines.push(""); // Blank line after search
 
 		if (this.filteredSessions.length === 0) {
-			lines.push(theme.fg("muted", "  No sessions found"));
+			if (this.showCwd) {
+				// "All" scope - no sessions anywhere that match filter
+				lines.push(theme.fg("muted", "  No sessions found"));
+			} else {
+				// "Current folder" scope - hint to try "all"
+				lines.push(theme.fg("muted", "  No sessions in current folder. Press Tab to view all."));
+			}
 			return lines;
 		}
 
@@ -154,6 +164,14 @@ class SessionList implements Component {
 		else if (isArrowDown(keyData)) {
 			this.selectedIndex = Math.min(this.filteredSessions.length - 1, this.selectedIndex + 1);
 		}
+		// Page up - jump up by maxVisible items
+		else if (isPageUp(keyData)) {
+			this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisible);
+		}
+		// Page down - jump down by maxVisible items
+		else if (isPageDown(keyData)) {
+			this.selectedIndex = Math.min(this.filteredSessions.length - 1, this.selectedIndex + this.maxVisible);
+		}
 		// Enter
 		else if (isEnter(keyData)) {
 			const selected = this.filteredSessions[this.selectedIndex];
@@ -211,11 +229,6 @@ export class SessionSelectorComponent extends Container {
 		// Add bottom border
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
-
-		// Auto-cancel if no sessions
-		if (sessions.length === 0) {
-			setTimeout(() => onCancel(), 100);
-		}
 	}
 
 	getSessionList(): SessionList {

package/src/modes/interactive/theme/light.json

@@ -2,13 +2,13 @@
 	"$schema": "https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/theme-schema.json",
 	"name": "light",
 	"vars": {
-		"teal": "#5f8787",
-		"blue": "#5f87af",
-		"green": "#87af87",
-		"red": "#af5f5f",
-		"yellow": "#d7af5f",
+		"teal": "#5a8080",
+		"blue": "#547da7",
+		"green": "#588458",
+		"red": "#aa5555",
+		"yellow": "#9a7326",
 		"mediumGray": "#6c6c6c",
-		"dimGray": "#8a8a8a",
+		"dimGray": "#767676",
 		"lightGray": "#b0b0b0",
 		"selectedBg": "#d0d0e0",
 		"userMsgBg": "#e8e8e8",
@@ -68,9 +68,9 @@
 		"syntaxPunctuation": "#000000",
 
 		"thinkingOff": "lightGray",
-		"thinkingMinimal": "#9e9e9e",
-		"thinkingLow": "#5f87af",
-		"thinkingMedium": "#5f8787",
+		"thinkingMinimal": "#767676",
+		"thinkingLow": "blue",
+		"thinkingMedium": "teal",
 		"thinkingHigh": "#875f87",
 		"thinkingXhigh": "#8b008b",
 

package/src/modes/interactive/utils/ui-helpers.ts

@@ -340,6 +340,8 @@ export class UiHelpers {
 				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
 				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
 			}
+			const hintText = theme.fg("dim", `${theme.tree.hook} Alt+Up to edit`);
+			this.ctx.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
 		}
 	}
 

package/src/modes/print-mode.ts

@@ -29,6 +29,14 @@ export interface PrintModeOptions {
  */
 export async function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void> {
 	const { mode, messages = [], initialMessage, initialImages } = options;
+
+	// Emit session header for JSON mode
+	if (mode === "json") {
+		const header = session.sessionManager.getHeader();
+		if (header) {
+			process.stdout.write(`${JSON.stringify(header)}\n`);
+		}
+	}
 	// Set up extensions for print mode (no UI, no command context)
 	const extensionRunner = session.extensionRunner;
 	if (extensionRunner) {

package/src/utils/clipboard.ts

@@ -151,19 +151,29 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 	return null;
 }
 
+type ClipboardReadResult =
+	| { status: "found"; image: ClipboardImage }
+	| { status: "empty" } // Tools ran successfully, no image in clipboard
+	| { status: "unavailable" }; // Tools not found or failed to run
+
 async function readImageLinux(timeout: number): Promise<ClipboardImage | null> {
 	const wayland = isWaylandSession();
 	if (wayland) {
-		const image = await readImageWayland(timeout);
-		if (image) return image;
+		const result = await readImageWayland(timeout);
+		if (result.status === "found") return result.image;
+		if (result.status === "empty") return null; // Don't fall back to X11 if Wayland worked
 	}
 
-	return await readImageX11(timeout);
+	const result = await readImageX11(timeout);
+	return result.status === "found" ? result.image : null;
 }
 
-async function readImageWayland(timeout: number): Promise<ClipboardImage | null> {
-	const types = await spawnAndRead(["wl-paste", "--list-types"], timeout);
-	if (!types) return null;
+async function readImageWayland(timeout: number): Promise<ClipboardReadResult> {
+	const wlPastePath = Bun.which("wl-paste");
+	if (!wlPastePath) return { status: "unavailable" };
+
+	const types = await spawnAndRead([wlPastePath, "--list-types"], timeout);
+	if (!types) return { status: "unavailable" }; // Command failed
 
 	const typeList = types
 		.toString("utf-8")
@@ -172,43 +182,46 @@ async function readImageWayland(timeout: number): Promise<ClipboardImage | null>
 		.filter(Boolean);
 
 	const selectedType = selectPreferredImageMimeType(typeList);
-	if (!selectedType) return null;
+	if (!selectedType) return { status: "empty" }; // No image types available
 
-	const imageData = await spawnAndRead(["wl-paste", "--type", selectedType, "--no-newline"], timeout);
-	if (!imageData || imageData.length === 0) return null;
+	const imageData = await spawnAndRead([wlPastePath, "--type", selectedType, "--no-newline"], timeout);
+	if (!imageData || imageData.length === 0) return { status: "empty" };
 
 	return {
-		data: imageData.toString("base64"),
-		mimeType: baseMimeType(selectedType),
+		status: "found",
+		image: {
+			data: imageData.toString("base64"),
+			mimeType: baseMimeType(selectedType),
+		},
 	};
 }
 
-async function readImageX11(timeout: number): Promise<ClipboardImage | null> {
-	const targets = await spawnAndRead(["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"], timeout);
+async function readImageX11(timeout: number): Promise<ClipboardReadResult> {
+	const xclipPath = Bun.which("xclip");
+	if (!xclipPath) return { status: "unavailable" };
 
-	let candidateTypes: string[] = [];
-	if (targets) {
-		candidateTypes = targets
-			.toString("utf-8")
-			.split(/\r?\n/)
-			.map((t) => t.trim())
-			.filter(Boolean);
-	}
+	const targets = await spawnAndRead([xclipPath, "-selection", "clipboard", "-t", "TARGETS", "-o"], timeout);
+	if (!targets) return { status: "unavailable" }; // xclip failed (no X server?)
 
-	const preferred = candidateTypes.length > 0 ? selectPreferredImageMimeType(candidateTypes) : null;
-	const tryTypes = preferred ? [preferred, ...PREFERRED_IMAGE_MIME_TYPES] : [...PREFERRED_IMAGE_MIME_TYPES];
+	const candidateTypes = targets
+		.toString("utf-8")
+		.split(/\r?\n/)
+		.map((t) => t.trim())
+		.filter(Boolean);
 
-	for (const mimeType of tryTypes) {
-		const imageData = await spawnAndRead(["xclip", "-selection", "clipboard", "-t", mimeType, "-o"], timeout);
-		if (imageData && imageData.length > 0) {
-			return {
-				data: imageData.toString("base64"),
-				mimeType: baseMimeType(mimeType),
-			};
-		}
-	}
+	const selectedType = selectPreferredImageMimeType(candidateTypes);
+	if (!selectedType) return { status: "empty" }; // Clipboard has no image types
 
-	return null;
+	const imageData = await spawnAndRead([xclipPath, "-selection", "clipboard", "-t", selectedType, "-o"], timeout);
+	if (!imageData || imageData.length === 0) return { status: "empty" };
+
+	return {
+		status: "found",
+		image: {
+			data: imageData.toString("base64"),
+			mimeType: baseMimeType(selectedType),
+		},
+	};
 }
 
 async function readImageMacOS(timeout: number): Promise<ClipboardImage | null> {

package/src/utils/image-convert.ts

@@ -1,11 +1,8 @@
-import { logger } from "../core/logger";
-import { convertToPngWithImageMagick } from "./image-magick";
-import { getPhoton } from "./photon";
+import photon from "@silvia-odwyer/photon-node";
 
 /**
  * Convert image to PNG format for terminal display.
  * Kitty graphics protocol requires PNG format (f=100).
- * Uses Photon (Rust/WASM) if available, falls back to ImageMagick.
  */
 export async function convertToPng(
 	base64Data: string,
@@ -17,7 +14,6 @@ export async function convertToPng(
 	}
 
 	try {
-		const photon = await getPhoton();
 		const image = photon.PhotonImage.new_from_byteslice(new Uint8Array(Buffer.from(base64Data, "base64")));
 		try {
 			const pngBuffer = image.get_bytes();
@@ -28,13 +24,8 @@ export async function convertToPng(
 		} finally {
 			image.free();
 		}
-	} catch (error) {
-		// Photon failed, try ImageMagick fallback
-		logger.error("Failed to convert image to PNG with Photon", {
-			error: error instanceof Error ? error.message : String(error),
-		});
+	} catch {
+		// Conversion failed
+		return null;
 	}
-
-	// Fall back to ImageMagick
-	return convertToPngWithImageMagick(base64Data, mimeType);
 }

package/src/utils/image-resize.ts

@@ -1,7 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { logger } from "../core/logger";
-import { getImageDimensionsWithImageMagick, resizeWithImageMagick } from "./image-magick";
-import { getPhoton } from "./photon";
+import photon from "@silvia-odwyer/photon-node";
 
 export interface ImageResizeOptions {
 	maxWidth?: number; // Default: 2000
@@ -30,49 +28,6 @@ const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
 	jpegQuality: 80,
 };
 
-/**
- * Fallback resize using ImageMagick when Photon is unavailable.
- */
-async function resizeImageWithImageMagick(
-	img: ImageContent,
-	opts: Required<ImageResizeOptions>,
-): Promise<ResizedImage> {
-	const dims = await getImageDimensionsWithImageMagick(img.data);
-	const originalWidth = dims?.width ?? 0;
-	const originalHeight = dims?.height ?? 0;
-
-	const result = await resizeWithImageMagick(
-		img.data,
-		img.mimeType,
-		opts.maxWidth,
-		opts.maxHeight,
-		opts.maxBytes,
-		opts.jpegQuality,
-	);
-
-	if (result) {
-		return {
-			data: result.data,
-			mimeType: result.mimeType,
-			originalWidth,
-			originalHeight,
-			width: result.width,
-			height: result.height,
-			wasResized: true,
-		};
-	}
-
-	return {
-		data: img.data,
-		mimeType: img.mimeType,
-		originalWidth,
-		originalHeight,
-		width: originalWidth,
-		height: originalHeight,
-		wasResized: false,
-	};
-}
-
 /** Helper to pick the smaller of two buffers */
 function pickSmaller(
 	a: { buffer: Uint8Array; mimeType: string },
@@ -85,7 +40,8 @@ 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 Photon (Rust/WASM) for image processing. Falls back to ImageMagick if unavailable.
+ * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
+ * returns the original image unchanged.
  *
  * Strategy for staying under maxBytes:
  * 1. First resize to maxWidth/maxHeight
@@ -97,73 +53,88 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const inputBuffer = Buffer.from(img.data, "base64");
 
+	let image: ReturnType<typeof photon.PhotonImage.new_from_byteslice> | undefined;
 	try {
-		const photon = await getPhoton();
-		const image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
+		image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
 
-		try {
-			const originalWidth = image.get_width();
-			const originalHeight = image.get_height();
-			const format = img.mimeType?.split("/")[1] ?? "png";
+		const originalWidth = image.get_width();
+		const originalHeight = image.get_height();
+		const format = img.mimeType?.split("/")[1] ?? "png";
 
-			// Check if already within all limits (dimensions AND size)
-			const originalSize = inputBuffer.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,
-				};
-			}
+		// Check if already within all limits (dimensions AND size)
+		const originalSize = inputBuffer.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,
+			};
+		}
 
-			// Calculate initial dimensions respecting max limits
-			let targetWidth = originalWidth;
-			let targetHeight = originalHeight;
+		// Calculate initial dimensions respecting max limits
+		let targetWidth = originalWidth;
+		let targetHeight = originalHeight;
 
-			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;
-			}
+		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;
+		}
 
-			// 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 resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+		// 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 resized = photon.resize(image!, width, height, photon.SamplingFilter.Lanczos3);
+
+			try {
+				const pngBuffer = resized.get_bytes();
+				const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
+
+				return pickSmaller(
+					{ buffer: pngBuffer, mimeType: "image/png" },
+					{ buffer: jpegBuffer, mimeType: "image/jpeg" },
+				);
+			} finally {
+				resized.free();
+			}
+		}
 
-				try {
-					const pngBuffer = resized.get_bytes();
-					const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
+		// 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];
 
-					return pickSmaller(
-						{ buffer: pngBuffer, mimeType: "image/png" },
-						{ buffer: jpegBuffer, mimeType: "image/jpeg" },
-					);
-				} finally {
-					resized.free();
-				}
-			}
+		let best: { buffer: Uint8Array; mimeType: string };
+		let finalWidth = targetWidth;
+		let finalHeight = targetHeight;
 
-			// 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];
+		// First attempt: resize to target dimensions, try both formats
+		best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
 
-			let best: { buffer: Uint8Array; mimeType: string };
-			let finalWidth = targetWidth;
-			let finalHeight = targetHeight;
+		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,
+			};
+		}
 
-			// First attempt: resize to target dimensions, try both formats
-			best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+		// 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 {
@@ -176,10 +147,19 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 					wasResized: true,
 				};
 			}
+		}
+
+		// 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;
+			}
 
-			// Still too large - try JPEG with decreasing quality
 			for (const quality of qualitySteps) {
-				best = tryBothFormats(targetWidth, targetHeight, quality);
+				best = tryBothFormats(finalWidth, finalHeight, quality);
 
 				if (best.buffer.length <= opts.maxBytes) {
 					return {
@@ -193,51 +173,33 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 					};
 				}
 			}
+		}
 
-			// 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,
-						};
-					}
-				}
-			}
-
-			// Last resort: return smallest version we produced
-			return {
-				data: Buffer.from(best.buffer).toString("base64"),
-				mimeType: best.mimeType,
-				originalWidth,
-				originalHeight,
-				width: finalWidth,
-				height: finalHeight,
-				wasResized: true,
-			};
-		} finally {
+		// Last resort: return smallest version we produced
+		return {
+			data: Buffer.from(best.buffer).toString("base64"),
+			mimeType: best.mimeType,
+			originalWidth,
+			originalHeight,
+			width: finalWidth,
+			height: finalHeight,
+			wasResized: true,
+		};
+	} catch {
+		// Failed to load image
+		return {
+			data: img.data,
+			mimeType: img.mimeType,
+			originalWidth: 0,
+			originalHeight: 0,
+			width: 0,
+			height: 0,
+			wasResized: false,
+		};
+	} finally {
+		if (image) {
 			image.free();
 		}
-	} catch (error) {
-		logger.error("Failed to resize image with Photon", {
-			error: error instanceof Error ? error.message : String(error),
-		});
-		return resizeImageWithImageMagick(img, opts);
 	}
 }
 

package/src/utils/image-magick.ts

@@ -1,247 +0,0 @@
-let imagemagickCommand: string | null | undefined;
-
-/**
- * Detect available ImageMagick command.
- * Returns "magick" (IM7) or "convert" (IM6) or null if unavailable.
- */
-async function detectImageMagick(): Promise<string | null> {
-	if (imagemagickCommand !== undefined) {
-		return imagemagickCommand;
-	}
-
-	for (const cmd of ["magick", "convert"]) {
-		try {
-			const proc = Bun.spawn([cmd, "-version"], { stdout: "ignore", stderr: "ignore" });
-			const code = await proc.exited;
-			if (code === 0) {
-				imagemagickCommand = cmd;
-				return cmd;
-			}
-		} catch {}
-	}
-
-	imagemagickCommand = null;
-	return null;
-}
-
-/**
- * Run ImageMagick command with buffer input/output.
- */
-async function runImageMagick(cmd: string, args: string[], input: Buffer): Promise<Buffer> {
-	const proc = Bun.spawn([cmd, ...args], {
-		stdin: new Blob([input]),
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(proc.stdout).arrayBuffer(),
-		new Response(proc.stderr).text(),
-		proc.exited,
-	]);
-
-	if (exitCode !== 0) {
-		throw new Error(`ImageMagick exited with code ${exitCode}: ${stderr}`);
-	}
-
-	return Buffer.from(stdout);
-}
-
-/**
- * Convert image to PNG using ImageMagick.
- * Returns null if ImageMagick is unavailable or conversion fails.
- */
-export async function convertToPngWithImageMagick(
-	base64Data: string,
-	_mimeType: string,
-): Promise<{ data: string; mimeType: string } | null> {
-	const cmd = await detectImageMagick();
-	if (!cmd) {
-		return null;
-	}
-
-	try {
-		const input = Buffer.from(base64Data, "base64");
-		// "-" reads from stdin, "png:-" writes PNG to stdout
-		const output = await runImageMagick(cmd, ["-", "png:-"], input);
-		return {
-			data: output.toString("base64"),
-			mimeType: "image/png",
-		};
-	} catch {
-		return null;
-	}
-}
-
-export interface ImageMagickResizeResult {
-	data: string; // base64
-	mimeType: string;
-	width: number;
-	height: number;
-}
-
-/**
- * Get image dimensions using ImageMagick identify.
- */
-async function getImageDimensions(cmd: string, buffer: Buffer): Promise<{ width: number; height: number } | null> {
-	try {
-		// Use identify to get dimensions
-		const identifyCmd = cmd === "magick" ? "magick" : "identify";
-		const args = cmd === "magick" ? ["identify", "-format", "%w %h", "-"] : ["-format", "%w %h", "-"];
-
-		const output = await runImageMagick(identifyCmd, args, buffer);
-		const [w, h] = output.toString().trim().split(" ").map(Number);
-		if (Number.isFinite(w) && Number.isFinite(h)) {
-			return { width: w, height: h };
-		}
-	} catch {
-		// Fall through
-	}
-	return null;
-}
-
-/**
- * Resize image using ImageMagick.
- * Returns null if ImageMagick is unavailable or operation fails.
- */
-export async function resizeWithImageMagick(
-	base64Data: string,
-	_mimeType: string,
-	maxWidth: number,
-	maxHeight: number,
-	maxBytes: number,
-	jpegQuality: number,
-): Promise<ImageMagickResizeResult | null> {
-	const cmd = await detectImageMagick();
-	if (!cmd) {
-		return null;
-	}
-
-	try {
-		const input = Buffer.from(base64Data, "base64");
-
-		// Get original dimensions
-		const dims = await getImageDimensions(cmd, input);
-		if (!dims) {
-			return null;
-		}
-
-		// Check if already within limits
-		if (dims.width <= maxWidth && dims.height <= maxHeight && input.length <= maxBytes) {
-			return null; // Signal caller to use original
-		}
-
-		// Calculate target dimensions maintaining aspect ratio
-		let targetWidth = dims.width;
-		let targetHeight = dims.height;
-
-		if (targetWidth > maxWidth) {
-			targetHeight = Math.round((targetHeight * maxWidth) / targetWidth);
-			targetWidth = maxWidth;
-		}
-		if (targetHeight > maxHeight) {
-			targetWidth = Math.round((targetWidth * maxHeight) / targetHeight);
-			targetHeight = maxHeight;
-		}
-
-		// Try PNG first, then JPEG with decreasing quality
-		const attempts: Array<{ args: string[]; mimeType: string }> = [
-			{ args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "png:-"], mimeType: "image/png" },
-			{
-				args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "-quality", String(jpegQuality), "jpeg:-"],
-				mimeType: "image/jpeg",
-			},
-		];
-
-		// Add lower quality JPEG attempts
-		for (const q of [70, 55, 40]) {
-			attempts.push({
-				args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "-quality", String(q), "jpeg:-"],
-				mimeType: "image/jpeg",
-			});
-		}
-
-		let best: { buffer: Buffer; mimeType: string } | null = null;
-
-		for (const attempt of attempts) {
-			try {
-				const output = await runImageMagick(cmd, attempt.args, input);
-				if (output.length <= maxBytes) {
-					return {
-						data: output.toString("base64"),
-						mimeType: attempt.mimeType,
-						width: targetWidth,
-						height: targetHeight,
-					};
-				}
-				if (!best || output.length < best.buffer.length) {
-					best = { buffer: output, mimeType: attempt.mimeType };
-				}
-			} catch {}
-		}
-
-		// Try progressively smaller dimensions
-		const scaleSteps = [0.75, 0.5, 0.35, 0.25];
-		for (const scale of scaleSteps) {
-			const scaledWidth = Math.round(targetWidth * scale);
-			const scaledHeight = Math.round(targetHeight * scale);
-
-			if (scaledWidth < 100 || scaledHeight < 100) break;
-
-			for (const q of [85, 70, 55, 40]) {
-				try {
-					const output = await runImageMagick(
-						cmd,
-						["-", "-resize", `${scaledWidth}x${scaledHeight}>`, "-quality", String(q), "jpeg:-"],
-						input,
-					);
-					if (output.length <= maxBytes) {
-						return {
-							data: output.toString("base64"),
-							mimeType: "image/jpeg",
-							width: scaledWidth,
-							height: scaledHeight,
-						};
-					}
-					if (!best || output.length < best.buffer.length) {
-						best = { buffer: output, mimeType: "image/jpeg" };
-					}
-				} catch {}
-			}
-		}
-
-		// Return best attempt even if over limit
-		if (best) {
-			return {
-				data: best.buffer.toString("base64"),
-				mimeType: best.mimeType,
-				width: targetWidth,
-				height: targetHeight,
-			};
-		}
-
-		return null;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Get image dimensions using ImageMagick.
- * Returns null if ImageMagick is unavailable.
- */
-export async function getImageDimensionsWithImageMagick(
-	base64Data: string,
-): Promise<{ width: number; height: number } | null> {
-	const cmd = await detectImageMagick();
-	if (!cmd) {
-		return null;
-	}
-
-	try {
-		const buffer = Buffer.from(base64Data, "base64");
-		return await getImageDimensions(cmd, buffer);
-	} catch {
-		return null;
-	}
-}

package/src/utils/photon.ts

@@ -1,25 +0,0 @@
-import type { base64_to_image, PhotonImage, resize as photonResize, SamplingFilter } from "@silvia-odwyer/photon";
-
-let _photon: typeof import("@silvia-odwyer/photon") | undefined;
-let _initialized = false;
-
-/**
- * Get the initialized Photon module.
- * Lazily imports and initializes the WASM module on first use.
- */
-export async function getPhoton(): Promise<typeof import("@silvia-odwyer/photon")> {
-	if (_photon && _initialized) return _photon;
-
-	const photon = await import("@silvia-odwyer/photon");
-
-	// Initialize the WASM module (default export is the init function)
-	if (!_initialized) {
-		await photon.default();
-		_initialized = true;
-	}
-
-	_photon = photon;
-	return _photon;
-}
-
-export type { PhotonImage, SamplingFilter, photonResize, base64_to_image };