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

package/bundled-realms/pretui/pretui-css.gts

@@ -64,7 +64,9 @@
 //   tooltip 80   a tooltip describes whatever is under the pointer, and that
 //                may be an item inside a dropdown or a popover. It is small,
 //                transient and non-interactive, so nothing is lost by it
-//                being the highest non-modal tier.
+//                being the highest non-modal tier. FALLBACK ONLY: Tooltip is
+//                a manual popover in the top layer, so an open tip paints
+//                over the Toaster too, and nothing reads this token.
 //   dialog  90   Dialog and Drawer. FALLBACK ONLY: both use native
 //                `<dialog>` + `showModal()`, which promotes them to the top
 //                layer, above every z-index on the page regardless of value.
@@ -75,7 +77,9 @@
 //                modal — so it is the only tier deliberately above `dialog`.
 //                Toaster's fixed region and SkipLink take it; a bare Toast is
 //                in flow and takes no tier, so whatever positions one owns
-//                its z-index.
+//                its z-index. A z-index can't rise above the top layer, so
+//                Dialog, Drawer, CommandPalette and an open Tooltip still
+//                paint over the Toaster.
 //
 // The numbers are gapped so a host can interleave its own chrome (a global
 // nav at 65, an assistant panel at 85) without editing Pretui.

package/bundled-realms/pretui/theme-scoped-css.gts

@@ -0,0 +1,262 @@
+// Pretui — a Theme card's stylesheet, scoped to one element. `themeScope`
+// derives the `data-boxel-theme-scope` value and `themeScopedCss` emits the
+// rules for it. They are the Pret UI counterparts of the same-named exports
+// of `@cardstack/boxel-ui/helpers` (ADR 009 §1.3) and keep their signatures
+// and their output. That equality carries weight: base's field-component
+// mints a card's scope with boxel-ui's copy, so a ThemeFrame previewing the
+// card's own theme mints the same scope here, and each stylesheet matches
+// both elements. Byte-identical, the two are harmless duplicates; any
+// difference would let one copy restyle the other's element. The host's
+// theme-scoped-css-parity test fails when the copies disagree.
+import { type SafeString, htmlSafe } from '@ember/template';
+import { sanitizeHtml } from '@cardstack/runtime-common';
+
+// ── Reading a theme's variables ──────────────────────────────────────────
+// A Theme card's `cssVariables` is CSS text: a `:root { … }` block, an
+// optional `.dark { … }` block, or bare declarations with no selector at all.
+// The parse below reads those blocks into per-selector maps of custom
+// properties, sorted by name so equal themes emit equal text.
+const COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
+const BLOCK_PATTERN = /(.*?)\{([\s\S]*?)\}/g;
+const PROPERTY_PATTERN = /^[a-z\d-]+$/i;
+const CUSTOM_PROPERTY_PATTERN = /^--[a-z\d_-]+$/i;
+
+type CssRuleMap = Map<string, string>;
+type CssGroups = Map<string, CssRuleMap>;
+
+// Trims a value and drops a trailing semicolon. Rejects values containing
+// CSS block delimiters: these values are serialized into <style>
+// declaration blocks, where an embedded `}` would close the scoped block and
+// let the remainder inject page-wide rules.
+function normalizeCssValue(value?: string | null): string | undefined {
+  if (value == null) {
+    return;
+  }
+  let normalized = `${value}`.trim().replace(/[;\s]+$/, '');
+  if (!normalized || /[{}]/.test(normalized)) {
+    return;
+  }
+  return normalized;
+}
+
+// Collapses the selector aliases `root` and `dark` into their canonical form.
+function normalizeSelector(selector?: string | null): string | undefined {
+  let trimmed = selector?.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed === 'root') {
+    return ':root';
+  }
+  if (trimmed === 'dark') {
+    return '.dark';
+  }
+  return trimmed;
+}
+
+// Turns a CSS declaration block into a property-value map.
+function parseCssDeclarations(rules?: string): CssRuleMap | undefined {
+  if (!rules?.trim()) {
+    return;
+  }
+  let entries: Array<[string, string]> = [];
+  for (let declaration of rules
+    .split(';')
+    .map((rule) => rule.replace(/[\r\n]+/g, ' ').trim())
+    .map((rule) => rule.replace(/\s{2,}/g, ' '))
+    .filter(Boolean)) {
+    let colonIndex = declaration.indexOf(':');
+    if (colonIndex <= 0) {
+      continue;
+    }
+    let property = declaration.slice(0, colonIndex).trim();
+    let value = normalizeCssValue(declaration.slice(colonIndex + 1));
+    let valid = property.startsWith('--')
+      ? CUSTOM_PROPERTY_PATTERN.test(property)
+      : PROPERTY_PATTERN.test(property);
+    if (!property || !valid || !value) {
+      continue;
+    }
+    entries.push([property, value]);
+  }
+  entries.sort(([a], [b]) => a.localeCompare(b));
+  let cssMap: CssRuleMap = new Map(entries);
+  return cssMap.size ? cssMap : undefined;
+}
+
+// Groups selectors and their declaration maps from raw CSS text. Text with
+// no block at all is read as root declarations.
+function parseCssGroups(cssString?: string | null): CssGroups | undefined {
+  let sanitized = cssString
+    ? cssString.replace(COMMENT_PATTERN, ' ').trim()
+    : '';
+  if (!sanitized) {
+    return;
+  }
+  let groups: CssGroups = new Map();
+  for (let match of sanitized.matchAll(BLOCK_PATTERN)) {
+    let selectorSource = match[1]?.trim();
+    let selector = selectorSource
+      ? (normalizeSelector(selectorSource) ?? ':root')
+      : ':root';
+    let rules = parseCssDeclarations(match[2]);
+    if (!rules?.size) {
+      continue;
+    }
+    let existing = groups.get(selector) ?? new Map();
+    for (let [property, value] of rules) {
+      existing.set(property, value);
+    }
+    groups.set(selector, existing);
+  }
+  if (!groups.size) {
+    let fallbackRules = parseCssDeclarations(sanitized);
+    if (fallbackRules?.size) {
+      groups.set(':root', fallbackRules);
+    }
+  }
+  return groups.size ? groups : undefined;
+}
+
+/**
+ * The custom properties a theme declares under `selector` (`:root` by
+ * default), as a `--name: value; --other: value` string, or undefined when
+ * it declares none there.
+ */
+export function extractCssVariables(
+  cssString?: string | null,
+  selector = ':root',
+): string | undefined {
+  let groups = parseCssGroups(cssString);
+  if (!groups?.size) {
+    return;
+  }
+  let rules = groups.get(normalizeSelector(selector) ?? ':root');
+  if (!rules?.size) {
+    return;
+  }
+  return [...rules.entries()]
+    .filter(([property]) => property.startsWith('--'))
+    .map(([property, value]) => `${property}: ${value}`)
+    .join('; ');
+}
+
+// ── Scoping the stylesheet ───────────────────────────────────────────────
+// Declarations are emitted inside a <style> block: sanitizeHtml strips markup
+// (e.g. a `</style>` breakout) but knows nothing about CSS, so also drop block
+// delimiters — an embedded `}` would close the scoped block and turn the rest
+// of the value into page-wide rules.
+function sanitizeDeclarations(declarations: string): string {
+  return sanitizeHtml(declarations).replace(/[{}]/g, '');
+}
+
+function fnv1a(text: string, seed: number): string {
+  let hash = seed;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+// 64-bit stable fingerprint of the theme CSS for scope values: two 32-bit
+// FNV-1a passes with different seeds (the standard offset basis, then the
+// upper half of the 64-bit offset basis), hex-encoded fixed-width. Not
+// cryptographic, but wide enough that two versions of a theme colliding —
+// which would let their scoped rules restyle each other's cards — is not a
+// practical concern, where a single 32-bit pass would leave that to chance.
+function fingerprint(text: string): string {
+  return fnv1a(text, 0x811c9dc5) + fnv1a(text, 0xcbf29ce4);
+}
+
+/**
+ * Derives a `data-boxel-theme-scope` value from a theme's identity plus a
+ * fingerprint of its CSS. Every element sharing a theme gets the same scope,
+ * so their emitted stylesheets are byte-identical — harmless as duplicate
+ * rules, and dedupable by consumers. The content hash keeps scopes from
+ * *different versions* of a theme distinct: prerendered fragments are cached
+ * at different times, so a page can mix a card captured before a theme edit
+ * with one captured after, and because the scoped rules are page-global,
+ * equal scopes with unequal declarations would restyle each other's cards.
+ */
+export function themeScope(
+  themeId: string | null | undefined,
+  cssVariables: string | null | undefined,
+): string | undefined {
+  if (!themeId || !cssVariables) {
+    return undefined;
+  }
+  return `${themeId}-${fingerprint(cssVariables)}`;
+}
+
+/**
+ * Builds a theme stylesheet scoped to `scope` (a `data-boxel-theme-scope`
+ * value). The theme's `:root` variables apply by default; its `.dark`
+ * variables take over via a CSS style container query on
+ * `--boxel-color-scheme` — an inherited signal the theme (theme.css) sets on
+ * each `[data-theme]` element. Because that signal inherits, the query
+ * resolves to the *nearest* ancestor's color scheme, so per-subtree overrides
+ * (dark pages, light islands, nested) all work with no JS and no !important.
+ * Scheme switches stamped *inside* the scope get the same palettes through
+ * descendant rules instead (see below). A theme with no `.dark` block simply
+ * keeps its light values.
+ */
+export function themeScopedCss(
+  scope?: string,
+  cssVariables?: string | null,
+): SafeString {
+  if (!scope || !cssVariables) {
+    return htmlSafe('');
+  }
+  let light = extractCssVariables(cssVariables, ':root');
+  let dark = extractCssVariables(cssVariables, '.dark');
+  // Scopes are arbitrary strings (typically card URLs); escape the characters
+  // that could break out of the double-quoted attribute selector (`\`, `"`),
+  // terminate the surrounding <style> element once this markup is serialized
+  // and re-parsed (`<`, as in `</style`), or are invalid in a CSS string
+  // (control characters). CSS hex escapes keep the selector matching the
+  // literal attribute value.
+  // eslint-disable-next-line no-control-regex
+  let escapedScope = scope.replace(/[\\"<\u0000-\u001f]/g, (char) =>
+    char === '\\' || char === '"'
+      ? `\\${char}`
+      : `\\${char.codePointAt(0)!.toString(16)} `,
+  );
+  let selector = `[data-boxel-theme-scope="${escapedScope}"]`;
+  let css = '';
+  if (light) {
+    css += `${selector}{${sanitizeDeclarations(light)}}`;
+  }
+  if (dark) {
+    css += `@container style(--boxel-color-scheme: dark){${selector}{${sanitizeDeclarations(dark)}}}`;
+  }
+  // Scheme islands the scoped template stamps (`data-theme` or `.dark` on an
+  // element inside the container) sit below the scope element, so the
+  // container query above — which resolves against the scope's ancestors —
+  // never sees them, while theme.css's own scheme blocks do and re-declare the
+  // whole contract there. Re-emit the palettes on those descendants so the
+  // theme wins there too: `:scope` lifts specificity above theme.css's
+  // single-selector blocks, which still fill the tokens the theme omits.
+  // A dark island gets the root declarations first and the dark ones on top,
+  // the same result the scope root has under an ambient dark scheme, where a
+  // token the theme defines only at the root keeps its value. The light rule
+  // matters as well, or a light island inside a dark subtree would fall back
+  // to Boxel's light defaults. The dark rule comes last so an element carrying
+  // both markers resolves dark, as it does in theme.css. The `to` limit stops
+  // at a nested themed card's boundary so this theme never leaks into islands
+  // the nested card stamps: its own stylesheet covers those, or leaves them to
+  // the theme.css defaults.
+  let lightDeclarations = light ? sanitizeDeclarations(light) : '';
+  let darkDeclarations = dark ? sanitizeDeclarations(dark) : '';
+  let islands = '';
+  if (lightDeclarations) {
+    islands += `:scope :is([data-theme="light"],.dark,[data-theme="dark"]){${lightDeclarations}}`;
+  }
+  if (darkDeclarations) {
+    islands += `:scope :is(.dark,[data-theme="dark"]){${darkDeclarations}}`;
+  }
+  if (islands) {
+    css += `@scope (${selector}) to ([data-boxel-theme-scope]){${islands}}`;
+  }
+  return htmlSafe(css);
+}

package/bundled-test-harness/assets/account-switch-failed-test-DwAZq6Sc.js

@@ -0,0 +1,45 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { d as click, h as render } from "./dist-BOAdzfkP.js";
+import { t as AccountSwitchFailed } from "./account-switch-failed-CrtFXZ0y.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/integration/components/matrix/account-switch-failed-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var noop = () => {};
+(0, import_qunit.module)("Integration | Component | matrix/account-switch-failed", function(hooks) {
+	setupRenderingTest(hooks);
+	(0, import_qunit.test)("renders the failure message and a back-to-home link", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "TU0JbnOZ",
+			"block": "[[[8,[32,0],null,[[\"@onBackToHome\"],[[32,1]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/matrix/account-switch-failed-test.gts",
+			"scope": () => [AccountSwitchFailed, noop],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-account-switch-failed]").exists();
+		assert.dom("[data-test-account-switch-failed] h1").hasText("Couldn't switch accounts", "the title is the heading");
+		assert.dom("[data-test-account-switch-failed]").containsText("haven't been signed out");
+		assert.dom("[data-test-account-switch-back-home]").hasText("Back to home");
+	});
+	(0, import_qunit.test)("invokes onBackToHome when the link is clicked", async function(assert) {
+		let calls = 0;
+		let onBackToHome = () => {
+			calls++;
+		};
+		await render(setComponentTemplate(templateFactory({
+			"id": "TU0JbnOZ",
+			"block": "[[[8,[32,0],null,[[\"@onBackToHome\"],[[32,1]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/matrix/account-switch-failed-test.gts",
+			"scope": () => [AccountSwitchFailed, onBackToHome],
+			"isStrictMode": true
+		}), templateOnly()));
+		await click("[data-test-account-switch-back-home]");
+		assert.strictEqual(calls, 1, "onBackToHome fired exactly once");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/adapter-C_6pnsx1.js

@@ -0,0 +1,2 @@
+import { Dt as TestRealmAdapter } from "./mock-matrix-FjsXmU7-.js";
+export { TestRealmAdapter };

package/bundled-test-harness/assets/add-field-to-card-definition-tool-test-zMYtJWBv.js

@@ -0,0 +1,112 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as AddFieldToCardDefinitionTool } from "./add-field-to-card-definition-Crr7-DHH.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/add-field-to-card-definition-tool-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 | add-field-to-card-definition", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "person.gts": `
+          import { contains, field, Component, CardDef } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+          export class Person extends CardDef {
+            static displayName = 'Person';
+            @field firstName = contains(StringField);
+          }
+        ` },
+			realmURL: "http://test-realm/test/"
+		}));
+	});
+	(0, import_qunit.test)("adds a field to a card definition", async function(assert) {
+		let toolService = getService("tool-service");
+		let cardService = getService("card-service");
+		await new AddFieldToCardDefinitionTool(toolService.toolContext).execute({
+			cardDefinitionToModify: {
+				module: rri("http://test-realm/test/person"),
+				name: "Person"
+			},
+			fieldName: "lastName",
+			fieldDefinitionType: "field",
+			fieldRef: {
+				module: rri("@cardstack/base/string"),
+				name: "default"
+			},
+			fieldType: "contains"
+		});
+		let response = (await cardService.getSource(new URL("person.gts", testRealmURL))).content;
+		assert.strictEqual(response, `
+          import { contains, field, Component, CardDef } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+          export class Person extends CardDef {
+            static displayName = 'Person';
+            @field firstName = contains(StringField);
+            @field lastName = contains(StringField);
+          }
+        `, "lastName field was added to the card definition");
+	});
+	(0, import_qunit.test)("can add a computed field", async function(assert) {
+		let toolService = getService("tool-service");
+		let cardService = getService("card-service");
+		await new AddFieldToCardDefinitionTool(toolService.toolContext).execute({
+			cardDefinitionToModify: {
+				module: rri("http://test-realm/test/person"),
+				name: "Person"
+			},
+			fieldName: "rapName",
+			fieldDefinitionType: "field",
+			fieldType: "contains",
+			fieldRef: {
+				module: rri("@cardstack/base/string"),
+				name: "default"
+			},
+			incomingRelativeTo: void 0,
+			outgoingRelativeTo: void 0,
+			outgoingRealmURL: void 0,
+			computedFieldFunctionSourceCode: `
+          function () {
+            let prefix = this.firstName.length > 5 ? 'Big' : 'Lil';
+            let nickname = this.firstName.toUpperCase();
+            return \`\${prefix} \${nickname}\`;
+          }`
+		});
+		let response = (await cardService.getSource(new URL("person.gts", testRealmURL))).content;
+		assert.strictEqual(response, `
+          import { contains, field, Component, CardDef } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/base/string";
+          export class Person extends CardDef {
+            static displayName = 'Person';
+            @field firstName = contains(StringField);
+            @field rapName = contains(StringField, {
+              computeVia: function () {
+                let prefix = this.firstName.length > 5 ? 'Big' : 'Lil';
+                let nickname = this.firstName.toUpperCase();
+                return \`\${prefix} \${nickname}\`;
+              }
+            });
+          }
+        `, "computed field was added to the card definition");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/ai-assistant-create-workspace-test-CwhAV-Ow.js

@@ -0,0 +1,130 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Jr as buildCommandFunctionNameFromResolvedRef, Kn as APP_BOXEL_MESSAGE_MSGTYPE, ar as APP_BOXEL_TOOL_REQUESTS_KEY, sr as APP_BOXEL_TOOL_RESULT_REL_TYPE } from "./runtime-common-BTaLJEw-.js";
+import { q as skillCardRef } from "./constants-Icc0nFW-.js";
+import { M as waitUntil, d as click, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, L as setupRealmCacheTeardown, Y as waitForNewRoomSkillsLoaded, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, o as addSkillToAiAssistant, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/acceptance/ai-assistant-create-workspace-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var newRealmURL = "http://test-realm/testuser/team-space/";
+var cardsGridIndex = { data: {
+	type: "card",
+	meta: { adoptsFrom: {
+		module: "@cardstack/base/cards-grid",
+		name: "CardsGrid"
+	} }
+} };
+(0, import_qunit.module)("Acceptance | AI assistant creates a workspace", function(hooks) {
+	const createWorkspaceToolName = buildCommandFunctionNameFromResolvedRef({
+		module: "@cardstack/boxel-host/tools/create-workspace",
+		name: "default"
+	});
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL]
+	});
+	let { simulateRemoteMessage, getRoomIds, getRoomEvents } = mockMatrixUtils;
+	hooks.beforeEach(async function() {
+		setupUserSubscription();
+		setupAuthEndpoints();
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"index.json": cardsGridIndex,
+				"realm.json": realmConfigCardJSON({ name: "Test Workspace" }),
+				"Skill/workspace-admin.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use create-workspace when the user asks for a new workspace.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "@cardstack/boxel-host/tools/create-workspace"
+							},
+							requiresApproval: true
+						}],
+						cardTitle: "Workspace Admin",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} }
+			}
+		});
+		await setupAcceptanceTestRealm({
+			realmURL: newRealmURL,
+			mockMatrixUtils,
+			permissions: { "@testuser:localhost": [
+				"read",
+				"write",
+				"realm-owner"
+			] },
+			contents: {
+				"realm.json": realmConfigCardJSON({ name: "Team Space" }),
+				"index.json": cardsGridIndex
+			}
+		});
+	});
+	(0, import_qunit.test)("a create-workspace tool request creates and opens the workspace", async function(assert) {
+		let realmServer = getService("realm-server");
+		let createRealmCalls = [];
+		realmServer.createRealm = async (args) => {
+			createRealmCalls.push(args);
+			return new URL(newRealmURL);
+		};
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		let roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/workspace-admin`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Creating a workspace for the team",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "create-ws-1",
+				name: createWorkspaceToolName,
+				arguments: JSON.stringify({
+					description: "Create the Team Space workspace",
+					attributes: {
+						name: "Team Space",
+						endpoint: "team-space"
+					}
+				})
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]").containsText("Create the Team Space workspace");
+		assert.strictEqual(createRealmCalls.length, 0, "nothing is created before the user approves");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
+		assert.strictEqual(createRealmCalls.length, 1, "one realm is created");
+		assert.strictEqual(createRealmCalls[0].endpoint, "team-space");
+		assert.strictEqual(createRealmCalls[0].name, "Team Space");
+		await waitUntil(() => getRoomEvents(roomId).find((m) => m.content.msgtype === "app.boxel.toolResultWithNoOutput" && m.content.commandRequestId === "create-ws-1"), {
+			timeout: 5e3,
+			timeoutMessage: "timed out waiting for the tool result event"
+		});
+		let resultEvent = getRoomEvents(roomId).find((m) => m.content.msgtype === "app.boxel.toolResultWithNoOutput" && m.content.commandRequestId === "create-ws-1");
+		assert.strictEqual(resultEvent.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(resultEvent.content["m.relates_to"]?.key, "applied");
+		let resultData = JSON.parse(resultEvent.content.data);
+		assert.strictEqual(resultData.context?.realmUrl, newRealmURL, "the context sent with the result names the new workspace, so the assistant can report its URL");
+		assert.strictEqual(getService("operator-mode-state-service").state?.stacks[0]?.[0]?.id, `${newRealmURL}index`, "the new workspace is opened");
+		await click("[data-test-workspace-chooser-toggle]");
+		await waitFor("[data-test-workspace-list] [data-test-workspace=\"Team Space\"]");
+		assert.dom("[data-test-workspace-list] [data-test-workspace=\"Team Space\"]").exists("the new workspace appears on the dashboard");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/ai-assistant-panel-relogin-test-DNgclkGJ.js

@@ -0,0 +1,46 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { O as baseRealm } from "./constants-Icc0nFW-.js";
+import { M as waitUntil, T as settled } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/ai-assistant-panel-relogin-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | ai-assistant-panel | re-login after logout", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		});
+	});
+	(0, import_qunit.test)("panel re-enters a room after logout → re-login instead of spinning forever", async function(assert) {
+		let matrixService = getService("matrix-service");
+		let panelService = getService("ai-assistant-panel-service");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		let session = getService("session");
+		await matrixService.ready;
+		operatorModeStateService.openAiAssistant();
+		await panelService.openPanel();
+		await waitUntil(() => matrixService.currentRoomId, { timeout: 5e3 });
+		assert.ok(matrixService.currentRoomId, "a room is entered on initial login");
+		matrixService.resetState();
+		session.notifySessionEnded();
+		await settled();
+		assert.notOk(matrixService.currentRoomId, "logout clears the current room");
+		assert.true(panelService.isOpen, "the panel is still open after logout");
+		await matrixService.start();
+		await settled();
+		await waitUntil(() => matrixService.currentRoomId, { timeout: 5e3 });
+		assert.ok(matrixService.currentRoomId, "the panel re-enters a room after re-login");
+		assert.false(panelService.loadingRooms, "the panel is not stuck loading after re-login");
+	});
+});
+//#endregion