Skip to content

#1 Persistent memory for AI coding agents based on real-world benchmarks

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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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);
+ });
+});