@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/file-def-manager-DUgR-gjs.js

@@ -0,0 +1,470 @@
+import "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { It as SupportedMimeType, Zt as inferContentType, ar as basicMappings, di as SEARCH_MARKER, fi as SEPARATOR_MARKER, hr as getClass, ji as relativeTo, li as REPLACE_MARKER, on as init_md5_esm_bundler, pr as codeRefWithAbsoluteIdentifier, sn as md5, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { r as setOwner } from "./owner-DGWjbd-X.js";
+import { r as service } from "./service-DJ87xpDt.js";
+import "./indexeddb-crypto-store-C09Shau-.js";
+import "./browser-index-G4NKYBAj.js";
+//#region ../runtime-common/ai/modality.ts
+init_md5_esm_bundler();
+var SUPPORTED_IMAGE_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+]);
+function isImageContentType(contentType) {
+	return !!contentType && SUPPORTED_IMAGE_TYPES.has(contentType);
+}
+function isPdfContentType(contentType) {
+	return !!contentType && contentType.includes("application/pdf");
+}
+function isAudioContentType(contentType) {
+	return !!contentType && contentType.startsWith("audio/");
+}
+function isVideoContentType(contentType) {
+	return !!contentType && contentType.startsWith("video/");
+}
+function requiredModality(contentType) {
+	if (isImageContentType(contentType)) return "image";
+	if (isPdfContentType(contentType)) return "file";
+	if (isAudioContentType(contentType)) return "audio";
+	if (isVideoContentType(contentType)) return "video";
+}
+var MODALITY_LABELS = {
+	image: "image files",
+	file: "PDF files",
+	audio: "audio files",
+	video: "video files"
+};
+function modalityLabel(modality) {
+	return MODALITY_LABELS[modality];
+}
+function isTextBasedContentType(contentType) {
+	if (!contentType) return false;
+	if (contentType.includes("text/")) return true;
+	if (contentType.includes("application/vnd.card+json")) return true;
+	if (contentType.includes("application/vnd.card+source")) return true;
+	return false;
+}
+//#endregion
+//#region ../runtime-common/ai/matrix-utils.ts
+var fileCache = /* @__PURE__ */ new Map();
+var CACHE_EXPIRATION_MS$1 = 1800 * 1e3;
+var inFlightFetches = /* @__PURE__ */ new Map();
+function cleanupCache() {
+	const now = Date.now();
+	for (const [url, entry] of fileCache.entries()) if (now - entry.timestamp > CACHE_EXPIRATION_MS$1) fileCache.delete(url);
+}
+async function fetchMatrixMediaWithFallback(client, url) {
+	let headers = { Authorization: `Bearer ${client.getAccessToken()}` };
+	let primaryError;
+	try {
+		let primaryResponse = await globalThis.fetch(url, { headers });
+		if (primaryResponse.ok) return primaryResponse;
+		primaryError = /* @__PURE__ */ new Error(`HTTP error. Status: ${primaryResponse.status}`);
+	} catch (err) {
+		primaryError = err;
+	}
+	let canonical = canonicalizeMatrixMediaKey(url);
+	let fallbackUrl = canonical?.startsWith("mxc://") && canonical !== url ? client.mxcUrlToHttp(canonical, void 0, void 0, void 0, void 0, void 0, true) : null;
+	if (!fallbackUrl || fallbackUrl === url) throw primaryError;
+	let fallbackResponse = await globalThis.fetch(fallbackUrl, { headers });
+	if (!fallbackResponse.ok) throw new Error(`HTTP error. Status: ${fallbackResponse.status}`);
+	return fallbackResponse;
+}
+async function downloadFile(client, attachedFile) {
+	let fileUrl = attachedFile?.url;
+	if (!fileUrl) throw new Error("Attached file URL is missing");
+	if (!isTextBasedContentType(attachedFile?.contentType)) throw new Error(`Unsupported file type: ${attachedFile.contentType}. For now, only text files are supported.`);
+	const canonicalKey = canonicalizeMatrixMediaKey(fileUrl);
+	const cachedEntry = canonicalKey ? fileCache.get(canonicalKey) : fileCache.get(fileUrl);
+	if (cachedEntry) {
+		cachedEntry.timestamp = Date.now();
+		return cachedEntry.content;
+	}
+	const inFlightKey = canonicalKey || fileUrl;
+	const inFlight = inFlightFetches.get(inFlightKey);
+	if (inFlight) return await inFlight;
+	const fetchPromise = (async () => {
+		const content = await (await fetchMatrixMediaWithFallback(client, fileUrl)).text();
+		const cacheKey = canonicalKey || fileUrl;
+		fileCache.set(cacheKey, {
+			content,
+			timestamp: Date.now()
+		});
+		if (fileCache.size > 100) cleanupCache();
+		return content;
+	})();
+	inFlightFetches.set(inFlightKey, fetchPromise);
+	try {
+		return await fetchPromise;
+	} finally {
+		inFlightFetches.delete(inFlightKey);
+	}
+}
+async function downloadFileAsBase64DataUrl(client, url, contentType) {
+	let buffer = await (await fetchMatrixMediaWithFallback(client, url)).arrayBuffer();
+	let bytes = new Uint8Array(buffer);
+	let maybeBuffer = globalThis.Buffer;
+	if (maybeBuffer?.from) return `data:${contentType};base64,${maybeBuffer.from(bytes).toString("base64")}`;
+	let btoaFn = globalThis.btoa;
+	if (typeof btoaFn !== "function") throw new Error("No base64 encoder available in this runtime");
+	let binaryChunks = [];
+	let chunkSize = 32768;
+	for (let i = 0; i < bytes.length; i += chunkSize) {
+		let chunk = bytes.subarray(i, i + chunkSize);
+		binaryChunks.push(String.fromCharCode(...chunk));
+	}
+	return `data:${contentType};base64,${btoaFn(binaryChunks.join(""))}`;
+}
+function isCommandOrCodePatchResult(event) {
+	let type = event.type || event.getType?.();
+	return type === "app.boxel.commandResult" || type === "app.boxel.codePatchResult";
+}
+function extractCodePatchBlocks(s) {
+	return [...s.matchAll(new RegExp(`${SEARCH_MARKER}.*?${SEPARATOR_MARKER}.*?${REPLACE_MARKER}`, "gs"))].map((match) => match[0]);
+}
+function canonicalizeMatrixMediaKey(url) {
+	if (!url) return null;
+	if (url.startsWith("mxc://")) return url;
+	try {
+		const parts = new URL(url).pathname.replace(/\/+$|\?.*$/g, "").split("/").filter(Boolean);
+		const downloadIdx = parts.indexOf("download");
+		if (downloadIdx !== -1 && parts.length >= downloadIdx + 3) return `mxc://${parts[downloadIdx + 1]}/${parts[downloadIdx + 2]}`;
+		const thumbIdx = parts.indexOf("thumbnail");
+		if (thumbIdx !== -1 && parts.length >= thumbIdx + 3) return `mxc://${parts[thumbIdx + 1]}/${parts[thumbIdx + 2]}`;
+	} catch (e) {}
+	return url;
+}
+//#endregion
+//#region app/lib/file-def-manager.ts
+var isSkillCard = Symbol.for("is-skill-card");
+var CACHE_EXPIRATION_MS = 1800 * 1e3;
+var LOCAL_SOURCE_URL_PREFIX = "boxel-local://";
+var FileDefManagerImpl = class {
+	static {
+		decorateFieldV2(this.prototype, "cardService", [service]);
+	}
+	#cardService;
+	static {
+		decorateFieldV2(this.prototype, "commandService", [service]);
+	}
+	#commandService;
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService;
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network;
+	constructor({ owner, client, getCardAPI, getFileAPI }) {
+		this.downloadCache = /* @__PURE__ */ new Map();
+		this.inFlightTextFetches = /* @__PURE__ */ new Map();
+		this.inFlightBlobFetches = /* @__PURE__ */ new Map();
+		this.contentHashCache = /* @__PURE__ */ new Map();
+		this.invalidUrlCache = /* @__PURE__ */ new Set();
+		this.prefetchedContent = /* @__PURE__ */ new Map();
+		this.#cardService = (initializeDeferredDecorator(this, "cardService"), void 0);
+		this.#commandService = (initializeDeferredDecorator(this, "commandService"), void 0);
+		this.#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+		this.#network = (initializeDeferredDecorator(this, "network"), void 0);
+		setOwner(this, owner);
+		this.client = client;
+		this.getCardAPI = getCardAPI;
+		this.getFileAPI = getFileAPI;
+	}
+	get fileAPI() {
+		return this.getFileAPI();
+	}
+	get cardAPI() {
+		return this.getCardAPI();
+	}
+	mxcToHttpUrl(mxcUrl) {
+		return this.client.mxcUrlToHttp(mxcUrl, void 0, void 0, void 0, void 0, void 0, true);
+	}
+	async getContentHash(content) {
+		return md5(content);
+	}
+	async getCachedUrlForContent(content) {
+		const hash = await this.getContentHash(content);
+		let cachedUrl = this.contentHashCache.get(hash) || null;
+		if (cachedUrl && !this.isMatrixMediaUrl(cachedUrl)) {
+			this.contentHashCache.delete(hash);
+			return null;
+		}
+		return cachedUrl;
+	}
+	async uploadContentWithCaching(content, contentType) {
+		const cachedUrl = await this.getCachedUrlForContent(content);
+		if (cachedUrl) return cachedUrl;
+		let response = await this.client.uploadContent(content, { type: contentType });
+		let url = this.mxcToHttpUrl(response.content_uri);
+		if (!url) throw new Error("Failed to convert mxcUrl to http");
+		const hash = await this.getContentHash(content);
+		this.contentHashCache.set(hash, url);
+		return url;
+	}
+	isMatrixMediaUrl(url) {
+		return url.startsWith("mxc://") || url.includes("/_matrix/media/");
+	}
+	isLocalSourceUrl(url) {
+		return url.startsWith(LOCAL_SOURCE_URL_PREFIX);
+	}
+	resolveUploadContentType(file, fetchedContentType) {
+		let hinted = file.contentType?.trim() ?? "";
+		let fetched = fetchedContentType?.trim() ?? "";
+		if (hinted && hinted !== "application/octet-stream" && hinted !== "application/vnd.card+source") return hinted;
+		let fetchedBase = fetched.split(";")[0]?.trim().toLowerCase();
+		if (!fetchedBase || fetchedBase === "application/octet-stream" || fetchedBase === "application/vnd.card+source" || fetchedBase === "text/plain") {
+			let inferred = inferContentType(file.name ?? file.sourceUrl ?? "");
+			if (inferred && inferred !== "application/octet-stream") return inferred;
+		}
+		return fetched || hinted;
+	}
+	async recacheContentHash(contentHash, url) {
+		if (!this.isMatrixMediaUrl(url)) return;
+		const canonicalKey = canonicalizeMatrixMediaKey(url) || url;
+		if (this.invalidUrlCache.has(canonicalKey)) return;
+		let content = await this.downloadContentAsBytes(url);
+		if (await this.getContentHash(content) !== contentHash) {
+			console.warn(`Content hash mismatch for URL: ${url}, skipping re-caching step`);
+			this.invalidUrlCache.add(canonicalKey);
+			return;
+		}
+		let storedUrl = url;
+		if (canonicalKey.startsWith("mxc://")) try {
+			const maybeHttp = this.mxcToHttpUrl(canonicalKey);
+			if (maybeHttp) storedUrl = maybeHttp;
+		} catch (e) {}
+		this.contentHashCache.set(contentHash, storedUrl);
+	}
+	async uploadCards(cards) {
+		if (!cards.length) return [];
+		let cardEntries = await Promise.all(cards.map(async (card) => {
+			let opts = {
+				useAbsoluteURL: true,
+				includeComputeds: true
+			};
+			let { default: Base64ImageField } = await this.loaderService.loader.import(`${baseRealm.url}base64-image`);
+			return {
+				card,
+				serialization: await this.cardService.serializeCard(card, {
+					omitFields: [Base64ImageField],
+					...opts
+				})
+			};
+		}));
+		return await Promise.all(cardEntries.map(async (entry) => {
+			const content = JSON.stringify(entry.serialization);
+			const contentHash = await this.getContentHash(content);
+			let fileDef = this.fileAPI.createFileDef({
+				sourceUrl: entry.card.id ? this.network.virtualNetwork.unresolveURL(entry.card.id) : "",
+				name: entry.card.cardTitle,
+				contentType: SupportedMimeType.CardJson,
+				contentHash
+			});
+			fileDef.url = await this.uploadContentWithCaching(content, fileDef.contentType);
+			return fileDef;
+		}));
+	}
+	async uploadCommandDefinitions(commandDefinitions) {
+		if (!commandDefinitions.length) return [];
+		let commandDefinitionSchemas = [];
+		const mappings = await basicMappings(this.loaderService.loader);
+		for (let commandDef of commandDefinitions) {
+			let absoluteCodeRef = codeRefWithAbsoluteIdentifier(commandDef.codeRef, commandDef[relativeTo], void 0, this.network.virtualNetwork);
+			const command = new (await (getClass(absoluteCodeRef, this.loaderService.loader)))(this.commandService.commandContext);
+			const schema = {
+				codeRef: absoluteCodeRef,
+				tool: {
+					type: "function",
+					function: {
+						name: commandDef.functionName,
+						description: command.description,
+						parameters: {
+							type: "object",
+							properties: {
+								description: { type: "string" },
+								...await command.getInputJsonSchema(this.getCardAPI(), mappings)
+							},
+							required: ["attributes", "description"]
+						}
+					}
+				}
+			};
+			commandDefinitionSchemas.push(schema);
+		}
+		return await Promise.all(commandDefinitionSchemas.map(async (schema) => {
+			const name = schema.tool.function.name;
+			const content = JSON.stringify(schema);
+			const contentHash = await this.getContentHash(content);
+			const fileDef = this.fileAPI.createFileDef({
+				sourceUrl: `${schema.codeRef.module}/${schema.codeRef.name}`,
+				name,
+				contentType: "text/plain",
+				contentHash
+			});
+			fileDef.url = await this.uploadContentWithCaching(content, fileDef.contentType);
+			return fileDef;
+		}));
+	}
+	async prefetchFileContent(file) {
+		if (!file.sourceUrl) throw new Error("File needs a realm server source URL to prefetch");
+		let response = await this.network.authedFetch(file.sourceUrl, { headers: { Accept: "application/vnd.card+source" } });
+		let bytes = new Uint8Array(await response.arrayBuffer());
+		let fetchedContentType = response.headers.get("content-type") ?? "";
+		let contentType = this.resolveUploadContentType(file, fetchedContentType);
+		this.prefetchedContent.set(file.sourceUrl, {
+			bytes,
+			contentType
+		});
+	}
+	async prefetchLocalFileContent(file, bytes, contentType) {
+		if (!file.sourceUrl) throw new Error("File needs a source URL to prefetch local content");
+		this.prefetchedContent.set(file.sourceUrl, {
+			bytes,
+			contentType
+		});
+	}
+	clearPrefetchedContent() {
+		this.prefetchedContent.clear();
+	}
+	async uploadFiles(files) {
+		return await Promise.all(files.map(async (file) => {
+			if (!file.sourceUrl) throw new Error("File needs a realm server source URL to upload");
+			let bytes;
+			let contentType;
+			let usedPrefetchedContent = false;
+			let cached = this.prefetchedContent.get(file.sourceUrl);
+			if (cached) {
+				bytes = cached.bytes;
+				contentType = this.resolveUploadContentType(file, cached.contentType);
+				usedPrefetchedContent = true;
+			} else if (this.isLocalSourceUrl(file.sourceUrl)) throw new Error(`Local file content is not available for upload: ${file.sourceUrl}`);
+			else {
+				let response = await this.network.authedFetch(file.sourceUrl, { headers: { Accept: "application/vnd.card+source" } });
+				bytes = new Uint8Array(await response.arrayBuffer());
+				let fetchedContentType = response.headers.get("content-type") ?? "";
+				contentType = this.resolveUploadContentType(file, fetchedContentType);
+			}
+			if (!contentType) throw new Error(`File has no content type: ${file.sourceUrl}`);
+			let uploadedUrl = await this.uploadContentWithCaching(bytes, contentType);
+			let contentHash = await this.getContentHash(bytes);
+			let contentSize = bytes.byteLength;
+			if (usedPrefetchedContent) this.prefetchedContent.delete(file.sourceUrl);
+			return this.fileAPI.createFileDef({
+				sourceUrl: file.sourceUrl,
+				name: file.name,
+				url: uploadedUrl,
+				contentType,
+				contentHash,
+				contentSize
+			});
+		}));
+	}
+	async downloadContentAsBlob(serializedFile) {
+		const canonicalKey = canonicalizeMatrixMediaKey(serializedFile.url) || serializedFile.url;
+		const inFlight = this.inFlightBlobFetches.get(canonicalKey);
+		if (inFlight) return await inFlight;
+		const fetchPromise = (async () => {
+			const response = await fetch(serializedFile.url, { headers: { Authorization: `Bearer ${this.client.getAccessToken()}` } });
+			if (!response.ok) throw new Error(`HTTP error. Status: ${response.status}`);
+			return await response.blob();
+		})();
+		this.inFlightBlobFetches.set(canonicalKey, fetchPromise);
+		try {
+			return await fetchPromise;
+		} finally {
+			this.inFlightBlobFetches.delete(canonicalKey);
+		}
+	}
+	async downloadContentAsText(url) {
+		const canonicalKey = canonicalizeMatrixMediaKey(url) || url;
+		const cachedEntry = this.downloadCache.get(canonicalKey);
+		if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_EXPIRATION_MS) return cachedEntry.content;
+		const inFlight = this.inFlightTextFetches.get(canonicalKey);
+		if (inFlight) return await inFlight;
+		const fetchPromise = (async () => {
+			const response = await fetch(url, { headers: { Authorization: `Bearer ${this.client.getAccessToken()}` } });
+			if (!response.ok) throw new Error(`HTTP error. Status: ${response.status}`);
+			const text = await response.text();
+			try {
+				this.downloadCache.set(canonicalKey, {
+					content: text,
+					timestamp: Date.now()
+				});
+				if (this.downloadCache.size > 100) this.cleanupCache();
+			} catch (e) {
+				console.warn("downloadContentAsText: failed to cache", {
+					url,
+					canonicalKey,
+					err: e
+				});
+			}
+			return text;
+		})();
+		this.inFlightTextFetches.set(canonicalKey, fetchPromise);
+		try {
+			return await fetchPromise;
+		} finally {
+			this.inFlightTextFetches.delete(canonicalKey);
+		}
+	}
+	async downloadContentAsBytes(url) {
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${this.client.getAccessToken()}` } });
+		if (!response.ok) throw new Error(`HTTP error. Status: ${response.status}`);
+		return new Uint8Array(await response.arrayBuffer());
+	}
+	async downloadAsFileInBrowser(serializedFile) {
+		const blob = await this.downloadContentAsBlob(serializedFile);
+		const blobUrl = URL.createObjectURL(blob);
+		const downloadLink = document.createElement("a");
+		downloadLink.href = blobUrl;
+		downloadLink.download = serializedFile.name;
+		document.body.appendChild(downloadLink);
+		downloadLink.click();
+		document.body.removeChild(downloadLink);
+		URL.revokeObjectURL(blobUrl);
+	}
+	/**
+	* Downloads a card from a SerializedFile and returns it as a LooseSingleCardDocument
+	* Uses caching to avoid repeated downloads of the same file
+	*/
+	async downloadCardFileDef(serializedFile) {
+		if (!serializedFile?.contentType?.includes("text/") && !serializedFile.contentType?.includes("application/vnd.card+json")) throw new Error(`Unsupported file type: ${serializedFile.contentType}`);
+		const content = await this.downloadContentAsText(serializedFile.url);
+		return JSON.parse(content);
+	}
+	/**
+	* Cleans up expired entries from the download cache
+	*/
+	cleanupCache() {
+		const now = Date.now();
+		for (const [url, entry] of this.downloadCache.entries()) if (now - entry.timestamp > CACHE_EXPIRATION_MS) this.downloadCache.delete(url);
+	}
+	async cacheContentHashIfNeeded(event) {
+		const recachingPromises = [];
+		if (event.type === "m.room.message" && (event.content.msgtype === "app.boxel.message" || event.content.msgtype === "app.boxel.codePatchCorrectness")) {
+			let data = event.content.data;
+			if (data?.attachedFiles) {
+				for (const file of data.attachedFiles) if (file.contentHash && file.url) recachingPromises.push(this.client.recacheContentHash(file.contentHash, file.url));
+			}
+			if (data?.attachedCards) {
+				for (const card of data.attachedCards) if (card.contentHash && card.url) recachingPromises.push(this.client.recacheContentHash(card.contentHash, card.url));
+			}
+		} else if (event.type === "app.boxel.room.skills") {
+			const skillsContent = event.content;
+			const skillsAndCommands = [
+				...skillsContent.enabledSkillCards || [],
+				...skillsContent.disabledSkillCards || [],
+				...skillsContent.commandDefinitions || []
+			];
+			for (const skillOrCommand of skillsAndCommands) if (skillOrCommand.contentHash && skillOrCommand.url) recachingPromises.push(this.client.recacheContentHash(skillOrCommand.contentHash, skillOrCommand.url));
+		}
+		await Promise.all(recachingPromises);
+	}
+};
+//#endregion
+export { downloadFileAsBase64DataUrl as a, isAudioContentType as c, isTextBasedContentType as d, isVideoContentType as f, downloadFile as i, isImageContentType as l, requiredModality as m, isSkillCard as n, extractCodePatchBlocks as o, modalityLabel as p, canonicalizeMatrixMediaKey as r, isCommandOrCodePatchResult as s, FileDefManagerImpl as t, isPdfContentType as u };