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

package/bundled-types/host-tests/helpers/mock-matrix/_sdk.ts

@@ -0,0 +1,71 @@
+import type Owner from '@ember/owner';
+
+import type { ExtendedMatrixSDK } from '@cardstack/host/services/matrix-sdk-loader';
+
+import { MockClient } from './_client';
+import { ServerState } from './_server-state';
+
+import type { Config } from '../mock-matrix';
+
+import type * as MatrixSDK from 'matrix-js-sdk';
+
+// without this, using a class as an interface forces you to have the same
+// private and protected methods too
+type PublicAPI<T> = { [K in keyof T]: T[K] };
+
+export class MockSDK implements PublicAPI<ExtendedMatrixSDK> {
+  serverState: ServerState;
+
+  constructor(
+    private sdkOpts: Config,
+    private owner: Owner,
+  ) {
+    this.serverState = new ServerState({
+      displayName: sdkOpts.displayName ?? '',
+      now: sdkOpts.now ?? Date.now,
+    });
+  }
+
+  createClient(clientOpts: MatrixSDK.ICreateClientOpts) {
+    return new MockClient(
+      this.owner,
+      this,
+      this.serverState,
+      clientOpts,
+      this.sdkOpts,
+    );
+  }
+
+  getRoomEvents(roomId: string) {
+    return this.serverState.getRoomEvents(roomId);
+  }
+
+  RoomEvent = {
+    Timeline: 'Room.timeline',
+    LocalEchoUpdated: 'Room.localEchoUpdated',
+    Receipt: 'Room.receipt',
+  } as ExtendedMatrixSDK['RoomEvent'];
+
+  RoomMemberEvent = {
+    Membership: 'RoomMember.membership',
+  } as ExtendedMatrixSDK['RoomMemberEvent'];
+
+  Preset = {
+    PrivateChat: 'private_chat',
+    TrustedPrivateChat: 'trusted_private_chat',
+    PublicChat: 'public_chat',
+  } as ExtendedMatrixSDK['Preset'];
+
+  ClientEvent = {
+    AccountData: 'accountData',
+  } as ExtendedMatrixSDK['ClientEvent'];
+
+  RoomStateEvent = {
+    Events: 'RoomState.events',
+    Members: 'RoomState.members',
+    NewMember: 'RoomState.newMember',
+    Update: 'RoomState.update',
+    BeaconLiveness: 'RoomState.BeaconLiveness',
+    Marker: 'RoomState.Marker',
+  } as ExtendedMatrixSDK['RoomStateEvent'];
+}

package/bundled-types/host-tests/helpers/mock-matrix/_server-state.ts

@@ -0,0 +1,343 @@
+import * as MatrixSDK from 'matrix-js-sdk';
+
+type IEvent = MatrixSDK.IEvent;
+
+export class ServerState {
+  #roomCounter = 0;
+  #eventCounter = 0;
+  #rooms: Map<
+    string,
+    {
+      events: IEvent[];
+      receipts: IEvent[];
+      roomStateEvents: Map<string, Map<string, MatrixSDK.MatrixEvent>>;
+    }
+  > = new Map();
+  #listeners: ((event: IEvent) => void)[] = [];
+  #slidingSyncListeners: ((roomId: string, roomName?: string) => void)[] = [];
+  #displayName: string;
+  #contents: Map<string, ArrayBuffer> = new Map();
+  #now: () => number;
+
+  constructor(opts: { displayName: string; now: () => number }) {
+    this.#displayName = opts.displayName;
+    this.#now = opts.now;
+  }
+
+  get displayName() {
+    return this.#displayName;
+  }
+
+  onEvent(callback: (event: IEvent) => void) {
+    return this.addListener(callback);
+  }
+
+  get rooms(): { id: string }[] {
+    return Array.from(this.#rooms.keys()).map((id) => ({ id }));
+  }
+
+  addListener(callback: (event: IEvent) => void) {
+    this.#listeners.push(callback);
+    return () => {
+      this.#listeners = this.#listeners.filter(
+        (listener) => listener !== callback,
+      );
+    };
+  }
+
+  onSlidingSyncEvent(callback: (roomId: string, roomName?: string) => void) {
+    this.#slidingSyncListeners.push(callback);
+    return () => {
+      this.#slidingSyncListeners = this.#slidingSyncListeners.filter(
+        (listener) => listener !== callback,
+      );
+    };
+  }
+
+  createRoom(
+    sender: string,
+    name?: string,
+    timestamp: number = this.#now(),
+    id?: string,
+  ): string {
+    if (document.querySelector('[data-test-throw-room-error]')) {
+      throw new Error('Intentional error thrown');
+    }
+
+    let roomId = id ?? `mock_room_${this.#roomCounter++}`;
+
+    if (this.#rooms.has(roomId)) {
+      throw new Error(`room ${roomId} already exists`);
+    }
+
+    this.#rooms.set(roomId, {
+      events: [],
+      receipts: [],
+      roomStateEvents: new Map(),
+    });
+
+    this.addRoomEvent(
+      sender,
+      {
+        room_id: roomId,
+        type: 'm.room.create',
+        content: {
+          creator: sender,
+          room_version: '0',
+        },
+      },
+      { origin_server_ts: timestamp, state_key: '' },
+    );
+
+    this.addRoomEvent(
+      sender,
+      {
+        room_id: roomId,
+        type: 'm.room.name',
+        content: { name: name ?? roomId },
+      },
+      { origin_server_ts: timestamp, state_key: '' },
+    );
+
+    this.addRoomEvent(
+      sender,
+      {
+        room_id: roomId,
+        type: 'm.room.member',
+        content: {
+          displayname: 'testuser',
+          membership: 'join',
+          membershipTs: timestamp,
+          membershipInitiator: sender,
+        },
+      },
+      { origin_server_ts: timestamp, state_key: sender },
+    );
+
+    if (
+      !roomId.includes('test-session-room-realm') &&
+      roomId !== 'test-auth-realm-server-session-room'
+    ) {
+      this.addRoomEvent(
+        sender,
+        {
+          room_id: roomId,
+          type: 'm.room.member',
+          content: {
+            displayname: 'aibot',
+            membership: 'invite',
+          },
+        },
+        {
+          origin_server_ts: timestamp,
+          // host application expects this for the bot to join the room
+          state_key: '@aibot:localhost',
+        },
+      );
+
+      this.addRoomEvent(
+        '@aibot:localhost',
+        {
+          room_id: roomId,
+          type: 'm.room.member',
+          content: {
+            displayname: 'aibot',
+            membership: 'join',
+          },
+        },
+        {
+          origin_server_ts: timestamp,
+          // host application expects this for the bot to join the room
+          state_key: '@aibot:localhost',
+        },
+      );
+    }
+
+    // Emit sliding sync event for the new room
+    setTimeout(() => {
+      this.#slidingSyncListeners.forEach((listener) => listener(roomId, name));
+    }, 0);
+
+    return roomId;
+  }
+
+  getRoomState(
+    roomId: string,
+    eventType: string,
+    stateKey?: string,
+  ): Record<string, any> {
+    let event = this.#rooms
+      .get(roomId)
+      ?.roomStateEvents.get(eventType)
+      ?.get(stateKey ?? '');
+    if (event) {
+      return event.event.content || {};
+    } else {
+      throw new MatrixSDK.MatrixError({
+        errcode: 'M_NOT_FOUND',
+        error: `room state event ${eventType} does not exist for state key ${stateKey}`,
+      });
+    }
+  }
+
+  setRoomState(
+    sender: string,
+    roomId: string,
+    eventType: string,
+    content: Record<string, any>,
+    stateKey?: string,
+    timestamp: number = this.#now(),
+  ) {
+    let room = this.#rooms.get(roomId);
+    if (!room) {
+      throw new Error(`room ${roomId} does not exist`);
+    }
+    return this.addRoomEvent(
+      sender,
+      {
+        room_id: roomId,
+        type: eventType,
+        content,
+      },
+      {
+        origin_server_ts: timestamp,
+        state_key: stateKey ?? '',
+      },
+    );
+  }
+
+  addRoomEvent(
+    sender: string,
+    event: Omit<
+      IEvent,
+      'event_id' | 'origin_server_ts' | 'unsigned' | 'status' | 'sender'
+    >,
+    overrides?: {
+      event_id?: string;
+      state_key?: string;
+      origin_server_ts?: number;
+    },
+  ) {
+    // duplicate the event fully
+    let room = event.room_id && this.#rooms.get(event.room_id);
+    if (!room) {
+      throw new Error(
+        `room ${event.room_id} does not exist, known rooms: ${Array.from(
+          this.#rooms.keys(),
+        ).join(', ')}`,
+      );
+    }
+    let eventId = overrides?.event_id ?? this.eventId();
+    let matrixEvent: IEvent = {
+      ...event,
+      // Don’t want to list out all the types from MatrixEvent union type
+      type: event.type as any,
+      event_id: eventId,
+      origin_server_ts: overrides?.origin_server_ts ?? this.#now(),
+      unsigned: { age: 0 },
+      sender,
+      state_key: overrides?.state_key,
+    };
+    let matrixContent = matrixEvent.content as any;
+    if (matrixContent?.data?.replace) {
+      matrixContent.data = matrixContent.data.replace(/__EVENT_ID__/g, eventId);
+    }
+    let relatesTo = matrixContent?.['m.relates_to'] as any;
+    if (relatesTo?.event_id?.replace) {
+      relatesTo.event_id = relatesTo.event_id.replace(/__EVENT_ID__/g, eventId);
+    }
+    room.events.push(matrixEvent);
+    setTimeout(() => {
+      this.#listeners.forEach((listener) => listener(matrixEvent));
+    }, 0);
+    if (typeof overrides?.state_key === 'string') {
+      if (!room.roomStateEvents.has(event.type)) {
+        room.roomStateEvents.set(event.type, new Map());
+      }
+      room.roomStateEvents
+        .get(event.type)!
+        .set(overrides.state_key, new MatrixSDK.MatrixEvent(matrixEvent));
+    }
+    return matrixEvent.event_id;
+  }
+
+  addReceiptEvent(
+    roomId: string,
+    eventId: string,
+    sender: string,
+    receiptType: MatrixSDK.ReceiptType,
+  ) {
+    let room = this.#rooms.get(roomId);
+    if (!room) {
+      throw new Error(`room ${roomId} does not exist`);
+    }
+
+    let ts = this.#now();
+    let content: Record<string, any> = {
+      [eventId]: {
+        [receiptType]: {
+          [sender]: {
+            thread_id: 'main',
+            ts,
+          },
+        },
+      },
+    };
+
+    let receiptEvent: IEvent = {
+      event_id: this.eventId(),
+      origin_server_ts: ts,
+      room_id: roomId,
+      type: 'm.receipt' as any,
+      sender,
+      unsigned: { age: 0 },
+      state_key: '',
+      content,
+    };
+
+    room.receipts.push(receiptEvent);
+    this.#listeners.forEach((listener) => listener(receiptEvent));
+
+    return receiptEvent;
+  }
+
+  getRoomEvents(roomId: string): IEvent[] {
+    let room = this.#rooms.get(roomId);
+    if (!room) {
+      throw new Error(`room ${roomId} does not exist`);
+    }
+    return [...room.events];
+  }
+
+  getRoomStateUpdatePayload(roomId: string): MatrixSDK.RoomState {
+    let room = this.#rooms.get(roomId);
+    if (!room) {
+      throw new Error(`room ${roomId} does not exist`);
+    }
+    return { events: room.roomStateEvents, roomId } as MatrixSDK.RoomState;
+  }
+
+  eventId(): string {
+    return `!mock_event_${this.#eventCounter++}`;
+  }
+
+  setDisplayName(name: string) {
+    if (name === 'MAKEMECRASH') {
+      throw new Error('BOOM!');
+    } else {
+      this.#displayName = name;
+    }
+  }
+
+  addContent(mxcUrl: string, content: ArrayBuffer) {
+    this.#contents.set(mxcUrl, content);
+  }
+
+  getContent(mxcUrl: string) {
+    return this.#contents.get(mxcUrl);
+  }
+
+  getUploadedContents() {
+    return this.#contents;
+  }
+}

package/bundled-types/host-tests/helpers/mock-matrix/_sliding-sync.ts

@@ -0,0 +1,140 @@
+import {
+  SlidingSync,
+  SlidingSyncEvent,
+  SlidingSyncState,
+} from 'matrix-js-sdk/lib/sliding-sync';
+
+import type * as MatrixSDK from 'matrix-js-sdk';
+import type {
+  MSC3575List,
+  MSC3575RoomSubscription,
+} from 'matrix-js-sdk/lib/sliding-sync';
+
+export class MockSlidingSync extends SlidingSync {
+  private _client: MatrixSDK.MatrixClient;
+  private _lists: Record<string, MSC3575List>;
+  private lifecycleCallbacks: Function[] = [];
+
+  constructor(
+    proxyBaseUrl: string,
+    lists: Map<string, MSC3575List>,
+    roomSubscriptionInfo: MSC3575RoomSubscription,
+    client: MatrixSDK.MatrixClient,
+    timeoutMS: number,
+  ) {
+    super(proxyBaseUrl, lists, roomSubscriptionInfo, client, timeoutMS);
+    this._client = client;
+    this._lists = Object.fromEntries(lists);
+  }
+
+  on(event: string, callback: Function) {
+    if (event === SlidingSyncEvent.Lifecycle) {
+      this.lifecycleCallbacks.push(callback);
+    }
+    return this;
+  }
+
+  off(event: string, callback: Function) {
+    if (event === SlidingSyncEvent.Lifecycle) {
+      this.lifecycleCallbacks = this.lifecycleCallbacks.filter(
+        (existing) => existing !== callback,
+      );
+    }
+    return this;
+  }
+
+  emit(event: string, ...args: any[]) {
+    if (event === SlidingSyncEvent.Lifecycle) {
+      this.lifecycleCallbacks.forEach((cb) => cb(...args));
+    }
+    return true;
+  }
+
+  async start() {
+    if (!this._lists) {
+      return;
+    }
+    let slidingResponse = await this._client.slidingSync(
+      {
+        lists: this._lists,
+        room_subscriptions: undefined,
+      },
+      '',
+      {} as any,
+    );
+
+    this.emit(
+      SlidingSyncEvent.Lifecycle,
+      SlidingSyncState.RequestFinished,
+      slidingResponse,
+    );
+
+    this.emit(
+      SlidingSyncEvent.Lifecycle,
+      SlidingSyncState.Complete,
+      slidingResponse,
+    );
+  }
+
+  async setListRanges(listKey: string, ranges: number[][]) {
+    this._lists[listKey].ranges = ranges;
+    return await this.resend();
+  }
+
+  async resend() {
+    await this.start();
+    return Promise.resolve('');
+  }
+
+  async triggerRoomSync(roomId: string, roomName?: string, serverState?: any) {
+    if (!this.lifecycleCallbacks.length) {
+      return;
+    }
+
+    // Create a mock sliding sync response that includes the new room
+    let mockResponse = {
+      pos: String(Date.now()),
+      lists: {
+        ['ai-room']: {
+          count: 1,
+          ops: [
+            {
+              op: 'SYNC',
+              range: [0, (serverState?.rooms?.length || 1) - 1],
+              room_ids: [roomId],
+            },
+          ],
+        },
+      },
+      rooms: {
+        [roomId]: {
+          name: roomName || 'room',
+          required_state: [],
+          timeline: serverState?.getRoomEvents?.(roomId) || [],
+          notification_count: 0,
+          highlight_count: 0,
+          joined_count: 1,
+          invited_count: 0,
+          initial: true,
+        },
+      },
+      extensions: {},
+    };
+
+    // Trigger the lifecycle events that the matrix service is waiting for
+    this.emit(
+      SlidingSyncEvent.Lifecycle,
+      SlidingSyncState.RequestFinished,
+      mockResponse,
+    );
+    this.emit(
+      SlidingSyncEvent.Lifecycle,
+      SlidingSyncState.Complete,
+      mockResponse,
+    );
+  }
+
+  stop() {
+    this.lifecycleCallbacks = [];
+  }
+}

package/bundled-types/host-tests/helpers/mock-matrix/_utils.ts

@@ -0,0 +1,146 @@
+import type Owner from '@ember/owner';
+
+import type { RealmAction } from '@cardstack/runtime-common';
+import { APP_BOXEL_REALM_EVENT_TYPE } from '@cardstack/runtime-common/matrix-constants';
+
+import type RealmService from '@cardstack/host/services/realm';
+
+import type { RealmEvent } from 'https://cardstack.com/base/matrix-event';
+
+import { setupAuthEndpoints } from '../';
+
+import type { MockSDK } from './_sdk';
+import type { Config } from '../mock-matrix';
+
+import type * as MatrixSDK from 'matrix-js-sdk';
+
+type IEvent = MatrixSDK.IEvent;
+
+export class MockUtils {
+  constructor(
+    private testState: { owner?: Owner; sdk?: MockSDK; opts?: Config },
+    readonly start: () => Promise<void>,
+  ) {}
+  getRoomEvents = (roomId: string) => {
+    return this.testState.sdk!.getRoomEvents(roomId);
+  };
+  getRoomIds = () => {
+    return this.testState.sdk!.serverState.rooms.map((r) => r.id);
+  };
+
+  getRoomIdForRealmAndUser = (realmURL: string, userId: string) => {
+    return getRoomIdForRealmAndUser(realmURL, userId);
+  };
+
+  getRoomState = (roomId: string, eventType: string, stateKey?: string) => {
+    return this.testState.sdk!.serverState.getRoomState(
+      roomId,
+      eventType,
+      stateKey,
+    );
+  };
+
+  getSystemCardAccountData = () => {
+    return this.testState.opts?.systemCardAccountData;
+  };
+
+  getRealmEventMessagesSince = (roomId: string, since: number) => {
+    return this.testState
+      .sdk!.serverState.getRoomEvents(roomId)
+      .filter(
+        (e: IEvent) => isRealmEvent(e) && e.origin_server_ts > since,
+      ) as RealmEvent[];
+  };
+
+  setRealmPermissions = (permissions: Record<string, RealmAction[]>) => {
+    this.testState.opts!.realmPermissions = permissions;
+    (this.testState.owner!.lookup('service:realm') as RealmService).logout();
+
+    setupAuthEndpoints(permissions);
+  };
+  simulateRemoteMessage = (
+    roomId: string,
+    sender: string,
+    content: MatrixSDK.IEvent['content'],
+    overrides?: {
+      event_id?: string;
+      state_key?: string;
+      origin_server_ts?: number;
+      type?: string;
+    },
+  ) => {
+    return this.testState.sdk!.serverState.addRoomEvent(
+      sender,
+      {
+        room_id: roomId,
+        type: overrides?.type ?? 'm.room.message',
+        content,
+      },
+      overrides,
+    );
+  };
+
+  setReadReceipt = (roomId: string, eventId: string, reader: string) => {
+    return this.testState.sdk!.serverState.addReceiptEvent(
+      roomId,
+      eventId,
+      reader,
+      'm.read' as MatrixSDK.ReceiptType,
+    );
+  };
+
+  setExpiresInSec = (sec: number) => {
+    this.testState.opts!.expiresInSec = sec;
+  };
+  setActiveRealms = (realmURLs: string[]) => {
+    this.testState.opts!.activeRealms = realmURLs;
+  };
+  createAndJoinRoom = ({
+    sender,
+    name,
+    id,
+    timestamp,
+  }: {
+    sender: string;
+    name: string;
+    id?: string;
+    timestamp?: number;
+  }) => {
+    let roomId = this.testState.sdk!.serverState.createRoom(
+      sender,
+      name,
+      timestamp,
+      id,
+    );
+    return roomId;
+  };
+  getUploadedContents = () => {
+    return this.testState.sdk!.serverState.getUploadedContents();
+  };
+  setUploadContentInterceptor = (fn: (() => Promise<void>) | undefined) => {
+    this.testState.opts!.uploadContentInterceptor = fn;
+  };
+
+  setRoomState = (
+    roomId: string,
+    eventType: string,
+    content: Record<string, any>,
+    stateKey?: string,
+  ) => {
+    return this.testState.sdk!.serverState.setRoomState(
+      this.testState.opts?.loggedInAs || 'unknown_user',
+      roomId,
+      eventType as string,
+      content,
+      stateKey,
+    );
+  };
+}
+
+function isRealmEvent(e: IEvent): e is RealmEvent {
+  return e.type === APP_BOXEL_REALM_EVENT_TYPE;
+}
+
+export function getRoomIdForRealmAndUser(realmURL: string, userId: string) {
+  return `test-session-room-realm-${realmURL}-user-${userId}`;
+}