@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/binary-upload-dedupe-test-Dnxlbbu6.js

@@ -0,0 +1,308 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL, vc as init_md5_esm_bundler, yc as md5 } from "./runtime-common-BTaLJEw-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CEslVSTe.js";
+import { T as settled, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { Ct as getTestRealmRegistry, D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, a as CardDef, s as Component$1, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/ai-assistant-panel/binary-upload-dedupe-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+init_md5_esm_bundler();
+var MINIMAL_PNG = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10,
+	0,
+	0,
+	0,
+	13,
+	73,
+	72,
+	68,
+	82,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1,
+	8,
+	6,
+	0,
+	0,
+	0,
+	31,
+	21,
+	196,
+	137,
+	0,
+	0,
+	0,
+	10,
+	73,
+	68,
+	65,
+	84,
+	120,
+	156,
+	98,
+	0,
+	2,
+	0,
+	0,
+	5,
+	0,
+	1,
+	13,
+	10,
+	45,
+	180,
+	0,
+	0,
+	0,
+	0,
+	73,
+	69,
+	78,
+	68,
+	174,
+	66,
+	96,
+	130
+]);
+var DIFFERENT_BINARY = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10,
+	0,
+	0,
+	0,
+	13,
+	73,
+	72,
+	68,
+	82,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1,
+	8,
+	2,
+	0,
+	0,
+	0,
+	144,
+	119,
+	83,
+	222,
+	0,
+	0,
+	0,
+	12,
+	73,
+	68,
+	65,
+	84,
+	120,
+	156,
+	98,
+	248,
+	15,
+	0,
+	0,
+	1,
+	1,
+	0,
+	5,
+	24,
+	216,
+	77,
+	0,
+	0,
+	0,
+	0,
+	73,
+	69,
+	78,
+	68,
+	174,
+	66,
+	96,
+	130
+]);
+(0, import_qunit.module)("Integration | ai-assistant-panel | binary upload dedupe", function(hooks) {
+	const realmName = "Operator Mode Workspace";
+	let loader;
+	let operatorModeStateService;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true,
+		now: (() => {
+			let clock = new Date(2024, 8, 19).getTime();
+			return () => clock += 10;
+		})()
+	});
+	let { getRoomEvents } = mockMatrixUtils;
+	let noop = () => {};
+	hooks.beforeEach(async function() {
+		operatorModeStateService = getService("operator-mode-state-service");
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "eZuHVhEf",
+						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],null,null,null],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/binary-upload-dedupe-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"Person/fadhlan.json": new Person({ firstName: "Fadhlan" }),
+				"test-image.png": MINIMAL_PNG,
+				"test-image-copy.png": MINIMAL_PNG,
+				"other-image.png": DIFFERENT_BINARY,
+				"realm.json": realmConfigCardJSON({ name: realmName })
+			}
+		});
+	});
+	function setCardInOperatorModeState(cardURL, format = "isolated") {
+		operatorModeStateService.restore({ stacks: cardURL ? [[{
+			id: cardURL,
+			format
+		}]] : [[]] });
+	}
+	async function openAiAssistant() {
+		await waitFor("[data-test-open-ai-assistant]");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-settled]");
+		let roomId = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId) throw new Error("Expected a room ID");
+		return roomId;
+	}
+	async function renderAiAssistantPanel(id) {
+		setCardInOperatorModeState(id);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "UuhHQK52",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/binary-upload-dedupe-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		return await openAiAssistant();
+	}
+	async function attachFile(filename) {
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click(`[data-test-file="${filename}"]`);
+		await click("[data-test-choose-file-modal-add-button]");
+	}
+	async function sendMessage(text) {
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", text);
+		await click("[data-test-send-message-btn]");
+	}
+	(0, import_qunit.test)("binary file upload preserves content integrity", async function(assert) {
+		await renderAiAssistantPanel();
+		await attachFile("test-image.png");
+		await sendMessage("Upload binary file");
+		let uploadedContents = mockMatrixUtils.getUploadedContents();
+		let expectedHash = md5(MINIMAL_PNG);
+		let uploadedArray = [...uploadedContents.values()].map((content) => new Uint8Array(content)).find((content) => md5(content) === expectedHash);
+		assert.ok(uploadedArray, "Found uploaded content matching test-image.png");
+		assert.strictEqual(uploadedArray.length, MINIMAL_PNG.length, "Uploaded content has same length as original PNG");
+		assert.deepEqual(uploadedArray, MINIMAL_PNG, "Uploaded bytes match original PNG exactly");
+	});
+	(0, import_qunit.test)("binary content hash is computed from raw bytes", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		await attachFile("test-image.png");
+		await sendMessage("Upload binary file for hash check");
+		let messageEvents = getRoomEvents(roomId).filter((e) => e.type === "m.room.message");
+		let messageData = messageEvents[0].content.data ? JSON.parse(messageEvents[0].content.data) : void 0;
+		let expectedHash = md5(MINIMAL_PNG);
+		assert.ok(messageData?.attachedFiles, "Message has attached files");
+		assert.strictEqual(messageData.attachedFiles[0].contentHash, expectedHash, "Content hash matches md5 of raw PNG bytes");
+	});
+	(0, import_qunit.test)("same binary content from different paths deduplicates to same mxc URL", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		await attachFile("test-image.png");
+		await sendMessage("First binary file");
+		await attachFile("test-image-copy.png");
+		await sendMessage("Copy of binary file");
+		let messageEvents = getRoomEvents(roomId).filter((e) => e.type === "m.room.message");
+		let firstData = messageEvents[0].content.data ? JSON.parse(messageEvents[0].content.data) : void 0;
+		let secondData = messageEvents[1].content.data ? JSON.parse(messageEvents[1].content.data) : void 0;
+		let expectedHash = md5(MINIMAL_PNG);
+		assert.ok(firstData?.attachedFiles, "First message has attached files");
+		assert.ok(secondData?.attachedFiles, "Second message has attached files");
+		assert.strictEqual(firstData.attachedFiles[0].url, secondData.attachedFiles[0].url, "Same binary content deduplicates to same mxc URL");
+		assert.notEqual(firstData.attachedFiles[0].sourceUrl, secondData.attachedFiles[0].sourceUrl, "Source URLs are different (different file paths)");
+		assert.strictEqual(firstData.attachedFiles[0].contentHash, expectedHash, "First file content hash matches md5 of raw PNG bytes");
+		assert.strictEqual(secondData.attachedFiles[0].contentHash, expectedHash, "Second file content hash matches md5 of raw PNG bytes");
+	});
+	(0, import_qunit.test)("file content is captured at attach time, not send time", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		await attachFile("test-image.png");
+		let testRealmRecord = getTestRealmRegistry().get(testRealmURL);
+		if (!testRealmRecord) throw new Error("Test realm not found");
+		await testRealmRecord.adapter.write("test-image.png", DIFFERENT_BINARY);
+		await settled();
+		await sendMessage("File was modified after attach");
+		let messageEvents = getRoomEvents(roomId).filter((e) => e.type === "m.room.message");
+		let messageData = messageEvents[0].content.data ? JSON.parse(messageEvents[0].content.data) : void 0;
+		let originalHash = md5(MINIMAL_PNG);
+		let modifiedHash = md5(DIFFERENT_BINARY);
+		assert.ok(messageData?.attachedFiles, "Message has attached files");
+		assert.strictEqual(messageData.attachedFiles[0].contentHash, originalHash, "Content hash matches original PNG (captured at attach time)");
+		assert.notEqual(messageData.attachedFiles[0].contentHash, modifiedHash, "Content hash does not match modified content");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/bot-registration-test-Bk2lTaCW.js

@@ -0,0 +1,97 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { r as RegisterBotTool, t as UnregisterBotTool } from "./unregister-bot-DYW2EC3X.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, R as setupRealmServerEndpoints, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/bot-registration-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | bot-registration", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let botRegistrations;
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	setupRealmServerEndpoints(hooks, [{
+		route: "_bot-registration",
+		getResponse: async (req) => {
+			if (req.method === "DELETE") {
+				let body = await req.json();
+				let index = botRegistrations.findIndex((registration) => registration.id === body?.data?.id);
+				if (index === -1) return new Response("invalid bot registration id", { status: 400 });
+				botRegistrations.splice(index, 1);
+				return new Response(null, { status: 204 });
+			}
+			let body = await req.json();
+			botRegistrations = [{
+				id: "bot-reg-1",
+				username: body.data.attributes.username,
+				createdAt: "2025-01-01T00:00:00Z"
+			}];
+			return new Response(JSON.stringify({ data: {
+				type: "bot-registration",
+				id: "bot-reg-1",
+				attributes: {
+					username: body.data.attributes.username,
+					createdAt: "2025-01-01T00:00:00Z"
+				}
+			} }), {
+				status: 201,
+				headers: { "Content-Type": "application/vnd.api+json" }
+			});
+		}
+	}, {
+		route: "_bot-registrations",
+		getResponse: async () => {
+			return new Response(JSON.stringify({ data: botRegistrations.map((registration) => ({
+				type: "bot-registration",
+				id: registration.id,
+				attributes: {
+					username: registration.username,
+					createdAt: registration.createdAt
+				}
+			})) }), {
+				status: 200,
+				headers: { "Content-Type": "application/vnd.api+json" }
+			});
+		}
+	}]);
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		getOwner(this).register("service:realm", StubRealmService);
+		botRegistrations = [];
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("register-bot returns botRegistrationId", async function(assert) {
+		let result = await new RegisterBotTool(getService("tool-service").toolContext).execute({ username: "@testuser:localhost" });
+		assert.strictEqual(result.botRegistrationId, "bot-reg-1");
+	});
+	(0, import_qunit.test)("unregister-bot removes the bot registration", async function(assert) {
+		let toolService = getService("tool-service");
+		let realmServer = getService("realm-server");
+		let registerBotCommand = new RegisterBotTool(toolService.toolContext);
+		let unregisterBotCommand = new UnregisterBotTool(toolService.toolContext);
+		let registerResult = await registerBotCommand.execute({ username: "@testuser:localhost" });
+		await unregisterBotCommand.execute({ botRegistrationId: registerResult.botRegistrationId });
+		let registrations = await realmServer.getBotRegistrations();
+		assert.strictEqual(registrations.length, 0, "bot registration removed");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/box-test-BbV9sMyU.js

@@ -0,0 +1,50 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/unit/box-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var cardApi;
+var loader;
+(0, import_qunit.module)("Unit | box", function(hooks) {
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	hooks.beforeEach(async function() {
+		cardApi = await loader.import("@cardstack/base/card-api");
+	});
+	(0, import_qunit.test)("Box children maintain object strict equality after re-ordering", async function(assert) {
+		let { Box } = cardApi;
+		let parentCardModel = { someField: [] };
+		let childCard1Model = {};
+		let childCard2Model = {};
+		let childCard3Model = {};
+		let boxArr = Box.create(parentCardModel).field("someField");
+		let childValues = [
+			childCard1Model,
+			childCard2Model,
+			childCard3Model
+		];
+		boxArr.set(childValues);
+		assert.strictEqual(boxArr.children[0].value, childCard1Model);
+		assert.strictEqual(boxArr.children[1].value, childCard2Model);
+		assert.strictEqual(boxArr.children[2].value, childCard3Model);
+		assert.strictEqual(boxArr.children[0].name, "0");
+		assert.strictEqual(boxArr.children[1].name, "1");
+		assert.strictEqual(boxArr.children[2].name, "2");
+		let childValuesReordered = [
+			childCard2Model,
+			childCard3Model,
+			childCard1Model
+		];
+		boxArr.set(childValuesReordered);
+		assert.strictEqual(boxArr.children[0].value, childCard2Model);
+		assert.strictEqual(boxArr.children[1].value, childCard3Model);
+		assert.strictEqual(boxArr.children[2].value, childCard1Model);
+		assert.strictEqual(boxArr.children[0].name, "0");
+		assert.strictEqual(boxArr.children[1].name, "1");
+		assert.strictEqual(boxArr.children[2].name, "2");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/brand-guide-attachments-test-z4wTsKbI.js

@@ -0,0 +1,84 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { t as renderCard } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/brand-guide-attachments-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | brand-guide | brand image attachments", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let BrandGuide;
+	let CompoundImageField;
+	let ImageDef;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		let brandGuideModule = await loader.import("@cardstack/base/brand-guide");
+		let cardApiModule = await loader.import("@cardstack/base/card-api");
+		BrandGuide = brandGuideModule.default;
+		CompoundImageField = brandGuideModule.CompoundImageField;
+		ImageDef = cardApiModule.ImageDef;
+	});
+	function makeImage(ImageDefClass, url, name) {
+		return new ImageDefClass({
+			id: url,
+			url,
+			sourceUrl: url,
+			name,
+			contentType: "image/png"
+		});
+	}
+	(0, import_qunit.test)("attachment row renders thumbnail, var name, and url value", async function(assert) {
+		let image = makeImage(ImageDef, "https://example.com/hero.png", "hero.png");
+		let card = new BrandGuide({ brandImageAttachments: [new CompoundImageField({
+			name: "heroBanner",
+			image
+		})] });
+		await renderCard(loader, card, "isolated");
+		assert.dom("[data-test-brand-image-attachment-var]").exists({ count: 1 }, "one row is rendered");
+		assert.dom("[data-test-brand-image-attachment-thumb]").hasAttribute("src", "https://example.com/hero.png", "thumbnail src is correct");
+		assert.dom("[data-test-brand-image-attachment-varname]").hasText("--hero-banner", "camelCase name is dasherized and prefixed with --");
+		assert.dom("[data-test-brand-image-attachment-url]").hasText("url(https://example.com/hero.png)", "url() value is rendered");
+	});
+	(0, import_qunit.test)("attachment appears in custom-css section with var name and url value", async function(assert) {
+		let image = makeImage(ImageDef, "https://example.com/hero.png", "hero.png");
+		let card = new BrandGuide({ brandImageAttachments: [new CompoundImageField({
+			name: "heroBanner",
+			image
+		})] });
+		await renderCard(loader, card, "isolated");
+		assert.dom("[data-test-brand-guide-section=\"custom-css\"]").exists("custom-css section appears");
+		assert.dom("[data-test-brand-guide-image-attachment-var]").exists({ count: 1 }, "one row appears in the custom-css section");
+		assert.dom("[data-test-brand-guide-image-attachment-varname]").hasText("--hero-banner", "var name is rendered in custom-css section");
+		assert.dom("[data-test-brand-guide-image-attachment-url]").hasText("url(https://example.com/hero.png)", "url() value is rendered in custom-css section");
+	});
+	(0, import_qunit.test)("attachments without a url are excluded from both sections", async function(assert) {
+		let card = new BrandGuide({ brandImageAttachments: [new CompoundImageField({ name: "missing" })] });
+		await renderCard(loader, card, "isolated");
+		assert.dom("[data-test-brand-image-attachment-var]").doesNotExist("item with no url is not rendered in brand-image-attachments");
+		assert.dom("[data-test-brand-guide-section=\"custom-css\"]").doesNotExist("custom-css section is hidden when all entries have no url");
+		assert.dom("[data-test-brand-guide-image-attachment-var]").doesNotExist("no rows rendered in custom-css section");
+	});
+	(0, import_qunit.test)("brand image attachments produce url() CSS variables in cssVariables", async function(assert) {
+		let image = makeImage(ImageDef, "https://example.com/hero.png", "hero.png");
+		let card = new BrandGuide({ brandImageAttachments: [new CompoundImageField({
+			name: "heroBanner",
+			image
+		})] });
+		await renderCard(loader, card, "isolated");
+		let css = card.cssVariables ?? "";
+		assert.ok(css.includes("--hero-banner: url(https://example.com/hero.png)"), "brand image attachment is emitted as a url() CSS variable");
+	});
+	(0, import_qunit.test)("brand image attachment with missing name or url is excluded from cssVariables", async function(assert) {
+		let image = makeImage(ImageDef, "https://example.com/hero.png", "hero.png");
+		let card = new BrandGuide({ brandImageAttachments: [new CompoundImageField({
+			name: "",
+			image
+		}), new CompoundImageField({ name: "noImage" })] });
+		await renderCard(loader, card, "isolated");
+		let css = card.cssVariables ?? "";
+		assert.notOk(css.includes("url(https://example.com/hero.png)"), "entry with empty name is excluded");
+		assert.notOk(css.includes("--no-image"), "entry with no image is excluded");
+	});
+});
+//#endregion