#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
fix(disk): implement 500MB quota LRU eviction and memory deletion parity
Tanmay-0081d4fbce38f11
diff --git a/src/functions/auto-forget.ts b/src/functions/auto-forget.tsindex cbc92c52..72e7d8db 100644--- a/src/functions/auto-forget.ts+++ b/src/functions/auto-forget.ts@@ -29,7 +29,7 @@ export function registerAutoForgetFunction(sdk: ISdk, kv: StateKV): void {const ctx = getContext();const dryRun = data?.dryRun ?? false;const now = Date.now();- const { deleteImage } = await import("../utils/image-store.js");+ const { decrementImageRef } = await import("./image-refs.js");const result: AutoForgetResult = {ttlExpired: [],@@ -48,7 +48,7 @@ export function registerAutoForgetFunction(sdk: ISdk, kv: StateKV): void {deletedIds.add(mem.id);if (!dryRun) {if (mem.imageRef) {- deleteImage(mem.imageRef);+ await decrementImageRef(kv, sdk, mem.imageRef);}await kv.delete(KV.memories, mem.id);}@@ -153,8 +153,8 @@ export function registerAutoForgetFunction(sdk: ISdk, kv: StateKV): void {if (age > 180 * MS_PER_DAY && (obs.importance ?? 5) <= 2) {result.lowValueObs.push(obs.id);if (!dryRun) {- if (obs.imageData) deleteImage(obs.imageData);- if (obs.imageRef) deleteImage(obs.imageRef);+ if (obs.imageData) await decrementImageRef(kv, sdk, obs.imageData);+ if (obs.imageRef) await decrementImageRef(kv, sdk, obs.imageRef);await kv.delete(KV.observations(sessions[i].id), obs.id).catch(() => { });diff --git a/src/functions/disk-size-manager.ts b/src/functions/disk-size-manager.tsnew file mode 100644index 00000000..b4e8c300--- /dev/null+++ b/src/functions/disk-size-manager.ts@@ -0,0 +1,40 @@+import type { ISdk } from "iii-sdk";+import { getContext } from "iii-sdk";+import { KV } from "../state/schema.js";+import { StateKV } from "../state/kv.js";+import { getMaxBytes } from "../utils/image-store.js";++const DISK_SIZE_KEY = "system:currentDiskSize";++export function registerDiskSizeManager(sdk: ISdk, kv: StateKV): void {+ sdk.registerFunction(+ {+ id: "mem::disk-size-delta",+ description: "Sequential single-writer manager for disk size tracking",+ },+ async (data: { deltaBytes: number }) => {+ const ctx = getContext();++ if (typeof data?.deltaBytes !== "number" || !isFinite(data.deltaBytes)) {+ return { success: false, error: "deltaBytes must be a finite number" };+ }++ const currentTotal = (await kv.get<number>(KV.state, DISK_SIZE_KEY)) || 0;+ let newTotal = currentTotal + data.deltaBytes;++ if (newTotal < 0) newTotal = 0;++ await kv.set(KV.state, DISK_SIZE_KEY, newTotal);++ if (data.deltaBytes > 0 && newTotal > getMaxBytes()) {+ sdk.triggerVoid("mem::image-quota-cleanup", {});+ ctx.logger.info("[agentmemory] Disk quota exceeded, cleanup triggered", {+ currentBytes: newTotal,+ maxBytes: getMaxBytes(),+ });+ }++ return { success: true, currentTotal: newTotal };+ },+ );+}diff --git a/src/functions/evict.ts b/src/functions/evict.tsindex 9c7ea5f0..f5a1458e 100644--- a/src/functions/evict.ts+++ b/src/functions/evict.ts@@ -43,7 +43,7 @@ export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {async (data: { dryRun?: boolean }): Promise<EvictionStats> => {const ctx = getContext();const dryRun = data?.dryRun ?? false;- const { deleteImage } = await import("../utils/image-store.js");+ const { decrementImageRef } = await import("./image-refs.js");const configOverride = await kv.get<Partial<EvictionConfig>>(KV.config, "eviction")@@ -95,8 +95,8 @@ export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {) {stats.lowImportanceObs++;if (!dryRun) {- if (o.imageData) deleteImage(o.imageData);- if (o.imageRef) deleteImage(o.imageRef);+ if (o.imageData) await decrementImageRef(kv, sdk, o.imageData);+ if (o.imageRef) await decrementImageRef(kv, sdk, o.imageRef);await kv.delete(KV.observations(session.id), o.id).catch(() => {});@@ -122,8 +122,8 @@ export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {stats.capEvictions += toEvict.length;if (!dryRun) {for (const o of toEvict) {- if (o.imageData) deleteImage(o.imageData);- if (o.imageRef) deleteImage(o.imageRef);+ if (o.imageData) await decrementImageRef(kv, sdk, o.imageData);+ if (o.imageRef) await decrementImageRef(kv, sdk, o.imageRef);await kv.delete(KV.observations(o.sessionId), o.id).catch(() => {});@@ -142,7 +142,7 @@ export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {evictedMemIds.add(mem.id);if (!dryRun) {if (mem.imageRef) {- deleteImage(mem.imageRef);+ await decrementImageRef(kv, sdk, mem.imageRef);}await kv.delete(KV.memories, mem.id).catch(() => {});}@@ -159,7 +159,7 @@ export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {stats.nonLatestMemories++;if (!dryRun) {if (mem.imageRef) {- deleteImage(mem.imageRef);+ await decrementImageRef(kv, sdk, mem.imageRef);}await kv.delete(KV.memories, mem.id).catch(() => {});}diff --git a/src/functions/image-quota-cleanup.ts b/src/functions/image-quota-cleanup.tsnew file mode 100644index 00000000..2c1ead5d--- /dev/null+++ b/src/functions/image-quota-cleanup.ts@@ -0,0 +1,105 @@+import type { ISdk } from "iii-sdk";+import { getContext } from "iii-sdk";+import { KV } from "../state/schema.js";+import { StateKV } from "../state/kv.js";+import { readdir, stat } from "node:fs/promises";+import { join } from "node:path";+import { IMAGES_DIR, getMaxBytes, deleteImage } from "../utils/image-store.js";+import { getImageRefCount } from "./image-refs.js";++const LOCK_KEY = "system:cleanupLockTimestamp";+const LOCK_TTL_MS = 60_000;+const HEARTBEAT_INTERVAL_MS = 30_000;+const GRACE_PERIOD_MS = 30_000;++export function registerImageQuotaCleanup(sdk: ISdk, kv: StateKV): void {+ sdk.registerFunction(+ {+ id: "mem::image-quota-cleanup",+ description: "Background LRU cleanup of image store when disk quota is exceeded",+ },+ async () => {+ const ctx = getContext();+ const now = Date.now();++ const lockTime = await kv.get<number>(KV.state, LOCK_KEY);+ if (lockTime && (now - lockTime) < LOCK_TTL_MS) {+ return { success: true, skipped: true, reason: "locked" };+ }+ await kv.set(KV.state, LOCK_KEY, now);++ try {+ let totalSize = 0;+ const fileStats: Array<{ filePath: string; size: number; mtimeMs: number }> = [];++ try {+ const files = await readdir(IMAGES_DIR);+ for (const file of files) {+ if (file.startsWith(".")) continue;+ const filePath = join(IMAGES_DIR, file);+ const s = await stat(filePath);+ if (s.isFile()) {+ fileStats.push({ filePath, size: s.size, mtimeMs: s.mtimeMs });+ totalSize += s.size;+ }+ }+ } catch {+ return { success: true, evicted: 0, freedBytes: 0 };+ }++ const limit = getMaxBytes();+ if (totalSize <= limit) {+ return { success: true, evicted: 0, freedBytes: 0, underQuota: true };+ }++ fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);++ let totalToFree = totalSize - limit;+ let evicted = 0;+ let freedBytes = 0;+ let lastHeartbeat = Date.now();++ for (const f of fileStats) {+ if (totalToFree <= 0) break;++ if (now - f.mtimeMs < GRACE_PERIOD_MS) {+ continue;+ }++ let refCount = 0;+ try {+ refCount = await getImageRefCount(kv, f.filePath);+ } catch (err) {+ ctx.logger.error(`[agentmemory] Failed to read refCount for ${f.filePath}:`, err);+ }++ if (refCount > 0) {+ continue;+ }++ const { deletedBytes } = await deleteImage(f.filePath);+ if (deletedBytes > 0) {+ sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });+ totalToFree -= deletedBytes;+ freedBytes += deletedBytes;+ evicted++;+ }++ if (Date.now() - lastHeartbeat > HEARTBEAT_INTERVAL_MS) {+ await kv.set(KV.state, LOCK_KEY, Date.now());+ lastHeartbeat = Date.now();+ }+ }++ if (evicted > 0) {+ const freedMb = (freedBytes / (1024 * 1024)).toFixed(1);+ ctx.logger.info("[agentmemory] Image quota cleanup complete", { evicted, freedMb });+ }++ return { success: true, evicted, freedBytes };+ } finally {+ await kv.delete(KV.state, LOCK_KEY);+ }+ },+ );+}diff --git a/src/functions/image-refs.ts b/src/functions/image-refs.tsnew file mode 100644index 00000000..fb15e279--- /dev/null+++ b/src/functions/image-refs.ts@@ -0,0 +1,28 @@+import type { ISdk } from "iii-sdk";+import { KV } from "../state/schema.js";+import { StateKV } from "../state/kv.js";+import { deleteImage, touchImage } from "../utils/image-store.js";++export async function getImageRefCount(kv: StateKV, filePath: string): Promise<number> {+ const count = await kv.get<number>(KV.imageRefs, filePath);+ return count ? Number(count) : 0;+}++export async function incrementImageRef(kv: StateKV, filePath: string): Promise<void> {+ const current = await getImageRefCount(kv, filePath);+ await kv.set(KV.imageRefs, filePath, current + 1);+ await touchImage(filePath);+}++export async function decrementImageRef(kv: StateKV, sdk: ISdk, filePath: string): Promise<void> {+ const current = await getImageRefCount(kv, filePath);+ if (current <= 1) {+ await kv.delete(KV.imageRefs, filePath);+ const { deletedBytes } = await deleteImage(filePath);+ if (deletedBytes > 0) {+ sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });+ }+ } else {+ await kv.set(KV.imageRefs, filePath, current - 1);+ }+}diff --git a/src/functions/observe.ts b/src/functions/observe.tsindex 3c66c696..261bca0f 100644--- a/src/functions/observe.ts+++ b/src/functions/observe.ts@@ -137,7 +137,11 @@ export function registerObserveFunction(if (pendingImageData && (pendingImageData.startsWith("data:image/") || pendingImageData.startsWith("iVBORw0KGgo") || pendingImageData.startsWith("/9j/"))) {const { saveImageToDisk } = await import("../utils/image-store.js");- raw.imageData = saveImageToDisk(pendingImageData);+ const { filePath, bytesWritten } = await saveImageToDisk(pendingImageData);+ raw.imageData = filePath;+ const { incrementImageRef } = await import("./image-refs.js");+ await incrementImageRef(kv, filePath);+ sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: bytesWritten });}try {@@ -147,7 +151,10 @@ export function registerObserveFunction(} catch (error) {if (raw.imageData) {const { deleteImage } = await import("../utils/image-store.js");- deleteImage(raw.imageData);+ const { deletedBytes } = await deleteImage(raw.imageData);+ if (deletedBytes > 0) {+ sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });+ }}throw error;}diff --git a/src/functions/retention.ts b/src/functions/retention.tsindex 154b393d..e031f260 100644--- a/src/functions/retention.ts+++ b/src/functions/retention.ts@@ -194,7 +194,7 @@ export function registerRetentionFunctions(const ctx = getContext();const threshold = data.threshold ?? DEFAULT_DECAY.tierThresholds.cold;const maxEvict = data.maxEvict ?? 50;- const { deleteImage } = await import("../utils/image-store.js");+ const { decrementImageRef } = await import("./image-refs.js");const allScores = await kv.list<RetentionScore>(KV.retentionScores);const candidates = allScores@@ -219,7 +219,7 @@ export function registerRetentionFunctions(try {const mem = await kv.get<Memory>(KV.memories, candidate.memoryId);if (mem && mem.imageRef) {- deleteImage(mem.imageRef);+ await decrementImageRef(kv, sdk, mem.imageRef);}await kv.delete(KV.memories, candidate.memoryId);await kv.delete(KV.retentionScores, candidate.memoryId);diff --git a/src/index.ts b/src/index.tsindex 3b83f884..da393d4b 100644--- a/src/index.ts+++ b/src/index.ts@@ -21,6 +21,8 @@ import { HybridSearch } from "./state/hybrid-search.js";import { IndexPersistence } from "./state/index-persistence.js";import { registerPrivacyFunction } from "./functions/privacy.js";import { registerObserveFunction } from "./functions/observe.js";+import { registerImageQuotaCleanup } from "./functions/image-quota-cleanup.js";+import { registerDiskSizeManager } from "./functions/disk-size-manager.js";import { registerCompressFunction } from "./functions/compress.js";import {registerSearchFunction,@@ -134,6 +136,8 @@ async function main() {registerPrivacyFunction(sdk);registerObserveFunction(sdk, kv, dedupMap, config.maxObservationsPerSession);+ registerImageQuotaCleanup(sdk, kv);+ registerDiskSizeManager(sdk, kv);registerCompressFunction(sdk, kv, provider, metricsStore);registerSearchFunction(sdk, kv);registerContextFunction(sdk, kv, config.tokenBudget);diff --git a/src/state/schema.ts b/src/state/schema.tsindex 3571e010..1781ac78 100644--- a/src/state/schema.ts+++ b/src/state/schema.ts@@ -40,6 +40,8 @@ export const KV = {enrichedChunks: (sessionId: string) => `mem:enriched:${sessionId}`,latentEmbeddings: (obsId: string) => `mem:latent:${obsId}`,retentionScores: "mem:retention",+ imageRefs: "mem:image-refs",+ state: "mem:state",} as const;export const STREAM = {diff --git a/src/utils/image-store.ts b/src/utils/image-store.tsindex 65085694..05469484 100644--- a/src/utils/image-store.ts+++ b/src/utils/image-store.ts@@ -1,10 +1,17 @@import { homedir } from "node:os";import { join, resolve } from "node:path";-import { writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";+import { existsSync } from "node:fs";+import { mkdir, writeFile, unlink, utimes, stat } from "node:fs/promises";import { createHash } from "node:crypto";export const IMAGES_DIR = join(homedir(), ".agentmemory", "images");+const DEFAULT_MAX_BYTES = 500 * 1024 * 1024;++export function getMaxBytes(): number {+ return Number(process.env.AGENTMEMORY_IMAGE_STORE_MAX_BYTES) || DEFAULT_MAX_BYTES;+}+export function isManagedImagePath(filePath: string): boolean {const resolved = resolve(filePath);return resolved.startsWith(IMAGES_DIR + "/") || resolved === IMAGES_DIR;@@ -14,13 +21,16 @@ function contentHash(data: string): string {return createHash("sha256").update(data).digest("hex");}-export function saveImageToDisk(base64Data: string): string {- if (!base64Data) return "";- mkdirSync(IMAGES_DIR, { recursive: true });-+export async function saveImageToDisk(base64Data: string): Promise<{ filePath: string; bytesWritten: number }> {+ if (!base64Data) return { filePath: "", bytesWritten: 0 };++ if (!existsSync(IMAGES_DIR)) {+ await mkdir(IMAGES_DIR, { recursive: true });+ }+let cleanBase64 = base64Data;let ext = "png";-+if (base64Data.startsWith("data:image/")) {const commaIdx = base64Data.indexOf(",");if (commaIdx !== -1) {@@ -36,19 +46,40 @@ export function saveImageToDisk(base64Data: string): string {const hash = contentHash(cleanBase64);const filePath = join(IMAGES_DIR, `${hash}.${ext}`);-- writeFileSync(filePath, Buffer.from(cleanBase64, "base64"));- return filePath;++ const buffer = Buffer.from(cleanBase64, "base64");+ await writeFile(filePath, buffer);++ const s = await stat(filePath);++ return { filePath, bytesWritten: s.size };}-export function deleteImage(filePath: string | undefined): void {- if (!filePath) return;- if (!isManagedImagePath(filePath)) return;+export async function deleteImage(filePath: string | undefined): Promise<{ deletedBytes: number }> {+ if (!filePath) return { deletedBytes: 0 };+ if (!isManagedImagePath(filePath)) return { deletedBytes: 0 };try {if (existsSync(filePath)) {- unlinkSync(filePath);+ const s = await stat(filePath);+ const size = s.size;+ await unlink(filePath);+ return { deletedBytes: size };}} catch (err) {console.error("[agentmemory] Failed to delete image context:", err);}+ return { deletedBytes: 0 };+}++/** Touch an image file to update its mtime (marking it as recently used for LRU eviction) */+export async function touchImage(filePath: string): Promise<void> {+ if (!filePath || !isManagedImagePath(filePath)) return;+ try {+ if (existsSync(filePath)) {+ const now = new Date();+ await utimes(filePath, now, now);+ }+ } catch (err) {+ // Ignore touch errors silently+ }}diff --git a/test/multimodal.test.ts b/test/multimodal.test.tsindex 653b9668..38f0b452 100644--- a/test/multimodal.test.ts+++ b/test/multimodal.test.ts@@ -1,4 +1,4 @@-import { describe, it, expect, vi, afterAll } from "vitest";+import { describe, it, expect, vi, afterAll, beforeEach } from "vitest";import { existsSync, rmSync } from "node:fs";vi.mock("iii-sdk", () => ({@@ -27,6 +27,9 @@ function mockKV() {store.get(scope)!.set(key, data);return data;},+ delete: async (scope: string, key: string): Promise<void> => {+ store.get(scope)?.delete(key);+ },list: async <T>(scope: string): Promise<T[]> => {if (!store.has(scope)) return [];return Array.from(store.get(scope)!.values()) as T[];@@ -60,6 +63,10 @@ describe("End-to-End Multimodal Flow", () => {}});+ beforeEach(() => {+ mockTriggerVoid.mockClear();+ });+it("Step 1: Agent image should be successfully saved to hard drive", async () => {let observeCallback: any = null;const sdkMocker = { ...mockSdk, registerFunction: vi.fn((config, cb) => { if (config.id === "mem::observe") observeCallback = cb; }) };@@ -91,6 +98,12 @@ describe("End-to-End Multimodal Flow", () => {expect(existsSync(raw.imageData!)).toBe(true);savedImagePath = raw.imageData;++ const deltaCalls = mockTriggerVoid.mock.calls.filter(+ (c: any[]) => c[0] === "mem::disk-size-delta"+ );+ expect(deltaCalls.length).toBe(1);+ expect(deltaCalls[0][1].deltaBytes).toBeGreaterThan(0);});it("Step 2 & 3: mem::compress should call the vision model and store compressed observation in KV", async () => {@@ -139,9 +152,176 @@ describe("End-to-End Multimodal Flow", () => {expect(compressed.title).toBe("Screenshot of Red Dot");expect(compressed.narrative).toContain("red dot");- const stored = await kv.get<CompressedObservation>("mem:obs:test-session", raw.id!);+ const stored = await kv.get("mem:obs:test-session", raw.id!) as CompressedObservation | null;expect(stored).not.toBeNull();expect(stored!.imageDescription).toBe("TEST_VISION_RESULT: I see a red dot");expect(stored!.imageRef).toBe(savedImagePath);});});++describe("Disk Size Manager", () => {+ it("should increment disk size and trigger cleanup when over quota", async () => {+ const localKv = mockKV() as any;+ const localTriggerVoid = vi.fn();+ const localSdk = { triggerVoid: localTriggerVoid } as any;++ let managerCallback: any = null;+ const sdkMocker = {+ ...localSdk,+ registerFunction: vi.fn((config: any, cb: any) => {+ if (config.id === "mem::disk-size-delta") managerCallback = cb;+ }),+ };++ const { registerDiskSizeManager } = await import("../src/functions/disk-size-manager.js");+ registerDiskSizeManager(sdkMocker, localKv);++ expect(managerCallback).not.toBeNull();++ const res1 = await managerCallback({ deltaBytes: 1000 });+ expect(res1.success).toBe(true);+ expect(res1.currentTotal).toBe(1000);++ const res2 = await managerCallback({ deltaBytes: 2000 });+ expect(res2.success).toBe(true);+ expect(res2.currentTotal).toBe(3000);++ expect(localTriggerVoid).not.toHaveBeenCalled();+ });++ it("should trigger cleanup when total exceeds max bytes", async () => {+ const originalEnv = process.env.AGENTMEMORY_IMAGE_STORE_MAX_BYTES;+ process.env.AGENTMEMORY_IMAGE_STORE_MAX_BYTES = "5000";++ const localKv = mockKV() as any;+ const localTriggerVoid = vi.fn();+ const localSdk = { triggerVoid: localTriggerVoid } as any;++ let managerCallback: any = null;+ const sdkMocker = {+ ...localSdk,+ registerFunction: vi.fn((config: any, cb: any) => {+ if (config.id === "mem::disk-size-delta") managerCallback = cb;+ }),+ };++ const { registerDiskSizeManager } = await import("../src/functions/disk-size-manager.js");+ registerDiskSizeManager(sdkMocker, localKv);++ await managerCallback({ deltaBytes: 3000 });+ expect(localTriggerVoid).not.toHaveBeenCalled();++ await managerCallback({ deltaBytes: 3000 });+ expect(localTriggerVoid).toHaveBeenCalledWith("mem::image-quota-cleanup", {});++ process.env.AGENTMEMORY_IMAGE_STORE_MAX_BYTES = originalEnv || "";+ });++ it("should clamp negative totals to zero", async () => {+ const localKv = mockKV() as any;+ const localSdk = { triggerVoid: vi.fn() } as any;++ let managerCallback: any = null;+ const sdkMocker = {+ ...localSdk,+ registerFunction: vi.fn((config: any, cb: any) => {+ if (config.id === "mem::disk-size-delta") managerCallback = cb;+ }),+ };++ const { registerDiskSizeManager } = await import("../src/functions/disk-size-manager.js");+ registerDiskSizeManager(sdkMocker, localKv);++ const res = await managerCallback({ deltaBytes: -99999 });+ expect(res.currentTotal).toBe(0);+ });++ it("should reject invalid deltaBytes", async () => {+ const localKv = mockKV() as any;+ const localSdk = { triggerVoid: vi.fn() } as any;++ let managerCallback: any = null;+ const sdkMocker = {+ ...localSdk,+ registerFunction: vi.fn((config: any, cb: any) => {+ if (config.id === "mem::disk-size-delta") managerCallback = cb;+ }),+ };++ const { registerDiskSizeManager } = await import("../src/functions/disk-size-manager.js");+ registerDiskSizeManager(sdkMocker, localKv);++ const res = await managerCallback({ deltaBytes: "not-a-number" });+ expect(res.success).toBe(false);+ });+});++describe("Image Refs", () => {+ it("should increment and decrement ref counts correctly", async () => {+ const localKv = mockKV() as any;+ const localTriggerVoid = vi.fn();+ const localSdk = { triggerVoid: localTriggerVoid } as any;++ const { incrementImageRef, decrementImageRef, getImageRefCount } = await import("../src/functions/image-refs.js");++ await incrementImageRef(localKv, "/fake/path/test.png");+ expect(await getImageRefCount(localKv, "/fake/path/test.png")).toBe(1);++ await incrementImageRef(localKv, "/fake/path/test.png");+ expect(await getImageRefCount(localKv, "/fake/path/test.png")).toBe(2);++ await decrementImageRef(localKv, localSdk, "/fake/path/test.png");+ expect(await getImageRefCount(localKv, "/fake/path/test.png")).toBe(1);+ });+});++describe("Image Store", () => {+ let testFilePath: string | undefined;++ afterAll(() => {+ if (testFilePath && existsSync(testFilePath)) {+ rmSync(testFilePath);+ }+ });++ it("saveImageToDisk should return filePath and bytesWritten", async () => {+ const { saveImageToDisk } = await import("../src/utils/image-store.js");+ const result = await saveImageToDisk(+ "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z/C/HgAGgwJ/lK3Q6wAAAABJRU5ErkJggg=="+ );++ expect(result.filePath).toBeDefined();+ expect(typeof result.filePath).toBe("string");+ expect(result.filePath.length).toBeGreaterThan(0);+ expect(result.bytesWritten).toBeGreaterThan(0);+ expect(existsSync(result.filePath)).toBe(true);++ testFilePath = result.filePath;+ });++ it("deleteImage should return deletedBytes after successful deletion", async () => {+ const { deleteImage } = await import("../src/utils/image-store.js");++ expect(testFilePath).toBeDefined();+ expect(existsSync(testFilePath!)).toBe(true);++ const result = await deleteImage(testFilePath);+ expect(result.deletedBytes).toBeGreaterThan(0);+ expect(existsSync(testFilePath!)).toBe(false);++ testFilePath = undefined;+ });++ it("deleteImage should return 0 for non-existent files", async () => {+ const { deleteImage } = await import("../src/utils/image-store.js");+ const result = await deleteImage("/non/existent/file.png");+ expect(result.deletedBytes).toBe(0);+ });++ it("saveImageToDisk should return empty for empty input", async () => {+ const { saveImageToDisk } = await import("../src/utils/image-store.js");+ const result = await saveImageToDisk("");+ expect(result.filePath).toBe("");+ expect(result.bytesWritten).toBe(0);+ });+});