promptfoo 0.120.27 → 0.121.1

package/dist/src/{blobs-BM_e6hCa.js → blobs-BAU-dXan.js}

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
-import { o as logger_default, v as getConfigDirectoryPath } from "./logger-LSBxlt7a.js";
-import { g as getDb, n as blobReferencesTable, t as blobAssetsTable } from "./tables-DMegD0Xf.js";
+import { o as logger, v as getConfigDirectoryPath } from "./logger-KkObSCzq.js";
+import { g as getDb, n as blobReferencesTable, t as blobAssetsTable } from "./tables-D36WTqKX.js";
 import * as fs$1 from "node:fs";
 import * as path$1 from "node:path";
 import * as fsPromises$1 from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { and, eq } from "drizzle-orm";
-
 //#region src/blobs/constants.ts
 const BLOB_MIN_SIZE = 1024;
 const BLOB_MAX_SIZE = 52428800;
 const BLOB_SCHEME = "promptfoo://blob/";
 const DEFAULT_FILESYSTEM_SUBDIR = "blobs";
-
 //#endregion
 //#region src/blobs/filesystemProvider.ts
 const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
@@ -33,7 +31,7 @@ var FilesystemBlobStorageProvider = class {
 	ensureDirectory() {
 		if (!fs$1.existsSync(this.basePath)) {
 			fs$1.mkdirSync(this.basePath, { recursive: true });
-			logger_default.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
+			logger.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
 		}
 	}
 	assertValidHash(hash) {
@@ -152,12 +150,11 @@ var FilesystemBlobStorageProvider = class {
 			return JSON.parse(raw);
 		} catch (error) {
 			if (error.code === "ENOENT") return null;
-			logger_default.warn("[BlobFS] Failed to read metadata", { error });
+			logger.warn("[BlobFS] Failed to read metadata", { error });
 			return null;
 		}
 	}
 };
-
 //#endregion
 //#region src/blobs/index.ts
 let defaultProvider = null;
@@ -167,7 +164,7 @@ function createDefaultProvider() {
 function getBlobStorageProvider() {
 	if (!defaultProvider) {
 		defaultProvider = createDefaultProvider();
-		logger_default.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
+		logger.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
 	}
 	return defaultProvider;
 }
@@ -197,7 +194,7 @@ async function storeBlob(data, mimeType, refContext) {
 		try {
 			await provider.deleteByHash(result.ref.hash);
 		} catch (cleanupError) {
-			logger_default.warn("[BlobStorage] Failed to rollback blob after DB error", {
+			logger.warn("[BlobStorage] Failed to rollback blob after DB error", {
 				error: cleanupError,
 				hash: result.ref.hash
 			});
@@ -215,7 +212,7 @@ async function getBlobUrl(hash, expiresInSeconds) {
 async function recordBlobReference(hash, refContext) {
 	if (!refContext.evalId) return;
 	if (!await getBlobStorageProvider().exists(hash).catch(() => false)) {
-		logger_default.debug("[BlobStorage] Attempted to record reference for missing blob", {
+		logger.debug("[BlobStorage] Attempted to record reference for missing blob", {
 			hash,
 			evalId: refContext.evalId,
 			location: refContext.location
@@ -234,7 +231,7 @@ async function recordBlobReference(hash, refContext) {
 		kind: refContext.kind
 	}).run();
 }
-
 //#endregion
 export { BLOB_MAX_SIZE as a, storeBlob as i, getBlobUrl as n, BLOB_MIN_SIZE as o, recordBlobReference as r, getBlobByHash as t };
-//# sourceMappingURL=blobs-BM_e6hCa.js.map
+
+//# sourceMappingURL=blobs-BAU-dXan.js.map

package/dist/src/{blobs-CR5C4Ihh.js → blobs-Bpg5rH6i.js}

@@ -1,17 +1,15 @@
-import { g as getConfigDirectoryPath, i as logger_default } from "./logger-CG1uZPbQ.js";
-import { n as blobReferencesTable, p as getDb, t as blobAssetsTable } from "./tables-DfTsNN7X.js";
+import { g as getConfigDirectoryPath, i as logger } from "./logger-CT3IKMKA.js";
+import { n as blobReferencesTable, p as getDb, t as blobAssetsTable } from "./tables-5EvT_Bwn.js";
 import * as path$1 from "node:path";
 import * as fs$1 from "node:fs";
 import * as fsPromises$1 from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { and, eq } from "drizzle-orm";
-
 //#region src/blobs/constants.ts
 const BLOB_MIN_SIZE = 1024;
 const BLOB_MAX_SIZE = 52428800;
 const BLOB_SCHEME = "promptfoo://blob/";
 const DEFAULT_FILESYSTEM_SUBDIR = "blobs";
-
 //#endregion
 //#region src/blobs/filesystemProvider.ts
 const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
@@ -32,7 +30,7 @@ var FilesystemBlobStorageProvider = class {
 	ensureDirectory() {
 		if (!fs$1.existsSync(this.basePath)) {
 			fs$1.mkdirSync(this.basePath, { recursive: true });
-			logger_default.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
+			logger.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
 		}
 	}
 	assertValidHash(hash) {
@@ -151,12 +149,11 @@ var FilesystemBlobStorageProvider = class {
 			return JSON.parse(raw);
 		} catch (error) {
 			if (error.code === "ENOENT") return null;
-			logger_default.warn("[BlobFS] Failed to read metadata", { error });
+			logger.warn("[BlobFS] Failed to read metadata", { error });
 			return null;
 		}
 	}
 };
-
 //#endregion
 //#region src/blobs/index.ts
 let defaultProvider = null;
@@ -166,7 +163,7 @@ function createDefaultProvider() {
 function getBlobStorageProvider() {
 	if (!defaultProvider) {
 		defaultProvider = createDefaultProvider();
-		logger_default.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
+		logger.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
 	}
 	return defaultProvider;
 }
@@ -196,7 +193,7 @@ async function storeBlob(data, mimeType, refContext) {
 		try {
 			await provider.deleteByHash(result.ref.hash);
 		} catch (cleanupError) {
-			logger_default.warn("[BlobStorage] Failed to rollback blob after DB error", {
+			logger.warn("[BlobStorage] Failed to rollback blob after DB error", {
 				error: cleanupError,
 				hash: result.ref.hash
 			});
@@ -211,7 +208,7 @@ async function getBlobByHash(hash) {
 async function recordBlobReference(hash, refContext) {
 	if (!refContext.evalId) return;
 	if (!await getBlobStorageProvider().exists(hash).catch(() => false)) {
-		logger_default.debug("[BlobStorage] Attempted to record reference for missing blob", {
+		logger.debug("[BlobStorage] Attempted to record reference for missing blob", {
 			hash,
 			evalId: refContext.evalId,
 			location: refContext.location
@@ -230,7 +227,7 @@ async function recordBlobReference(hash, refContext) {
 		kind: refContext.kind
 	}).run();
 }
-
 //#endregion
 export { BLOB_MIN_SIZE as a, BLOB_MAX_SIZE as i, recordBlobReference as n, storeBlob as r, getBlobByHash as t };
-//# sourceMappingURL=blobs-CR5C4Ihh.js.map
+
+//# sourceMappingURL=blobs-Bpg5rH6i.js.map

package/dist/src/{blobs-B-KQAFhX.cjs → blobs-DvS-O6be.cjs}

@@ -1,5 +1,5 @@
-const require_logger = require('./logger-B7sBeGa0.cjs');
-const require_tables = require('./tables-BKTmd6u7.cjs');
+const require_logger = require("./logger-Cp1GPUjj.cjs");
+const require_tables = require("./tables-C7K-XKWp.cjs");
 let node_fs = require("node:fs");
 node_fs = require_logger.__toESM(node_fs);
 let node_fs_promises = require("node:fs/promises");
@@ -8,13 +8,11 @@ let node_path = require("node:path");
 node_path = require_logger.__toESM(node_path);
 let node_crypto = require("node:crypto");
 let drizzle_orm = require("drizzle-orm");
-
 //#region src/blobs/constants.ts
 const BLOB_MIN_SIZE = 1024;
 const BLOB_MAX_SIZE = 52428800;
 const BLOB_SCHEME = "promptfoo://blob/";
 const DEFAULT_FILESYSTEM_SUBDIR = "blobs";
-
 //#endregion
 //#region src/blobs/filesystemProvider.ts
 const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
@@ -35,7 +33,7 @@ var FilesystemBlobStorageProvider = class {
 	ensureDirectory() {
 		if (!node_fs.existsSync(this.basePath)) {
 			node_fs.mkdirSync(this.basePath, { recursive: true });
-			require_logger.logger_default.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
+			require_logger.logger.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
 		}
 	}
 	assertValidHash(hash) {
@@ -154,12 +152,11 @@ var FilesystemBlobStorageProvider = class {
 			return JSON.parse(raw);
 		} catch (error) {
 			if (error.code === "ENOENT") return null;
-			require_logger.logger_default.warn("[BlobFS] Failed to read metadata", { error });
+			require_logger.logger.warn("[BlobFS] Failed to read metadata", { error });
 			return null;
 		}
 	}
 };
-
 //#endregion
 //#region src/blobs/index.ts
 let defaultProvider = null;
@@ -169,7 +166,7 @@ function createDefaultProvider() {
 function getBlobStorageProvider() {
 	if (!defaultProvider) {
 		defaultProvider = createDefaultProvider();
-		require_logger.logger_default.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
+		require_logger.logger.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
 	}
 	return defaultProvider;
 }
@@ -199,7 +196,7 @@ async function storeBlob(data, mimeType, refContext) {
 		try {
 			await provider.deleteByHash(result.ref.hash);
 		} catch (cleanupError) {
-			require_logger.logger_default.warn("[BlobStorage] Failed to rollback blob after DB error", {
+			require_logger.logger.warn("[BlobStorage] Failed to rollback blob after DB error", {
 				error: cleanupError,
 				hash: result.ref.hash
 			});
@@ -214,7 +211,7 @@ async function getBlobByHash(hash) {
 async function recordBlobReference(hash, refContext) {
 	if (!refContext.evalId) return;
 	if (!await getBlobStorageProvider().exists(hash).catch(() => false)) {
-		require_logger.logger_default.debug("[BlobStorage] Attempted to record reference for missing blob", {
+		require_logger.logger.debug("[BlobStorage] Attempted to record reference for missing blob", {
 			hash,
 			evalId: refContext.evalId,
 			location: refContext.location
@@ -233,36 +230,36 @@ async function recordBlobReference(hash, refContext) {
 		kind: refContext.kind
 	}).run();
 }
-
 //#endregion
-Object.defineProperty(exports, 'BLOB_MAX_SIZE', {
-  enumerable: true,
-  get: function () {
-    return BLOB_MAX_SIZE;
-  }
+Object.defineProperty(exports, "BLOB_MAX_SIZE", {
+	enumerable: true,
+	get: function() {
+		return BLOB_MAX_SIZE;
+	}
 });
-Object.defineProperty(exports, 'BLOB_MIN_SIZE', {
-  enumerable: true,
-  get: function () {
-    return BLOB_MIN_SIZE;
-  }
+Object.defineProperty(exports, "BLOB_MIN_SIZE", {
+	enumerable: true,
+	get: function() {
+		return BLOB_MIN_SIZE;
+	}
 });
-Object.defineProperty(exports, 'getBlobByHash', {
-  enumerable: true,
-  get: function () {
-    return getBlobByHash;
-  }
+Object.defineProperty(exports, "getBlobByHash", {
+	enumerable: true,
+	get: function() {
+		return getBlobByHash;
+	}
 });
-Object.defineProperty(exports, 'recordBlobReference', {
-  enumerable: true,
-  get: function () {
-    return recordBlobReference;
-  }
+Object.defineProperty(exports, "recordBlobReference", {
+	enumerable: true,
+	get: function() {
+		return recordBlobReference;
+	}
 });
-Object.defineProperty(exports, 'storeBlob', {
-  enumerable: true,
-  get: function () {
-    return storeBlob;
-  }
+Object.defineProperty(exports, "storeBlob", {
+	enumerable: true,
+	get: function() {
+		return storeBlob;
+	}
 });
-//# sourceMappingURL=blobs-B-KQAFhX.cjs.map
+
+//# sourceMappingURL=blobs-DvS-O6be.cjs.map

package/dist/src/blobs-qTYm-1PY.js

@@ -0,0 +1,236 @@
+import { g as getConfigDirectoryPath, i as logger } from "./logger-DLcq4dWf.js";
+import { h as getDb, n as blobReferencesTable, t as blobAssetsTable } from "./tables-xKANLRBD.js";
+import * as fs$1 from "node:fs";
+import * as path$1 from "node:path";
+import * as fsPromises$1 from "node:fs/promises";
+import { and, eq } from "drizzle-orm";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/blobs/constants.ts
+const BLOB_MIN_SIZE = 1024;
+const BLOB_MAX_SIZE = 52428800;
+const BLOB_SCHEME = "promptfoo://blob/";
+const DEFAULT_FILESYSTEM_SUBDIR = "blobs";
+//#endregion
+//#region src/blobs/filesystemProvider.ts
+const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
+function computeHash(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+function buildUri(hash) {
+	return `${BLOB_SCHEME}${hash}`;
+}
+var FilesystemBlobStorageProvider = class {
+	providerId = "filesystem";
+	basePath;
+	constructor(config) {
+		const defaultBase = path$1.join(getConfigDirectoryPath(true), DEFAULT_FILESYSTEM_SUBDIR);
+		this.basePath = path$1.resolve(config?.basePath || defaultBase);
+		this.ensureDirectory();
+	}
+	ensureDirectory() {
+		if (!fs$1.existsSync(this.basePath)) {
+			fs$1.mkdirSync(this.basePath, { recursive: true });
+			logger.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
+		}
+	}
+	assertValidHash(hash) {
+		if (!BLOB_HASH_REGEX.test(hash)) throw new Error(`[BlobFS] Invalid blob hash: "${hash}"`);
+	}
+	resolvePathInBase(unsafePath) {
+		const targetPath = path$1.isAbsolute(unsafePath) ? path$1.resolve(unsafePath) : path$1.resolve(this.basePath, unsafePath);
+		const safeBase = path$1.resolve(this.basePath) + path$1.sep;
+		if (!targetPath.startsWith(safeBase)) throw new Error("[BlobFS] Path traversal attempt detected");
+		return targetPath;
+	}
+	hashToPath(hash) {
+		this.assertValidHash(hash);
+		const dirRelative = path$1.join(hash.slice(0, 2), hash.slice(2, 4));
+		const fileRelative = path$1.join(dirRelative, hash);
+		return this.resolvePathInBase(fileRelative);
+	}
+	async ensureHashDir(hash) {
+		this.assertValidHash(hash);
+		const dirRelative = path$1.join(hash.slice(0, 2), hash.slice(2, 4));
+		const dirPath = this.resolvePathInBase(dirRelative);
+		await fsPromises$1.mkdir(dirPath, { recursive: true });
+	}
+	metadataPath(filePath) {
+		return `${filePath}.meta.json`;
+	}
+	async store(data, mimeType) {
+		const hash = computeHash(data);
+		await this.ensureHashDir(hash);
+		const filePath = this.hashToPath(hash);
+		try {
+			await fsPromises$1.access(filePath);
+			const meta = await this.readMetadata(filePath);
+			return {
+				ref: this.buildRef(hash, meta?.mimeType ?? mimeType, meta?.sizeBytes ?? data.length, meta?.provider ?? this.providerId),
+				deduplicated: true
+			};
+		} catch {}
+		await fsPromises$1.writeFile(filePath, data);
+		const metadata = {
+			mimeType,
+			sizeBytes: data.length,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			provider: this.providerId,
+			key: filePath
+		};
+		await fsPromises$1.writeFile(this.metadataPath(filePath), JSON.stringify(metadata, null, 2));
+		return {
+			ref: this.buildRef(hash, mimeType, data.length, this.providerId),
+			deduplicated: false
+		};
+	}
+	async getByHash(hash) {
+		const filePath = this.hashToPath(hash);
+		let data;
+		try {
+			data = await fsPromises$1.readFile(filePath);
+		} catch (error) {
+			if (error.code === "ENOENT") throw new Error(`Blob not found: ${hash}`);
+			throw error;
+		}
+		const metadata = await this.readMetadata(filePath) || {
+			mimeType: "application/octet-stream",
+			sizeBytes: data.length,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			provider: this.providerId,
+			key: filePath
+		};
+		return {
+			data,
+			metadata
+		};
+	}
+	async exists(hash) {
+		try {
+			const filePath = this.hashToPath(hash);
+			await fsPromises$1.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async deleteByHash(hash) {
+		try {
+			const filePath = this.hashToPath(hash);
+			const metaPath = this.metadataPath(filePath);
+			try {
+				await fsPromises$1.unlink(filePath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			try {
+				await fsPromises$1.unlink(metaPath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		} catch {}
+	}
+	async getUrl(_hash, _expiresInSeconds) {
+		return null;
+	}
+	buildRef(hash, mimeType, sizeBytes, provider) {
+		return {
+			uri: buildUri(hash),
+			hash,
+			mimeType,
+			sizeBytes,
+			provider
+		};
+	}
+	async readMetadata(filePath) {
+		const safeFilePath = this.resolvePathInBase(filePath);
+		const metaPath = this.metadataPath(safeFilePath);
+		try {
+			const raw = await fsPromises$1.readFile(metaPath, "utf8");
+			return JSON.parse(raw);
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			logger.warn("[BlobFS] Failed to read metadata", { error });
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/blobs/index.ts
+let defaultProvider = null;
+function createDefaultProvider() {
+	return new FilesystemBlobStorageProvider();
+}
+function getBlobStorageProvider() {
+	if (!defaultProvider) {
+		defaultProvider = createDefaultProvider();
+		logger.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
+	}
+	return defaultProvider;
+}
+async function storeBlob(data, mimeType, refContext) {
+	const provider = getBlobStorageProvider();
+	const result = await provider.store(data, mimeType);
+	const db = getDb();
+	try {
+		db.transaction(() => {
+			const assetInsert = db.insert(blobAssetsTable).values({
+				hash: result.ref.hash,
+				sizeBytes: result.ref.sizeBytes,
+				mimeType: result.ref.mimeType,
+				provider: result.ref.provider
+			}).onConflictDoNothing().run();
+			return (refContext?.evalId && db.insert(blobReferencesTable).values({
+				id: randomUUID(),
+				blobHash: result.ref.hash,
+				evalId: refContext.evalId,
+				testIdx: refContext.testIdx,
+				promptIdx: refContext.promptIdx,
+				location: refContext.location,
+				kind: refContext.kind
+			}).onConflictDoNothing().run()) ?? assetInsert;
+		});
+	} catch (error) {
+		try {
+			await provider.deleteByHash(result.ref.hash);
+		} catch (cleanupError) {
+			logger.warn("[BlobStorage] Failed to rollback blob after DB error", {
+				error: cleanupError,
+				hash: result.ref.hash
+			});
+		}
+		throw error;
+	}
+	return result;
+}
+async function getBlobByHash(hash) {
+	return getBlobStorageProvider().getByHash(hash);
+}
+async function getBlobUrl(hash, expiresInSeconds) {
+	return getBlobStorageProvider().getUrl(hash, expiresInSeconds);
+}
+async function recordBlobReference(hash, refContext) {
+	if (!refContext.evalId) return;
+	if (!await getBlobStorageProvider().exists(hash).catch(() => false)) {
+		logger.debug("[BlobStorage] Attempted to record reference for missing blob", {
+			hash,
+			evalId: refContext.evalId,
+			location: refContext.location
+		});
+		return;
+	}
+	const db = getDb();
+	if (db.select({ id: blobReferencesTable.id }).from(blobReferencesTable).where(and(eq(blobReferencesTable.blobHash, hash), eq(blobReferencesTable.evalId, refContext.evalId))).get()) return;
+	db.insert(blobReferencesTable).values({
+		id: randomUUID(),
+		blobHash: hash,
+		evalId: refContext.evalId,
+		testIdx: refContext.testIdx,
+		promptIdx: refContext.promptIdx,
+		location: refContext.location,
+		kind: refContext.kind
+	}).run();
+}
+//#endregion
+export { BLOB_MAX_SIZE as a, storeBlob as i, getBlobUrl as n, BLOB_MIN_SIZE as o, recordBlobReference as r, getBlobByHash as t };
+
+//# sourceMappingURL=blobs-qTYm-1PY.js.map