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

package/bundled-types/host-app/services/host-mode-state-service.ts

@@ -0,0 +1,160 @@
+import type Owner from '@ember/owner';
+import type RouterService from '@ember/routing/router-service';
+import { scheduleOnce } from '@ember/runloop';
+import Service, { service } from '@ember/service';
+
+import { tracked } from '@glimmer/tracking';
+
+import stringify from 'safe-stable-stringify';
+
+import { TrackedArray } from 'tracked-built-ins';
+
+import type RealmService from './realm';
+import type ResetService from './reset';
+
+interface InitializeOptions {
+  primaryCardId: string | null;
+  stack: string[];
+  routePath: string;
+}
+
+type SerializedStack = string[];
+
+export default class HostModeStateService extends Service {
+  @service declare router: RouterService;
+  @service declare realm: RealmService;
+  @service declare reset: ResetService;
+
+  // The primary card comes from the main path segment of the URL.
+  // The stack cards come from the `hostModeStack` query param.
+  // Example:
+  // URL: https://user.example.com/cards/123.json?hostModeStack=https%3A%2F%2Fuser.example.com%2Fcards%2F456.json,https%3A%2F%2Fuser.example.com%2Fcards%2F789.json
+  // Primary card ID: https://user.example.com/cards/123
+  // Stack card IDs: [https://user.example.com/cards/456, https://user.example.com/cards/789]
+  @tracked private primaryCardItem: string | null = null;
+  private stackCardItems: TrackedArray<string> = new TrackedArray();
+  private currentRoutePath: string | null = null;
+  private isStateInitialized = false;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.primaryCardItem = null;
+    this.stackCardItems = new TrackedArray();
+    this.currentRoutePath = null;
+    this.isStateInitialized = false;
+  }
+
+  restore({
+    primaryCardId,
+    serializedStack,
+    routePath,
+  }: {
+    primaryCardId: string | null;
+    serializedStack?: string | null;
+    routePath?: string | null;
+  }) {
+    let stack = this.deserialize(serializedStack);
+
+    this.initialize({
+      primaryCardId,
+      stack,
+      routePath: routePath ?? '',
+    });
+  }
+
+  private initialize({ primaryCardId, stack, routePath }: InitializeOptions) {
+    if (this.isStateInitialized) {
+      return;
+    }
+    this.isStateInitialized = false;
+    this.primaryCardItem = primaryCardId ?? null;
+    this.stackCardItems.push(...stack);
+    this.currentRoutePath = routePath;
+    this.isStateInitialized = true;
+  }
+
+  get stackItems() {
+    return this.stackCardItems;
+  }
+
+  get primaryCard(): string | null {
+    return this.primaryCardItem ?? null;
+  }
+
+  setPrimaryCard(cardId: string | null) {
+    if (!this.isStateInitialized) {
+      return;
+    }
+
+    this.primaryCardItem = cardId ?? null;
+    this.schedulePersist();
+  }
+
+  pushCard(cardId: string) {
+    this.stackCardItems.push(cardId);
+    this.schedulePersist();
+  }
+
+  removeCardFromStack(cardId: string) {
+    let index = this.stackCardItems.findIndex((item) => item === cardId);
+
+    if (index !== -1) {
+      this.stackCardItems.splice(index, 1);
+      this.schedulePersist();
+    }
+  }
+
+  private deserialize(serialized: string | undefined | null): string[] {
+    if (!serialized) {
+      return [];
+    }
+
+    try {
+      return JSON.parse(serialized) as SerializedStack;
+    } catch (error) {
+      // Ignore malformed data and reset stack
+    }
+
+    return [];
+  }
+
+  serialize(): string | undefined {
+    if (this.stackCardItems.length === 0) {
+      return undefined;
+    }
+
+    return stringify(this.stackCardItems) ?? undefined;
+  }
+
+  private schedulePersist() {
+    if (!this.isStateInitialized) {
+      return;
+    }
+
+    scheduleOnce('afterRender', this, this.persist);
+  }
+
+  private persist() {
+    if (!this.isStateInitialized || !this.currentRoutePath) {
+      return;
+    }
+
+    let serialized = this.serialize();
+    // Preserve the param if there is a stack, otherwise remove it to keep the URL clean.
+    this.router.transitionTo('index', this.currentRoutePath, {
+      queryParams: {
+        hostModeStack: serialized,
+      },
+    });
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'host-mode-state-service': HostModeStateService;
+  }
+}

package/bundled-types/host-app/services/loader-service.ts

@@ -0,0 +1,148 @@
+import { registerDestructor } from '@ember/destroyable';
+import type Owner from '@ember/owner';
+import Service, { service } from '@ember/service';
+
+import { isTesting } from '@embroider/macros';
+import { tracked } from '@glimmer/tracking';
+
+import type { FetcherMiddlewareHandler } from '@cardstack/runtime-common';
+import {
+  fetcher,
+  maybeHandleScopedCSSRequest,
+  authorizationMiddleware,
+  clearFetchCache,
+  clearInjectedScopedCSS,
+  logger,
+} from '@cardstack/runtime-common';
+
+import { Loader } from '@cardstack/runtime-common/loader';
+
+import { clearKnownFileMetaUrls } from '@cardstack/host/components/prerendered-card-search';
+
+import config from '@cardstack/host/config/environment';
+
+import { authErrorEventMiddleware } from '../utils/auth-error-guard';
+import { scheduleNativeTimeout } from '../utils/render-timer-stub';
+
+import type NetworkService from './network';
+import type RealmService from './realm';
+import type RealmInfoService from './realm-info-service';
+import type ResetService from './reset';
+
+const log = logger('loader-service');
+
+export default class LoaderService extends Service {
+  @service declare private realmInfoService: RealmInfoService;
+  @service declare private realm: RealmService;
+  @service declare private network: NetworkService;
+  @service declare private reset: ResetService;
+
+  @tracked public loader = this.makeInstance();
+  private resetTime: number | undefined;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+    if (isTesting()) {
+      // clears the fetch cache and SSR-injected scoped styles in between tests
+      this.resetState();
+    }
+    registerDestructor(this, () => this.resetState());
+  }
+
+  public resetState() {
+    this.clearSessionCaches();
+  }
+
+  public resetSessionBoundary(reason?: string) {
+    this.resetTime = undefined;
+    log.debug(`resetting loader for session boundary (${reason ?? ''})`);
+    this.clearSessionCaches();
+    this.loader = this.loader
+      ? Loader.cloneLoader(this.loader)
+      : this.makeInstance();
+  }
+
+  public resetLoader(options?: { clearFetchCache?: boolean; reason?: string }) {
+    // clearFetchCache requests must never be debounced--the caller is
+    // signalling that cached responses are stale (e.g. a module was
+    // rewritten). Skipping this would cause re-indexing to use the old
+    // (broken) module from the fetch cache.
+    if (options?.clearFetchCache) {
+      this.resetTime = Date.now();
+      log.debug(`resetting loader (clearFetchCache, ${options.reason ?? ''})`);
+      clearFetchCache();
+      this.loader = this.makeInstance();
+      return;
+    }
+
+    // This method is called in both the FileResource and in RealmSubscription,
+    // oftentimes for the same update. It is very difficult to coordinate
+    // between these two, as a CardResource is not always present (e.g. schema
+    // editor). In order to prevent this from doubling up (and causing
+    // unnecessary screen flashes) we add a simple leading edge debounce.
+    if (this.resetTime == null || Date.now() - this.resetTime > 250) {
+      this.resetTime = Date.now();
+      log.debug(`resetting loader (${options?.reason ?? ''})`);
+      // by default we keep the fetch cache so we can take advantage of HTTP
+      // caching when rebuilding the loader state
+      if (this.loader) {
+        this.loader = Loader.cloneLoader(this.loader);
+      } else {
+        this.loader = this.makeInstance();
+      }
+    }
+  }
+
+  private makeInstance() {
+    let middlewareStack: FetcherMiddlewareHandler[] = [];
+    middlewareStack.push(async (req, next) => {
+      return (await maybeHandleScopedCSSRequest(req)) || next(req);
+    });
+    middlewareStack.push(async (req, next) => {
+      let response = await next(req);
+      if (
+        !response.ok &&
+        req.url.startsWith(
+          `${config.iconsURL}/@cardstack/boxel-icons/v1/icons/`,
+        )
+      ) {
+        req = new Request(
+          `${config.iconsURL}/@cardstack/boxel-icons/v1/icons/error-404.js`,
+          req,
+        );
+        response = await next(req);
+      }
+      return response;
+    });
+
+    middlewareStack.push(authorizationMiddleware(this.realm));
+    middlewareStack.push(authErrorEventMiddleware());
+    let fetch = fetcher(this.network.fetch, middlewareStack);
+    let loader = new Loader(fetch, this.network.resolveImport, {
+      // Route the loader's transient-5xx retry backoff sleep through
+      // scheduleNativeTimeout so it bypasses the render-timer-stub during
+      // prerender. Outside prerender this falls back to the native
+      // setTimeout, so behavior is unchanged in the host runtime.
+      retrySleep: (ms) =>
+        new Promise<void>((resolve) =>
+          scheduleNativeTimeout(() => resolve(), ms),
+        ),
+    });
+    return loader;
+  }
+
+  private clearSessionCaches() {
+    // This clears cached module fetches and scoped styles at session/test
+    // boundaries so private realm assets do not leak across owners.
+    clearFetchCache();
+    clearInjectedScopedCSS();
+    clearKnownFileMetaUrls();
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'loader-service': LoaderService;
+  }
+}

package/bundled-types/host-app/services/local-indexer.ts

@@ -0,0 +1,68 @@
+import type Owner from '@ember/owner';
+import Service from '@ember/service';
+import { service } from '@ember/service';
+
+import { tracked } from '@glimmer/tracking';
+
+import type { IndexWriter, Prerenderer } from '@cardstack/runtime-common';
+
+import type { TestRealmAdapter } from '@cardstack/host/tests/helpers/adapter';
+
+import type ResetService from './reset';
+
+// Tests inject an implementation of this service to help perform indexing
+// for the test-realm-adapter
+export default class LocalIndexer extends Service {
+  @service declare reset: ResetService;
+  @tracked renderError: string | undefined;
+  @tracked prerenderStatus: 'ready' | 'loading' | 'unusable' | undefined;
+  #prerenderer: Prerenderer | undefined;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.renderError = undefined;
+    this.prerenderStatus = undefined;
+    this.teardown();
+  }
+
+  setup(prerenderer: Prerenderer) {
+    if (this.#prerenderer === prerenderer) {
+      return;
+    }
+    this.#prerenderer = prerenderer;
+  }
+  teardown(prerenderer?: Prerenderer) {
+    if (prerenderer && this.#prerenderer !== prerenderer) {
+      return;
+    }
+    this.#prerenderer = undefined;
+  }
+  get adapter(): TestRealmAdapter {
+    return {} as TestRealmAdapter;
+  }
+  get indexWriter(): IndexWriter {
+    return {} as IndexWriter;
+  }
+  get prerenderer() {
+    if (!this.#prerenderer) {
+      throw new Error('prerenderer has not been configured on LocalIndexer');
+    }
+    return this.#prerenderer;
+  }
+  setPrerenderStatus(status: 'ready' | 'loading' | 'unusable') {
+    this.prerenderStatus = status;
+  }
+  setRenderError(error: string) {
+    this.renderError = error;
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'local-indexer': LocalIndexer;
+  }
+}

package/bundled-types/host-app/services/local-persistence-service.ts

@@ -0,0 +1,296 @@
+import Service from '@ember/service';
+
+import window from 'ember-window-mock';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { SerializedFileDef } from 'https://cardstack.com/base/file-api';
+
+import {
+  AiAssistantMessageDrafts,
+  CurrentRoomIdPersistenceKey,
+} from '../utils/local-storage-keys';
+
+const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+
+export type StoredFileDraft = Pick<
+  SerializedFileDef,
+  'sourceUrl' | 'name' | 'url' | 'contentType' | 'contentHash'
+>;
+
+type StoredMessageDraft = {
+  message?: string;
+  attachedCardIds?: string[];
+  attachedFiles?: StoredFileDraft[];
+  updatedAt: number;
+};
+
+type DraftUpdate = {
+  message?: string;
+  attachedCardIds?: string[] | undefined;
+  attachedFiles?: StoredFileDraft[] | undefined;
+};
+
+export default class LocalPersistenceService extends Service {
+  // Using sessionStorage for agent id because we want:
+  // - to keep the same agent id if user reloads the page (or tab)
+  // - to get a new agent id if user opens an additional tab
+  getAgentId() {
+    let agentId = window.sessionStorage.getItem('agentId');
+    if (!agentId) {
+      agentId = uuidv4();
+      window.sessionStorage.setItem('agentId', agentId);
+    }
+    return agentId;
+  }
+
+  // Using sessionStorage so that we can keep different current room id for each tab, and
+  // keep the same current room id if user reloads the page (or tab).
+  // Additionally, we use localStorage so that when a user opens a new tab,
+  // the previously most recently used room is selected. But after the user enters another room,
+  // that room gets persisted in sessionStorage and the behaviour from the beginning of this
+  // comment applies again.
+  getCurrentRoomId() {
+    let currentRoomId = window.sessionStorage.getItem('currentRoomId');
+    if (!currentRoomId) {
+      currentRoomId = window.localStorage.getItem(CurrentRoomIdPersistenceKey);
+    }
+    return currentRoomId;
+  }
+
+  setCurrentRoomId(roomId: string | undefined) {
+    if (!roomId) {
+      window.sessionStorage.removeItem('currentRoomId');
+      window.localStorage.removeItem(CurrentRoomIdPersistenceKey);
+      return;
+    }
+    window.sessionStorage.setItem('currentRoomId', roomId);
+    window.localStorage.setItem(CurrentRoomIdPersistenceKey, roomId);
+  }
+
+  getDraft(roomId: string) {
+    return this.readMessageDrafts()[roomId];
+  }
+
+  getMessageDraft(roomId: string) {
+    return this.getDraft(roomId)?.message;
+  }
+
+  setMessageDraft(roomId: string, message: string | undefined) {
+    this.updateDraft(roomId, {
+      message: message?.length ? message : undefined,
+    });
+  }
+
+  getAttachedCardIds(roomId: string) {
+    return this.getDraft(roomId)?.attachedCardIds;
+  }
+
+  setAttachedCardIds(roomId: string, cardIds: string[] | undefined) {
+    let sanitized = cardIds?.filter((id) => typeof id === 'string' && id);
+    this.updateDraft(roomId, {
+      attachedCardIds: sanitized && sanitized.length ? sanitized : undefined,
+    });
+  }
+
+  getAttachedFiles(roomId: string) {
+    return this.getDraft(roomId)?.attachedFiles;
+  }
+
+  setAttachedFiles(roomId: string, files: StoredFileDraft[] | undefined) {
+    let sanitized = files
+      ? (files
+          .map((file) => this.sanitizeFile(file))
+          .filter(Boolean) as StoredFileDraft[])
+      : undefined;
+    this.updateDraft(roomId, {
+      attachedFiles: sanitized && sanitized.length ? sanitized : undefined,
+    });
+  }
+
+  private readMessageDrafts(): Record<string, StoredMessageDraft> {
+    let drafts = window.localStorage.getItem(AiAssistantMessageDrafts);
+    if (!drafts) {
+      return {} as Record<string, StoredMessageDraft>;
+    }
+
+    try {
+      let parsed = JSON.parse(drafts);
+      if (!parsed || typeof parsed !== 'object') {
+        return {} as Record<string, StoredMessageDraft>;
+      }
+
+      let now = Date.now();
+      let sanitized: Record<string, StoredMessageDraft> = {};
+
+      for (let [roomId, value] of Object.entries(
+        parsed as Record<string, unknown>,
+      )) {
+        let draft = this.sanitizeDraft(value, now);
+        if (draft) {
+          sanitized[roomId] = draft;
+        }
+      }
+
+      return sanitized;
+    } catch {
+      window.localStorage.removeItem(AiAssistantMessageDrafts);
+      return {} as Record<string, StoredMessageDraft>;
+    }
+  }
+
+  private sanitizeDraft(value: unknown, now: number) {
+    if (!value || typeof value !== 'object') {
+      return;
+    }
+
+    let message = (value as { message?: unknown }).message;
+    let updatedAt = Number(
+      (value as { updatedAt?: unknown }).updatedAt ??
+        (value as { createdAt?: unknown }).createdAt,
+    );
+    let attachedCardIds = (value as { attachedCardIds?: unknown })
+      .attachedCardIds;
+    let attachedFiles = (value as { attachedFiles?: unknown }).attachedFiles;
+
+    let sanitizedMessage = typeof message === 'string' ? message : undefined;
+    let sanitizedCards = Array.isArray(attachedCardIds)
+      ? attachedCardIds.filter(
+          (id): id is string => typeof id === 'string' && id.length > 0,
+        )
+      : undefined;
+    let sanitizedFiles = Array.isArray(attachedFiles)
+      ? (attachedFiles
+          .map((file) => this.sanitizeFile(file))
+          .filter(Boolean) as StoredFileDraft[])
+      : undefined;
+
+    if (!Number.isFinite(updatedAt)) {
+      updatedAt = now;
+    }
+
+    if (
+      this.isDraftEmpty({
+        message: sanitizedMessage,
+        attachedCardIds: sanitizedCards,
+        attachedFiles: sanitizedFiles,
+        updatedAt,
+      })
+    ) {
+      return;
+    }
+
+    return {
+      message: sanitizedMessage,
+      attachedCardIds: sanitizedCards,
+      attachedFiles: sanitizedFiles,
+      updatedAt,
+    } satisfies StoredMessageDraft;
+  }
+
+  private sanitizeFile(file: unknown): StoredFileDraft | undefined {
+    if (!file || typeof file !== 'object') {
+      return;
+    }
+
+    let sourceUrl = (file as { sourceUrl?: unknown }).sourceUrl;
+    if (typeof sourceUrl !== 'string' || sourceUrl.length === 0) {
+      return;
+    }
+
+    let name = (file as { name?: unknown }).name;
+    let url = (file as { url?: unknown }).url;
+    let contentType = (file as { contentType?: unknown }).contentType;
+    let contentHash = (file as { contentHash?: unknown }).contentHash;
+
+    return {
+      sourceUrl,
+      ...(typeof name === 'string' ? { name } : {}),
+      ...(typeof url === 'string' ? { url } : {}),
+      ...(typeof contentType === 'string' ? { contentType } : {}),
+      ...(typeof contentHash === 'string' ? { contentHash } : {}),
+    } satisfies StoredFileDraft;
+  }
+
+  private writeMessageDrafts(drafts: Record<string, StoredMessageDraft>) {
+    let now = Date.now();
+    let prunedEntries = Object.entries(drafts).filter(([, draft]) => {
+      if (!draft) {
+        return false;
+      }
+      let updatedAt = Number(draft?.updatedAt);
+      if (!Number.isFinite(updatedAt)) {
+        return false;
+      }
+      if (now - updatedAt > ONE_WEEK_MS) {
+        return false;
+      }
+
+      return !this.isDraftEmpty(draft);
+    });
+
+    if (prunedEntries.length === 0) {
+      window.localStorage.removeItem(AiAssistantMessageDrafts);
+      return;
+    }
+
+    let prunedDrafts = Object.fromEntries(prunedEntries) as Record<
+      string,
+      StoredMessageDraft
+    >;
+
+    window.localStorage.setItem(
+      AiAssistantMessageDrafts,
+      JSON.stringify(prunedDrafts),
+    );
+  }
+
+  private updateDraft(roomId: string, updates: DraftUpdate) {
+    let drafts = this.readMessageDrafts();
+    let existing = drafts[roomId];
+    let next: StoredMessageDraft = {
+      message: existing?.message,
+      attachedCardIds: existing?.attachedCardIds,
+      attachedFiles: existing?.attachedFiles,
+      updatedAt:
+        existing?.updatedAt ??
+        Number((existing as { createdAt?: number })?.createdAt) ??
+        Date.now(),
+    };
+
+    if ('message' in updates) {
+      next.message = updates.message;
+    }
+    if ('attachedCardIds' in updates) {
+      next.attachedCardIds = updates.attachedCardIds;
+    }
+    if ('attachedFiles' in updates) {
+      next.attachedFiles = updates.attachedFiles;
+    }
+
+    if (this.isDraftEmpty(next)) {
+      delete drafts[roomId];
+    } else {
+      next.updatedAt = Date.now();
+      drafts[roomId] = next;
+    }
+
+    this.writeMessageDrafts(drafts);
+  }
+
+  private isDraftEmpty(draft: StoredMessageDraft | undefined) {
+    if (!draft) {
+      return true;
+    }
+    let hasMessage =
+      typeof draft.message === 'string' && draft.message.length > 0;
+    let hasCards = draft.attachedCardIds && draft.attachedCardIds.length > 0;
+    let hasFiles = draft.attachedFiles && draft.attachedFiles.length > 0;
+    return !hasMessage && !hasCards && !hasFiles;
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'local-persistence-service': LocalPersistenceService;
+  }
+}

package/bundled-types/host-app/services/logger-service.ts

@@ -0,0 +1,13 @@
+import Service from '@ember/service';
+
+import LogLevel from 'loglevel';
+
+export default class LoggerService extends Service {
+  getLogger(name: string) {
+    return LogLevel.getLogger(name);
+  }
+
+  getLoggers() {
+    return LogLevel.getLoggers();
+  }
+}