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

package/bundled-test-harness/assets/convert-to-class-name-test-CX21VRzM.js

@@ -0,0 +1,17 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as convertToClassName } from "./create-file-modal-_y7nscSl.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+//#region tests/unit/convert-to-class-name-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Unit | convertToClassName", function() {
+	(0, import_qunit.test)("it removes invalid characters and provides a fallback", function(assert) {
+		assert.strictEqual(convertToClassName("hey"), "Hey");
+		assert.strictEqual(convertToClassName("hey there"), "HeyThere");
+		assert.strictEqual(convertToClassName("hey!"), "Hey");
+		assert.strictEqual(convertToClassName("hé"), "Hé");
+		assert.strictEqual(convertToClassName("hey 😀"), "Hey");
+		assert.strictEqual(convertToClassName("123hey"), "Hey");
+		assert.strictEqual(convertToClassName("123"), "Class123");
+	});
+});
+//#endregion

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

@@ -0,0 +1,291 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Ai as realmURL, Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
+import { t as CopyAndEditCommand } from "./copy-and-edit-B8M2rwoL.js";
+import { t as StackItem } from "./stack-item-Bn9IwoUX.js";
+import { A as settled } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/integration/commands/copy-and-edit-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var otherRealmURL = "http://other-realm/test2/";
+(0, import_qunit.module)("Integration | commands | 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 "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/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 "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/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: "https://cardstack.com/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 "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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 commandService = getService("command-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 CopyAndEditCommand(commandService.commandContext).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-LWbugEPe.js

@@ -0,0 +1,156 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Ai as realmURL, Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
+import { t as CopyCardToRealmCommand } from "./copy-card-JGCXNcjb.js";
+import { t as CopyCardToStackCommand } from "./copy-card-to-stack-Cnj8p8tc.js";
+import { t as StackItem } from "./stack-item-Bn9IwoUX.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/integration/commands/copy-card-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+(0, import_qunit.module)("Integration | commands | 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 "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/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: "https://cardstack.com/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)("CopyCardToRealmCommand", function() {
+		(0, import_qunit.test)("copies card to target realm", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmCommand(getService("command-service").commandContext);
+			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)("errors when user does not have write permissions to target realm", async function(assert) {
+			let copyCardCommand = new CopyCardToRealmCommand(getService("command-service").commandContext);
+			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)("CopyCardToStackCommand", function() {
+		(0, import_qunit.test)("copies card to stack when valid targetStackIndex is provided", async function(assert) {
+			let copyCardToStackCommand = new CopyCardToStackCommand(getService("command-service").commandContext);
+			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)("errors when targetStackIndex does not exist", async function(assert) {
+			let copyCardToStackCommand = new CopyCardToStackCommand(getService("command-service").commandContext);
+			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-BS25EUGV.js

@@ -0,0 +1,99 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
+import { r as CopyFileToRealmCommand, t as ShowFileCommand } from "./show-file-CyRiY_6z.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/integration/commands/copy-file-to-realm-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+(0, import_qunit.module)("Integration | commands | 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 CopyFileToRealmCommand(getService("command-service").commandContext).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 CopyFileToRealmCommand(getService("command-service").commandContext);
+		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 commandService = getService("command-service");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		operatorModeStateService.restore({
+			stacks: [[]],
+			submode: "interact"
+		});
+		let result = await new CopyFileToRealmCommand(commandService.commandContext).execute({
+			sourceFileIdentifier: `${testRealmURL}hello.txt`,
+			targetRealm: testRealm2URL
+		});
+		assert.ok(result.newFileIdentifier, "new file URL is returned");
+		await new ShowFileCommand(commandService.commandContext).execute({ fileIdentifier: result.newFileIdentifier });
+		assert.strictEqual(operatorModeStateService.state?.submode, "code", "submode is switched to code");
+		assert.strictEqual(operatorModeStateService.state?.codePath?.href, result.newFileIdentifier, "code path is set to the copied file URL");
+	});
+	(0, import_qunit.test)("errors when user does not have write permissions to target realm", async function(assert) {
+		let copyFileCommand = new CopyFileToRealmCommand(getService("command-service").commandContext);
+		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

package/bundled-test-harness/assets/copy-source-test-Dh33cqM8.js

@@ -0,0 +1,56 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Xn as testRealmInfo, Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
+import { t as getOwner } from "./owner-CqZ4C0QN.js";
+import { t as CopySourceCommand } from "./copy-source-CSrG5lS7.js";
+import { t as RealmService } from "./realm-DhUCLR5r.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/integration/commands/copy-source-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var fetch;
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | commands | copy-source", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+		fetch = getService("network").fetch;
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: { "person.gts": `
+          import { contains, field, Component, CardDef } from "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/base/string";
+          export class Person extends CardDef {
+            static displayName = 'Person';
+            @field firstName = contains(StringField);
+          }
+        ` }
+		}));
+	});
+	(0, import_qunit.test)("able to copy source or file", async function(assert) {
+		let copySourceCommand = new CopySourceCommand(getService("command-service").commandContext);
+		const originSourceIdentifier = testRealmURL + "person.gts";
+		const destinationSourceIdentifier = testRealmURL + "person-copy.gts";
+		await copySourceCommand.execute({
+			originSourceIdentifier,
+			destinationSourceIdentifier
+		});
+		let personContent = await (await fetch(new URL(originSourceIdentifier))).text();
+		let personCopyContent = await (await fetch(new URL(destinationSourceIdentifier))).text();
+		assert.strictEqual(personCopyContent, personContent);
+	});
+});
+//#endregion