@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.13

package/bundled-types/host-tests/helpers/realm-server-mock/types.ts

@@ -0,0 +1,24 @@
+import type { RealmAction } from '@cardstack/runtime-common';
+
+export type EnsureSessionRoom = (
+  realmURL: string,
+  userId: string,
+) => Promise<void> | void;
+
+export type RealmServerMockState = {
+  handler: (req: Request) => Promise<Response | null>;
+  realmPermissions: Map<string, RealmAction[]>;
+  mountedVirtualNetwork?: unknown;
+  ensureSessionRoom?: EnsureSessionRoom;
+};
+
+export type RealmServerMockRouteHandler = (
+  req: Request,
+  url: URL,
+  state: RealmServerMockState,
+) => Promise<Response | null>;
+
+export type RealmServerMockRoute = {
+  path: string;
+  handler: RealmServerMockRouteHandler;
+};

package/bundled-types/host-tests/helpers/recent-files-cards.ts

@@ -0,0 +1,86 @@
+import window from 'ember-window-mock';
+
+import type { RecentFile } from '@cardstack/host/services/recent-files-service';
+import {
+  RecentFiles,
+  RecentCards,
+} from '@cardstack/host/utils/local-storage-keys';
+
+export function getRecentFileURL(recentFile: RecentFile) {
+  if (!recentFile) {
+    throw new Error(`recent file was not provided`);
+  }
+  return `${recentFile.realmURL}${recentFile.filePath}`;
+}
+
+export function assertRecentFileURLs(
+  assert: Assert,
+  recentFiles: RecentFile[],
+  fileURLs: string[],
+  message?: string,
+) {
+  assert.strictEqual(
+    recentFiles.length,
+    fileURLs.length,
+    'recent file count is correct',
+  );
+  recentFiles.map((recentFile, i) =>
+    assert.strictEqual(
+      getRecentFileURL(recentFile),
+      fileURLs[i],
+      message ?? `url is correct for recent file at index ${i}`,
+    ),
+  );
+}
+
+// direct manipulation of local storage:
+type RecentFiles =
+  | [string, string][]
+  | [string, string, { line: number; column: number } | null, number][];
+
+// RecentFiles
+export function getRecentFiles(): RecentFiles | null {
+  let files = window.localStorage.getItem(RecentFiles);
+  if (!files) {
+    return null;
+  }
+  return JSON.parse(files);
+}
+
+export function setRecentFiles(files: RecentFiles) {
+  // ensure deterministic ordering when explicit timestamps are not provided
+  let baseTimestamp = Date.now() + files.length;
+  let recentFiles = files.map(
+    ([realmURL, filePath, cursorPosition, timestamp], index) => [
+      realmURL,
+      filePath,
+      cursorPosition ?? null,
+      timestamp ?? baseTimestamp - index,
+    ],
+  );
+  window.localStorage.setItem(RecentFiles, JSON.stringify(recentFiles));
+}
+
+export function removeRecentFiles() {
+  window.localStorage.removeItem(RecentFiles);
+}
+
+// RecentCards
+export function getRecentCards():
+  | { cardId: string; timestamp?: number }[]
+  | null {
+  let cards = window.localStorage.getItem(RecentCards);
+  if (!cards) {
+    return null;
+  }
+  return JSON.parse(cards);
+}
+
+export function setRecentCards(cards: ([string, number] | [string])[]) {
+  let recentCards = cards.map(([cardId, timestamp]) => ({ cardId, timestamp }));
+  window.localStorage.setItem(RecentCards, JSON.stringify(recentCards));
+}
+
+export function removeRecentCards() {
+  window.localStorage.removeItem(RecentCards);
+}

package/bundled-types/host-tests/helpers/render-component.ts

@@ -0,0 +1,40 @@
+// @ts-ignore
+import { precompileTemplate } from '@ember/template-compilation';
+import { render, getContext } from '@ember/test-helpers';
+
+import type { Loader } from '@cardstack/runtime-common';
+import { baseRealm } from '@cardstack/runtime-common';
+
+import type {
+  BaseDef,
+  Format,
+  Field,
+} from 'https://cardstack.com/base/card-api';
+
+import type { ComponentLike } from '@glint/template';
+
+async function cardApi(
+  loader: Loader,
+): Promise<typeof import('https://cardstack.com/base/card-api')> {
+  return await loader.import(`${baseRealm.url}card-api`);
+}
+
+export async function renderComponent(C: ComponentLike, format?: Format) {
+  await render(
+    precompileTemplate(`<C @format={{format}} />`, {
+      strictMode: true,
+      scope: () => ({ C, format }),
+    }),
+  );
+}
+
+export async function renderCard(
+  loader: Loader,
+  card: BaseDef,
+  format: Format,
+  field?: Field,
+) {
+  let api = await cardApi(loader);
+  await renderComponent(api.getComponent(card, field), format);
+  return (getContext() as { element: Element }).element;
+}

package/bundled-types/host-tests/helpers/setup-qunit.js

@@ -0,0 +1,164 @@
+import { isDestroyed, isDestroying } from '@ember/destroyable';
+import { getApplication } from '@ember/test-helpers';
+import * as TestWaiters from '@ember/test-waiters';
+
+import * as QUnit from 'qunit';
+import { setup } from 'qunit-dom';
+
+import { useTestWaiters } from '@cardstack/runtime-common';
+
+export function setupQUnit() {
+  // ResizeObserver fires this when a callback causes a layout change that
+  // would trigger another notification in the same frame. The browser
+  // defers the second notification safely; the error itself is benign but
+  // QUnit picks it up via window.onerror and reports it as a global failure.
+  // We wrap window.onerror (rather than addEventListener) because window.onerror
+  // fires first; returning true suppresses the error before QUnit sees it.
+  const _originalOnError = window.onerror;
+  window.onerror = (message, ...args) => {
+    if (
+      message ===
+      'ResizeObserver loop completed with undelivered notifications.'
+    ) {
+      return true;
+    }
+    return _originalOnError ? _originalOnError(message, ...args) : false;
+  };
+
+  QUnit.dump.maxDepth = 20;
+  useTestWaiters(TestWaiters);
+  setup(QUnit.assert);
+  QUnit.config.autostart = false;
+
+  // Per-module memory delta probe — log each test file's contribution to
+  // retained memory, independent of where it falls in shard order. We GC
+  // at module boundaries so the start/end snapshots compare like-for-like.
+  //
+  // We run several gc() cycles with a microtask yield between each call so
+  // V8 can drain its FinalizationRegistry queue and finish generational
+  // sweeps between passes. Without the yield, finalizers are deferred until
+  // the next microtask checkpoint, so repeated synchronous gc() calls don't
+  // actually settle — prior-module garbage can reclaim mid-way through our
+  // window and produce negative "deltas" that aren't real.
+  //
+  // Uses QUnit.moduleStart/moduleDone (not QUnit.on('suiteStart')) because
+  // only the logging-callback API awaits async handlers. Nested modules
+  // are tracked with a simple depth counter so we only probe top-level ones.
+  let usedAtModuleStart = null;
+  let moduleDepth = 0;
+  async function settledGc() {
+    if (typeof globalThis.gc !== 'function') return;
+    for (let i = 0; i < 3; i++) {
+      globalThis.gc();
+      await new Promise((r) => setTimeout(r, 0));
+    }
+  }
+  QUnit.moduleStart(async () => {
+    moduleDepth++;
+    if (moduleDepth !== 1) return;
+    await settledGc();
+    try {
+      let pm = performance && performance.memory;
+      usedAtModuleStart = pm ? pm.usedJSHeapSize : null;
+    } catch (_) {
+      usedAtModuleStart = null;
+    }
+  });
+  QUnit.moduleDone(async (details) => {
+    if (moduleDepth === 1) {
+      await settledGc();
+      try {
+        let pm = performance && performance.memory;
+        if (pm) {
+          let used = pm.usedJSHeapSize;
+          let usedMB = (used / 1048576).toFixed(1);
+          let totalMB = (pm.totalJSHeapSize / 1048576).toFixed(1);
+          let deltaMB =
+            usedAtModuleStart != null
+              ? ((used - usedAtModuleStart) / 1048576).toFixed(1)
+              : 'na';
+          let tests = details.tests ? details.tests.length : 0;
+          console.log(
+            `MEMPROBE_FILE module=${JSON.stringify(details.name)} tests=${tests} used=${usedMB}MB total=${totalMB}MB delta=${deltaMB}MB`,
+          );
+        }
+      } catch (_) {
+        /* ignore */
+      }
+    }
+    moduleDepth--;
+  });
+
+  // After each test, force GC (via --expose-gc) so V8 can release
+  // per-test allocations before the next test starts. Without this, V8's
+  // opportunistic GC can't keep up and the heap drifts toward the 4GB
+  // ceiling in long shards. Every 10 tests we also log a memory line so
+  // regressions are visible in CI output.
+  //
+  // We also read App._applicationInstances.size directly from the Ember
+  // Application — any ApplicationInstance that didn't complete willDestroy
+  // stays in this Set and pins its Registry + template factories + Box trees.
+  // A healthy test suite should keep this at 0 between tests; a linear
+  // growth in `app_instances` means we have an ApplicationInstance-level leak.
+  let probeCount = 0;
+  QUnit.testDone(() => {
+    probeCount++;
+    // Sweep out ApplicationInstances whose willDestroy completed (isDestroyed
+    // is set) but where super.willDestroy() errored before _unwatchInstance
+    // could remove them from App._applicationInstances. Without this sweep,
+    // each leaked instance pins its Registry → template factories →
+    // FieldComponent closures → Box trees → ~7.5MB of base-realm module
+    // sources. Removing destroyed instances from the Set is provably safe
+    // (they're already in the DESTROYED state per @glimmer/destroyable).
+    try {
+      let app = getApplication && getApplication();
+      if (app && app._applicationInstances) {
+        for (let inst of app._applicationInstances) {
+          if (isDestroyed(inst)) {
+            app._applicationInstances.delete(inst);
+          }
+        }
+      }
+    } catch (_) {
+      /* ignore */
+    }
+    if (typeof globalThis.gc === 'function') {
+      globalThis.gc();
+      globalThis.gc();
+    }
+    if (probeCount % 10 === 0) {
+      let appInstances = -1;
+      let aliveInstances = -1;
+      let destroyingInstances = -1;
+      let destroyedInstances = -1;
+      try {
+        let app = getApplication && getApplication();
+        if (app && app._applicationInstances) {
+          appInstances = app._applicationInstances.size;
+          aliveInstances = 0;
+          destroyingInstances = 0;
+          destroyedInstances = 0;
+          for (let inst of app._applicationInstances) {
+            if (isDestroyed(inst)) destroyedInstances++;
+            else if (isDestroying(inst)) destroyingInstances++;
+            else aliveInstances++;
+          }
+        }
+      } catch (_) {
+        /* ignore */
+      }
+      try {
+        let pm = performance && performance.memory;
+        if (pm) {
+          let used = (pm.usedJSHeapSize / 1048576).toFixed(1);
+          let total = (pm.totalJSHeapSize / 1048576).toFixed(1);
+          console.log(
+            `MEMPROBE t=${probeCount} used=${used}MB total=${total}MB app_instances=${appInstances} alive=${aliveInstances} destroying=${destroyingInstances} destroyed=${destroyedInstances}`,
+          );
+        }
+      } catch (_) {
+        /* ignore */
+      }
+    }
+  });
+}

package/bundled-types/host-tests/helpers/setup.ts

@@ -0,0 +1,349 @@
+/* eslint-disable @cardstack/host/wrapped-setup-helpers-only */
+// This is the one place we allow these to be used directly.
+
+import { settled } from '@ember/test-helpers';
+
+import {
+  setupApplicationTest as emberSetupApplicationTest,
+  setupRenderingTest as emberSetupRenderingTest,
+} from 'ember-qunit';
+import window from 'ember-window-mock';
+import { setupWindowMock } from 'ember-window-mock/test-support';
+
+import { clearHtmlComponentCache } from '@cardstack/host/lib/html-component';
+import type ResetService from '@cardstack/host/services/reset';
+import { AiAssistantOpen } from '@cardstack/host/utils/local-storage-keys';
+
+import { clearRemoteRealmCache } from './realm-server-mock/routes';
+
+import { cleanupMonacoEditorModels } from './index';
+
+// Map of fetch calls currently in flight, keyed by a globally-unique per-call
+// id so overlapping identical requests each occupy their own slot, and so a
+// late `finally` from a prior test can never collide with the current test's
+// ids. The map reference is constant; we `clear()` it between tests rather
+// than reassigning, otherwise late-resolving fetches would mutate the next
+// test's tracking container. Snapshotted by the unhandled-rejection
+// diagnostics helper to surface what was outstanding when a rejection fired.
+const inFlightFetches = new Map<number, string>();
+let nextFetchId = 0;
+
+// Track the most recent failed fetches per test so a "Promise rejected during X"
+// failure (which surfaces the generic browser TypeError "A network error
+// occurred." with no URL) can be correlated with the actual request that blew
+// up. Each entry is `${method} ${url}: ${reason}`; cleared in beforeEach.
+//
+// Each fetch captures `currentTestEpoch` at start; on failure, we only push to
+// the buffer when the captured epoch still matches the current one. Without
+// that gate, a fetch from test N rejecting after test N+1's beforeEach has
+// cleared the buffer would repopulate it and misattribute URLs to N+1.
+const recentFailedFetches: string[] = [];
+const RECENT_FAILED_FETCHES_LIMIT = 20;
+let currentTestEpoch = 0;
+
+function setupFetchDebugging(hooks: NestedHooks) {
+  let originalFetch: typeof globalThis.fetch | undefined;
+  let wrappedFetch: typeof globalThis.fetch | undefined;
+
+  hooks.beforeEach(function () {
+    inFlightFetches.clear();
+    recentFailedFetches.length = 0;
+    currentTestEpoch++;
+    if (!globalThis.fetch) {
+      return;
+    }
+    originalFetch = globalThis.fetch;
+    let boundFetch = globalThis.fetch.bind(globalThis);
+    wrappedFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      let { method, url } = describeFetchRequest(input, init);
+      let id = nextFetchId++;
+      let epoch = currentTestEpoch;
+      inFlightFetches.set(id, `${method} ${url}`);
+      try {
+        return await boundFetch(input, init);
+      } catch (error) {
+        let reason = formatErrorForLog(error);
+        console.error(`[test-fetch] ${method} ${url} failed: ${reason}`);
+        rememberFailedFetch(epoch, method, url, reason);
+        throw error;
+      } finally {
+        inFlightFetches.delete(id);
+      }
+    };
+    globalThis.fetch = wrappedFetch;
+  });
+
+  hooks.afterEach(function () {
+    if (originalFetch && globalThis.fetch === wrappedFetch) {
+      globalThis.fetch = originalFetch;
+    }
+    originalFetch = undefined;
+    wrappedFetch = undefined;
+    inFlightFetches.clear();
+  });
+}
+
+function rememberFailedFetch(
+  epoch: number,
+  method: string,
+  url: string,
+  reason: string,
+) {
+  // Drop late rejections from a prior test — the buffer is per-test and would
+  // otherwise contaminate the next test's diagnostic output.
+  if (epoch !== currentTestEpoch) {
+    return;
+  }
+  recentFailedFetches.push(`${method} ${url}: ${reason}`);
+  if (recentFailedFetches.length > RECENT_FAILED_FETCHES_LIMIT) {
+    recentFailedFetches.splice(
+      0,
+      recentFailedFetches.length - RECENT_FAILED_FETCHES_LIMIT,
+    );
+  }
+}
+
+// Resolve the qunit runtime object (the one the qunit package installs on the
+// global) rather than the ES module namespace. Importing `import * as QUnit
+// from 'qunit'` produces a frozen module record where `onUncaughtException`
+// is a getter-only export — assignments throw `TypeError: Cannot set property
+// onUncaughtException of #<Object> which has only a getter`. The runtime
+// global is writable; `suspendGlobalErrorHook` (uncaught-exceptions.ts) reads
+// and reassigns it the same way.
+function getQUnitRuntime():
+  | { onUncaughtException?: (error: unknown) => void }
+  | undefined {
+  let q = (globalThis as { QUnit?: unknown }).QUnit;
+  return q && typeof q === 'object'
+    ? (q as { onUncaughtException?: (error: unknown) => void })
+    : undefined;
+}
+
+// surface unhandled rejections during tests with full stacks + in-flight URLs
+function setupUnhandledRejectionDiagnostics(hooks: NestedHooks) {
+  let handler: ((event: PromiseRejectionEvent) => void) | undefined;
+  let target: Window | undefined;
+  let originalOnUncaughtException:
+    | ((error: unknown) => void)
+    | undefined
+    | null;
+  let wrappedOnUncaughtException: ((error: unknown) => void) | undefined;
+
+  hooks.beforeEach(function () {
+    // Host tests run in the browser; if `window` is missing or doesn't expose
+    // an event listener API for some reason, skip rather than throw.
+    target =
+      typeof window !== 'undefined' &&
+      typeof window.addEventListener === 'function'
+        ? window
+        : undefined;
+    if (target) {
+      handler = (event: PromiseRejectionEvent) => {
+        // Observation only — do NOT call event.preventDefault(). QUnit's own
+        // unhandled-rejection handling must still run and fail the test.
+        logRejectionDiagnostics(
+          '[test-unhandled-rejection]',
+          formatRejectionReason(event.reason),
+        );
+      };
+      target.addEventListener('unhandledrejection', handler);
+    }
+
+    // Wrap QUnit.onUncaughtException so QUnit-handled rejections (e.g.,
+    // "Promise rejected during X: A network error occurred." — which propagates
+    // via the test's awaited promise chain rather than firing a global
+    // `unhandledrejection` event) also dump in-flight + recently-failed fetch
+    // context. Without this hook, the failure message exposes only the generic
+    // browser TypeError with no URL, making field-playground / code-submode
+    // network-error flakes effectively unattributable.
+    let qunitGlobal = getQUnitRuntime();
+    if (qunitGlobal) {
+      originalOnUncaughtException = qunitGlobal.onUncaughtException;
+      wrappedOnUncaughtException = (error: unknown) => {
+        try {
+          logRejectionDiagnostics(
+            '[test-qunit-uncaught]',
+            formatRejectionReason(error),
+          );
+        } catch (_e) {
+          // never let diagnostic logging swallow the original failure
+        }
+        if (typeof originalOnUncaughtException === 'function') {
+          // Preserve QUnit as the receiver in case any future hook reads
+          // `this` — current QUnit 2.x reads `config` from closure scope, but
+          // calling via `.call(qunitGlobal, ...)` keeps the wrapper's behavior
+          // identical to the unwrapped path regardless.
+          originalOnUncaughtException.call(qunitGlobal, error);
+        }
+      };
+      qunitGlobal.onUncaughtException = wrappedOnUncaughtException;
+    }
+  });
+
+  hooks.afterEach(function () {
+    if (target && handler) {
+      target.removeEventListener('unhandledrejection', handler);
+    }
+    handler = undefined;
+    target = undefined;
+
+    let qunitGlobal = getQUnitRuntime();
+    if (
+      qunitGlobal &&
+      qunitGlobal.onUncaughtException === wrappedOnUncaughtException
+    ) {
+      qunitGlobal.onUncaughtException = originalOnUncaughtException as
+        | ((error: unknown) => void)
+        | undefined;
+    }
+    wrappedOnUncaughtException = undefined;
+    originalOnUncaughtException = undefined;
+  });
+}
+
+function logRejectionDiagnostics(prefix: string, formattedReason: string) {
+  let inFlightSnapshot = Array.from(inFlightFetches.values());
+  let recent = recentFailedFetches.slice();
+  console.error(
+    [
+      prefix,
+      formattedReason,
+      inFlightSnapshot.length
+        ? `in-flight fetches at rejection time (${inFlightSnapshot.length}):\n  ${inFlightSnapshot.join('\n  ')}`
+        : 'in-flight fetches at rejection time: <none>',
+      recent.length
+        ? `recent failed fetches this test (${recent.length}):\n  ${recent.join('\n  ')}`
+        : 'recent failed fetches this test: <none>',
+    ].join('\n'),
+  );
+}
+
+function formatRejectionReason(reason: unknown): string {
+  let lines: string[] = [];
+  let seen = new Set<unknown>();
+  let current: unknown = reason;
+  let depth = 0;
+  while (current && !seen.has(current) && depth < 5) {
+    seen.add(current);
+    let prefix = depth === 0 ? 'reason' : `cause[${depth}]`;
+    if (current instanceof Error) {
+      let header = current.name
+        ? `${current.name}: ${current.message}`
+        : current.message;
+      let stack = current.stack?.trim();
+      lines.push(`${prefix}: ${header}`);
+      if (stack) {
+        lines.push(stack);
+      }
+      current = (current as { cause?: unknown }).cause;
+    } else if (typeof current === 'string') {
+      lines.push(`${prefix}: ${current}`);
+      current = undefined;
+    } else {
+      try {
+        lines.push(`${prefix}: ${JSON.stringify(current)}`);
+      } catch (_e) {
+        lines.push(`${prefix}: ${String(current)}`);
+      }
+      current = undefined;
+    }
+    depth++;
+  }
+  if (lines.length === 0) {
+    lines.push(`reason: ${String(reason)}`);
+  }
+  return lines.join('\n');
+}
+
+function describeFetchRequest(input: RequestInfo | URL, init?: RequestInit) {
+  if (input instanceof Request) {
+    return { method: input.method, url: input.url };
+  }
+  let url = input instanceof URL ? input.href : String(input);
+  let method = init?.method ?? 'GET';
+  return { method, url };
+}
+
+function formatErrorForLog(error: unknown): string {
+  if (error instanceof Error) {
+    let header = error.name ? `${error.name}: ${error.message}` : error.message;
+    let stack = error.stack?.trim();
+    if (stack && !stack.includes(header)) {
+      return `${header}\n${stack}`;
+    }
+    return stack ?? header ?? 'Unknown error';
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  try {
+    let serialized = JSON.stringify(error);
+    if (serialized && serialized !== '{}') {
+      return serialized;
+    }
+  } catch (_e) {
+    // fall through to string coercion
+  }
+  return String(error);
+}
+
+// Seed the AI Assistant open/closed preference to 'false' before each test so
+// the existing test helpers (which click to open) are not double-toggled by
+// the persistence behavior added in CS-11071. Keeping tests deterministic and
+// matching the historical default of "panel closed until the test opens it".
+function seedAiAssistantClosed(hooks: NestedHooks) {
+  hooks.beforeEach(function () {
+    window.localStorage.setItem(AiAssistantOpen, 'false');
+  });
+}
+
+export function setupApplicationTest(hooks: NestedHooks) {
+  emberSetupApplicationTest(hooks);
+  setupWindowMock(hooks);
+  seedAiAssistantClosed(hooks);
+  setupFetchDebugging(hooks);
+  setupUnhandledRejectionDiagnostics(hooks);
+  hooks.afterEach(async function () {
+    resetServiceIfPresent(this.owner, 'service:ai-assistant-panel-service');
+    resetServiceIfPresent(this.owner, 'service:matrix-service');
+    resetServiceIfPresent(this.owner, 'service:operator-mode-state-service');
+    await settled();
+    (
+      this.owner.lookup('service:reset') as ResetService | undefined
+    )?.resetAll();
+    cleanupMonacoEditorModels();
+    clearHtmlComponentCache();
+    clearRemoteRealmCache();
+  });
+}
+
+export function setupRenderingTest(hooks: NestedHooks) {
+  emberSetupRenderingTest(hooks);
+  setupWindowMock(hooks);
+  seedAiAssistantClosed(hooks);
+  setupFetchDebugging(hooks);
+  setupUnhandledRejectionDiagnostics(hooks);
+  hooks.afterEach(async function () {
+    await settled();
+    (
+      this.owner.lookup('service:reset') as ResetService | undefined
+    )?.resetAll();
+    cleanupMonacoEditorModels();
+    clearHtmlComponentCache();
+    clearRemoteRealmCache();
+  });
+}
+
+function resetServiceIfPresent(
+  owner: {
+    __container__?: { cache?: Record<string, unknown> };
+    lookup(name: string): unknown;
+  },
+  name: string,
+) {
+  (
+    owner.__container__?.cache?.[name] as
+      | { resetState?: () => void }
+      | undefined
+  )?.resetState?.();
+}