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

package/bundled-test-harness/assets/copy-and-edit-test-Cqw7kcur.js

@@ -0,0 +1,292 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { G as realmURL } from "./constants-Icc0nFW-.js";
+import { t as StackItem } from "./stack-item-DVxyTuhM.js";
+import { T as settled } from "./dist-BOAdzfkP.js";
+import { t as CopyAndEditTool } from "./copy-and-edit-xnb1V7j9.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, 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/copy-and-edit-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var otherRealmURL = "http://other-realm/test2/";
+(0, import_qunit.module)("Integration | tools | copy-and-edit", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL, otherRealmURL]
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {
+				"content-card.gts": `
+          import { CardDef, contains, field, linksTo, linksToMany } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+
+          export class Child extends CardDef {
+            static displayName = 'Child';
+            @field name = contains(StringField);
+          }
+
+          export class Parent extends CardDef {
+            static displayName = 'Parent';
+            @field child = linksTo(Child);
+            @field children = linksToMany(() => Child);
+          }
+        `,
+				"Child/og.json": { data: {
+					type: "card",
+					attributes: { name: "Original" },
+					meta: { adoptsFrom: {
+						module: "../content-card",
+						name: "Child"
+					} }
+				} },
+				"Parent/root.json": { data: {
+					type: "card",
+					relationships: {
+						child: { data: {
+							type: "card",
+							id: "../Child/og"
+						} },
+						"children.0": { links: { self: "../Child/og" } }
+					},
+					meta: { adoptsFrom: {
+						module: "../content-card",
+						name: "Parent"
+					} }
+				} },
+				"simple-card.gts": `
+          import { CardDef, field, contains } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+
+          export class Theme extends CardDef {
+            static displayName = 'Theme';
+            @field name = contains(StringField);
+          }
+
+          export class SimpleCard extends CardDef {
+            static displayName = 'SimpleCard';
+          }
+        `,
+				"Theme/og.json": { data: {
+					type: "card",
+					attributes: { name: "Original Theme" },
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/theme",
+						name: "default"
+					} }
+				} },
+				"simple-card-instance.json": { data: {
+					type: "card",
+					attributes: {},
+					relationships: { "cardInfo.theme": { data: {
+						type: "card",
+						id: "./Theme/og"
+					} } },
+					meta: { adoptsFrom: {
+						module: "./simple-card",
+						name: "SimpleCard"
+					} }
+				} }
+			}
+		}));
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: otherRealmURL,
+			contents: {
+				"content-card.gts": `
+          import { CardDef, contains, field } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+
+          export class Child extends CardDef {
+            static displayName = 'Child';
+            @field name = contains(StringField);
+          }
+        `,
+				"Child/remote.json": { data: {
+					type: "card",
+					attributes: { name: "RemoteChild" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}content-card`,
+						name: "Child"
+					} }
+				} }
+			}
+		}));
+		let realmService = getService("realm");
+		await realmService.login(testRealmURL);
+		await realmService.login(otherRealmURL);
+	});
+	(0, import_qunit.test)("copies card and relinks linksTo parent (same realm)", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let parentCard = await store.get(`${testRealmURL}Parent/root`);
+		let childCard = await store.get(`${testRealmURL}Child/og`);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: parentCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: childCard.id,
+			format: "isolated",
+			stackIndex: 0,
+			relationshipContext: {
+				fieldName: "child",
+				fieldType: "linksTo"
+			}
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
+		await settled();
+		let updatedParent = await store.get(parentCard.id);
+		let newChildId = updatedParent.child?.id ?? updatedParent.child;
+		assert.ok(newChildId, "parent now links to a child (linksTo)");
+		assert.notEqual(newChildId, childCard.id, "parent links to a different child after copy");
+		if (newChildId) {
+			let copiedChild = await store.get(newChildId);
+			assert.strictEqual(copiedChild[realmURL]?.href, testRealmURL, "new child is in same realm as source");
+		}
+	});
+	(0, import_qunit.test)("copies card and relinks nested linksTo parent when only leaf field name is provided", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let parentCard = await store.get(`${testRealmURL}simple-card-instance`);
+		let originalTheme = await store.get(`${testRealmURL}Theme/og`);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: parentCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: originalTheme.id,
+			format: "isolated",
+			stackIndex: 0,
+			relationshipContext: {
+				fieldName: "theme",
+				fieldType: "linksTo"
+			}
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: originalTheme });
+		await settled();
+		let updatedParent = await store.get(parentCard.id);
+		let linkedThemeId = updatedParent.cardInfo?.theme?.id ?? updatedParent.cardInfo?.theme;
+		assert.ok(linkedThemeId, "parent cardInfo.theme is set after copy");
+		assert.notEqual(linkedThemeId, originalTheme.id, "cardInfo.theme points to copied theme");
+	});
+	(0, import_qunit.test)("copies card without linked parent (query-derived stack) and does not throw", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let childCard = await store.get(`${testRealmURL}Child/og`);
+		operatorModeStateService.clearStacks();
+		operatorModeStateService.addItemToStack(operatorModeStateService.createStackItem(`${testRealmURL}index`, 0, "isolated"));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
+		assert.ok(true, "command completes without throwing when no parent linked");
+	});
+	(0, import_qunit.test)("copies card in single stack and replaces current item", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let simpleCard = await store.get(`${testRealmURL}simple-card-instance`);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: simpleCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: simpleCard });
+		await settled();
+		let stacks = operatorModeStateService.state?.stacks ?? [];
+		let topItemId = stacks[0]?.[stacks[0].length - 1]?.id;
+		assert.ok(topItemId, "stack has a top item after copy");
+		assert.notEqual(topItemId, simpleCard.id, "stack item replaced with copied card");
+	});
+	(0, import_qunit.test)("copies card and relinks linksToMany parent (same realm)", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let parentCard = await store.get(`${testRealmURL}Parent/root`);
+		let childCard = await store.get(`${testRealmURL}Child/og`);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: parentCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: childCard.id,
+			format: "isolated",
+			stackIndex: 0,
+			relationshipContext: {
+				fieldName: "children",
+				fieldType: "linksToMany"
+			}
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
+		await settled();
+		let newChildrenIds = (await store.get(parentCard.id)).children?.map((c) => c?.id ?? c) ?? [];
+		assert.ok(newChildrenIds.some((id) => id && id !== childCard.id), "linksToMany children updated to include copied child");
+	});
+	(0, import_qunit.test)("copies linked card and relinks linksTo parent (cross realm)", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let parentCard = await store.get(`${testRealmURL}Parent/root`);
+		let remoteChild = await store.get(`${otherRealmURL}Child/remote`);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: parentCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: remoteChild.id,
+			format: "isolated",
+			stackIndex: 0,
+			relationshipContext: {
+				fieldName: "child",
+				fieldType: "linksTo"
+			}
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: remoteChild });
+		await settled();
+		let updatedParent = await store.get(parentCard.id);
+		let newChildId = updatedParent.child?.id ?? updatedParent.child;
+		assert.ok(newChildId, "parent now links to a child after copy");
+		assert.notEqual(newChildId, remoteChild.id, "parent links to a different child after copy");
+		assert.ok(newChildId.startsWith(otherRealmURL), "copied child remains in original remote realm");
+	});
+	(0, import_qunit.test)("copies card and relinks linksToMany parent (cross realm)", async function(assert) {
+		let toolService = getService("tool-service");
+		let store = getService("store");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let parentCard = await store.get(`${testRealmURL}Parent/root`);
+		let remoteChild = await store.get(`${otherRealmURL}Child/remote`);
+		parentCard.children = [remoteChild];
+		if (parentCard.id) store.save(parentCard.id);
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: parentCard.id,
+			format: "isolated",
+			stackIndex: 0
+		}));
+		operatorModeStateService.addItemToStack(new StackItem({
+			id: remoteChild.id,
+			format: "isolated",
+			stackIndex: 0,
+			relationshipContext: {
+				fieldName: "children",
+				fieldType: "linksToMany"
+			}
+		}));
+		await new CopyAndEditTool(toolService.toolContext).execute({ card: remoteChild });
+		await settled();
+		let newChildrenIds = (await store.get(parentCard.id)).children?.map((c) => c?.id ?? c) ?? [];
+		assert.ok(newChildrenIds.some((id) => id && id !== remoteChild.id), "linksToMany children updated to include copied child");
+		assert.ok(newChildrenIds.some((id) => id && id.startsWith(otherRealmURL)), "copied child remains in original remote realm");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/copy-card-test-D5m3eVEH.js

@@ -0,0 +1,218 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { G as realmURL } from "./constants-Icc0nFW-.js";
+import { r as basicMappings } from "./ai-BFUROO-8.js";
+import { t as StackItem } from "./stack-item-DVxyTuhM.js";
+import { t as CopyCardToRealmTool } from "./copy-card-D0YSVIfv.js";
+import { t as CopyCardToStackTool } from "./copy-card-to-stack-DD_vzJ5Q.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, 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/copy-card-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+(0, import_qunit.module)("Integration | tools | copy-card", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL, testRealm2URL]
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => {
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: testRealmURL,
+				contents: {
+					"pet.gts": `
+          import { contains, field, CardDef } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+          export class Pet extends CardDef {
+            static displayName = 'Pet';
+            @field firstName = contains(StringField);
+          }
+        `,
+					"Pet/mango.json": { data: {
+						type: "card",
+						attributes: { firstName: "Mango" },
+						meta: { adoptsFrom: {
+							module: "../pet",
+							name: "Pet"
+						} }
+					} }
+				}
+			});
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: testRealm2URL,
+				contents: {
+					"index.json": { data: {
+						type: "card",
+						meta: { adoptsFrom: {
+							module: "@cardstack/base/cards-grid",
+							name: "CardsGrid"
+						} }
+					} },
+					"Pet/fluffy.json": { data: {
+						type: "card",
+						attributes: { firstName: "Fluffy" },
+						meta: { adoptsFrom: {
+							module: `${testRealmURL}pet`,
+							name: "Pet"
+						} }
+					} }
+				}
+			});
+		});
+		let realmService = getService("realm");
+		await realmService.login(testRealmURL);
+		await realmService.login(testRealm2URL);
+	});
+	(0, import_qunit.module)("CopyCardToRealmTool", function() {
+		(0, import_qunit.test)("copies card to target realm", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
+			let sourceCardUrl = `${testRealmURL}Pet/mango`;
+			let targetRealm = testRealm2URL;
+			let store = getService("store");
+			let sourceCard = await store.get(sourceCardUrl);
+			assert.ok(sourceCard, "source card exists");
+			assert.strictEqual(sourceCard[realmURL]?.href, testRealmURL, "source card is from expected realm");
+			let result = await copyCardCommand.execute({
+				sourceCard,
+				targetRealm
+			});
+			assert.ok(result.newCardId, "new card URL is returned");
+			assert.true(result.newCardId.startsWith(targetRealm), "new card is created in target realm");
+			assert.notEqual(result.newCardId, sourceCardUrl, "new card has different URL than source");
+			let copiedCard = await store.get(result.newCardId);
+			assert.ok(copiedCard, "copied card exists in store");
+			assert.strictEqual(copiedCard[realmURL]?.href, targetRealm, "copied card is in target realm");
+		});
+		(0, import_qunit.test)("puts the copy beneath localDir, in a folder named after its type", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
+			let store = getService("store");
+			let sourceCard = await store.get(`${testRealmURL}Pet/mango`);
+			let result = await copyCardCommand.execute({
+				sourceCard,
+				targetRealm: testRealm2URL,
+				localDir: "projects/acme"
+			});
+			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy lands at <targetRealm><localDir>/<CardTypeName>/<generated-id>, got ${result.newCardId}`);
+			let copiedCard = await store.get(result.newCardId);
+			assert.strictEqual(copiedCard.firstName, "Mango", "the copy is readable at newCardId");
+		});
+		(0, import_qunit.test)("reads a leading slash in localDir as the realm root", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
+			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
+			let result = await copyCardCommand.execute({
+				sourceCard,
+				targetRealm: testRealm2URL,
+				localDir: "/projects/acme"
+			});
+			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy stays inside the target realm, got ${result.newCardId}`);
+		});
+		(0, import_qunit.test)("refuses a localDir that leaves the target realm", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
+			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
+			for (let localDir of [
+				"../test",
+				"projects/../../test",
+				"%2e%2e/test"
+			]) await assert.rejects(copyCardCommand.execute({
+				sourceCard,
+				targetRealm: testRealm2URL,
+				localDir
+			}), /is not a folder inside/, `localDir "${localDir}" is refused`);
+		});
+		(0, import_qunit.test)("the tool schema describes how targetRealm and localDir make up the path of the copy", async function(assert) {
+			let loader = getService("loader-service").loader;
+			let cardAPI = await loader.import("@cardstack/base/card-api");
+			let mappings = await basicMappings(loader);
+			let { properties } = (await new CopyCardToRealmTool(getService("tool-service").toolContext).getInputJsonSchema(cardAPI, mappings, true)).attributes;
+			assert.true(properties.targetRealm?.description?.includes("<targetRealm><localDir>/<CardTypeName>/<generated-id>.json"), "targetRealm states the path the copy is written to");
+			assert.true(properties.localDir?.description?.includes("projects/acme/Incident/<generated-id>.json"), "localDir gives an example of the folder it adds and the generated file name");
+		});
+		(0, import_qunit.test)("errors when user does not have write permissions to target realm", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
+			let sourceCardUrl = `${testRealmURL}Pet/mango`;
+			let targetRealm = testRealm2URL;
+			let realmService = getService("realm");
+			realmService.logout();
+			await realmService.login(testRealmURL);
+			let sourceCard = await getService("store").get(sourceCardUrl);
+			assert.ok(sourceCard, "source card exists");
+			try {
+				await copyCardCommand.execute({
+					sourceCard,
+					targetRealm
+				});
+				assert.ok(false, "should have thrown an error");
+			} catch (error) {
+				assert.ok(error instanceof Error, "throws an error");
+				assert.strictEqual(error.message, `Do not have write permissions to ${targetRealm}`, "error message indicates write permission issue");
+			}
+		});
+	});
+	(0, import_qunit.module)("CopyCardToStackTool", function() {
+		(0, import_qunit.test)("copies card to stack when valid targetStackIndex is provided", async function(assert) {
+			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
+			let sourceCardUrl = `${testRealmURL}Pet/mango`;
+			let targetStackIndex = 0;
+			let targetCardUrl = `${testRealm2URL}Pet/fluffy`;
+			let operatorModeStateService = getService("operator-mode-state-service");
+			operatorModeStateService.topMostStackItems = () => [new StackItem({
+				id: targetCardUrl,
+				format: "isolated",
+				stackIndex: 0
+			})];
+			let store = getService("store");
+			let sourceCard = await store.get(sourceCardUrl);
+			assert.ok(sourceCard, "source card exists");
+			assert.strictEqual(sourceCard[realmURL]?.href, testRealmURL, "source card is from expected realm");
+			let result = await copyCardToStackCommand.execute({
+				sourceCard,
+				targetStackIndex
+			});
+			assert.ok(result.newCardId, "new card URL is returned");
+			assert.true(result.newCardId.startsWith(testRealm2URL), "new card is created in target realm");
+			assert.notEqual(result.newCardId, sourceCardUrl, "new card has different URL than source");
+			let copiedCard = await store.get(result.newCardId);
+			assert.ok(copiedCard, "copied card exists in store");
+			assert.strictEqual(copiedCard[realmURL]?.href, testRealm2URL, "copied card is in target realm");
+		});
+		(0, import_qunit.test)("puts the copy beneath localDir in the target stack realm", async function(assert) {
+			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
+			let operatorModeStateService = getService("operator-mode-state-service");
+			operatorModeStateService.topMostStackItems = () => [new StackItem({
+				id: `${testRealm2URL}Pet/fluffy`,
+				format: "isolated",
+				stackIndex: 0
+			})];
+			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
+			let result = await copyCardToStackCommand.execute({
+				sourceCard,
+				targetStackIndex: 0,
+				localDir: "projects/acme"
+			});
+			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy lands beneath localDir in the stack's realm, got ${result.newCardId}`);
+		});
+		(0, import_qunit.test)("errors when targetStackIndex does not exist", async function(assert) {
+			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
+			let sourceCardUrl = `${testRealmURL}Pet/mango`;
+			let targetStackIndex = 99;
+			let sourceCard = await getService("store").get(sourceCardUrl);
+			try {
+				await copyCardToStackCommand.execute({
+					sourceCard,
+					targetStackIndex
+				});
+				assert.ok(false, "should have thrown an error");
+			} catch (error) {
+				assert.ok(error instanceof Error, "throws an error");
+				assert.true(error.message.includes("Cannot find topmost card in target stack"), "error message mentions missing stack");
+			}
+		});
+	});
+});
+//#endregion

package/bundled-test-harness/assets/copy-file-to-realm-test-FPY-6Ddm.js

@@ -0,0 +1,148 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as CopyFileToRealmTool } from "./copy-file-to-realm-_zLGtK4w.js";
+import { t as ShowFileTool } from "./show-file-DpZ0VqpD.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, 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/copy-file-to-realm-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+(0, import_qunit.module)("Integration | tools | copy-file-to-realm", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL, testRealm2URL]
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => {
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: testRealmURL,
+				contents: {
+					"hello.txt": "Hello World!",
+					"nested/deep.txt": "Nested file content"
+				}
+			});
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: testRealm2URL,
+				contents: { "existing.txt": "I already exist" }
+			});
+		});
+		let realmService = getService("realm");
+		await realmService.login(testRealmURL);
+		await realmService.login(testRealm2URL);
+	});
+	(0, import_qunit.test)("copies file to target realm", async function(assert) {
+		let result = await new CopyFileToRealmTool(getService("tool-service").toolContext).execute({
+			sourceFileIdentifier: `${testRealmURL}hello.txt`,
+			targetRealm: testRealm2URL
+		});
+		assert.ok(result.newFileIdentifier, "new file URL is returned");
+		assert.true(result.newFileIdentifier.startsWith(testRealm2URL), "new file is in target realm");
+		let copied = await getService("card-service").getSource(new URL(result.newFileIdentifier));
+		assert.strictEqual(copied.status, 200, "copied file exists");
+		assert.strictEqual(copied.content, "Hello World!", "content matches");
+	});
+	(0, import_qunit.test)("handles filename conflicts by creating non-conflicting name", async function(assert) {
+		let copyFileCommand = new CopyFileToRealmTool(getService("tool-service").toolContext);
+		await copyFileCommand.execute({
+			sourceFileIdentifier: `${testRealmURL}hello.txt`,
+			targetRealm: testRealm2URL
+		});
+		let result = await copyFileCommand.execute({
+			sourceFileIdentifier: `${testRealmURL}hello.txt`,
+			targetRealm: testRealm2URL
+		});
+		assert.ok(result.newFileIdentifier, "new file URL is returned");
+		assert.true(result.newFileIdentifier.startsWith(testRealm2URL), "new file is in target realm");
+		assert.notStrictEqual(result.newFileIdentifier, `${testRealm2URL}hello.txt`, "file URL is different from the original (conflict resolved)");
+		let copied = await getService("card-service").getSource(new URL(result.newFileIdentifier));
+		assert.strictEqual(copied.status, 200, "copied file exists");
+		assert.strictEqual(copied.content, "Hello World!", "content matches");
+	});
+	(0, import_qunit.test)("after copying, show file command switches to code submode with correct file URL", async function(assert) {
+		let toolService = getService("tool-service");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		operatorModeStateService.restore({
+			stacks: [[]],
+			submode: "interact"
+		});
+		let result = await new CopyFileToRealmTool(toolService.toolContext).execute({
+			sourceFileIdentifier: `${testRealmURL}hello.txt`,
+			targetRealm: testRealm2URL
+		});
+		assert.ok(result.newFileIdentifier, "new file URL is returned");
+		await new ShowFileTool(toolService.toolContext).execute({ fileIdentifier: result.newFileIdentifier });
+		assert.strictEqual(operatorModeStateService.state?.submode, "code", "submode is switched to code");
+		assert.strictEqual(operatorModeStateService.state?.codePath, result.newFileIdentifier, "code path is set to the copied file URL");
+	});
+	(0, import_qunit.test)("show file command opens a prefix-form file identifier", async function(assert) {
+		let toolService = getService("tool-service");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let { virtualNetwork } = getService("network");
+		let testRealmPrefix = "@test/show-realm/";
+		virtualNetwork.addRealmMapping(testRealmPrefix, testRealmURL);
+		try {
+			operatorModeStateService.restore({
+				stacks: [[]],
+				submode: "interact"
+			});
+			await new ShowFileTool(toolService.toolContext).execute({ fileIdentifier: `${testRealmPrefix}hello.txt` });
+			assert.strictEqual(operatorModeStateService.state?.submode, "code", "submode is switched to code");
+			let codePath = operatorModeStateService.state?.codePath;
+			assert.strictEqual(codePath ? virtualNetwork.toURL(codePath).href : void 0, `${testRealmURL}hello.txt`, "code path is the file the prefix-form identifier names");
+		} finally {
+			await operatorModeStateService.updateCodePath(null);
+			virtualNetwork.removeRealmMapping(testRealmPrefix);
+		}
+	});
+	(0, import_qunit.test)("copies a file named by prefix-form identifiers", async function(assert) {
+		let toolService = getService("tool-service");
+		let { virtualNetwork } = getService("network");
+		let sourcePrefix = "@test/copy-source/";
+		let targetPrefix = "@test/copy-target/";
+		virtualNetwork.addRealmMapping(sourcePrefix, testRealmURL);
+		virtualNetwork.addRealmMapping(targetPrefix, testRealm2URL);
+		try {
+			let result = await new CopyFileToRealmTool(toolService.toolContext).execute({
+				sourceFileIdentifier: `${sourcePrefix}hello.txt`,
+				targetRealm: targetPrefix
+			});
+			assert.strictEqual(result.newFileIdentifier, `${targetPrefix}hello.txt`, "the new file identifier keeps the prefix form");
+			let response = await fetch(new URL("hello.txt", testRealm2URL));
+			assert.strictEqual(response.status, 200, "copied file exists");
+			assert.strictEqual(await response.text(), "Hello World!", "content matches");
+		} finally {
+			virtualNetwork.removeRealmMapping(sourcePrefix);
+			virtualNetwork.removeRealmMapping(targetPrefix);
+		}
+	});
+	(0, import_qunit.test)("refuses a source identifier that names a directory", async function(assert) {
+		let toolService = getService("tool-service");
+		await assert.rejects(new CopyFileToRealmTool(toolService.toolContext).execute({
+			sourceFileIdentifier: `${testRealmURL}nested/`,
+			targetRealm: testRealm2URL
+		}), /does not name a file/);
+	});
+	(0, import_qunit.test)("errors when user does not have write permissions to target realm", async function(assert) {
+		let copyFileCommand = new CopyFileToRealmTool(getService("tool-service").toolContext);
+		let realmService = getService("realm");
+		realmService.logout();
+		await realmService.login(testRealmURL);
+		try {
+			await copyFileCommand.execute({
+				sourceFileIdentifier: `${testRealmURL}hello.txt`,
+				targetRealm: testRealm2URL
+			});
+			assert.ok(false, "should have thrown an error");
+		} catch (error) {
+			assert.ok(error instanceof Error, "throws an error");
+			assert.strictEqual(error.message, `Do not have write permissions to ${testRealm2URL}`, "error message indicates write permission issue");
+		}
+	});
+});
+//#endregion