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

package/bundled-types/host-app/router.ts

@@ -12,6 +12,7 @@ Router.map(function () {
     this.route('html', { path: '/html/:format/:ancestor_level' });
     this.route('icon');
     this.route('meta');
+    this.route('types');
     this.route('file-extract');
     this.route('error');
   });

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

@@ -19,6 +19,16 @@ function ensureSingleTitle(headHTML: string): string {
     ? headHTML
     : `${DEFAULT_HEAD_HTML}\n${headHTML}`;
 }
+
+// Normalize trailing-slash variance for routing-map matching. `/realm/`
+// and `/realm` are the same destination from the user's perspective,
+// but the injected map keys and Ember's `params.path` disagree on
+// the trailing slash. Stripping it on both sides makes the comparator
+// robust. Preserve the root `/` since stripping it would empty the path.
+function canonicalizeRoutingPath(path: string): string {
+  if (path === '/') return '/';
+  return path.replace(/\/+$/, '');
+}
 import type HostModeStateService from '@cardstack/host/services/host-mode-state-service';
 import type OperatorModeStateService from '@cardstack/host/services/operator-mode-state-service';
 import type RealmService from '@cardstack/host/services/realm';
@@ -130,10 +140,19 @@ export default class HostModeService extends Service {
   // `https://host/<user>/<realm>/whitepaper`); a leading slash is added if
   // absent so the index path is matchable as either '' or '/'. The
   // server prefixes each rule's `path` with the realm's mount pathname
-  // before injecting the map, so the two sides line up as direct equality.
+  // before injecting the map, so the two sides line up as direct equality
+  // — except for the trailing-slash variance at the realm root. A `/`
+  // rule's injected key is the realm's mount pathname WITH trailing
+  // slash (e.g. `/progressive-cheetah/`), but Ember's catch-all strips
+  // it (`params.path === 'progressive-cheetah'` for either visit form).
+  // Canonicalize both sides by stripping trailing slashes (except the
+  // root `/` itself) before comparing so `/realm` ↔ `/realm/` resolve.
   resolveRoutedPath(path: string): string | null {
     let normalized = path.startsWith('/') ? path : `/${path}`;
-    let rule = this.hostRoutingMap.find((r) => r.path === normalized);
+    let canonical = canonicalizeRoutingPath(normalized);
+    let rule = this.hostRoutingMap.find(
+      (r) => canonicalizeRoutingPath(r.path) === canonical,
+    );
     return rule ? rule.id : null;
   }
 

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

@@ -33,6 +33,7 @@ import {
   logger,
   isCardInstance,
   Deferred,
+  ri,
   SEARCH_MARKER,
   REPLACE_MARKER,
   SEPARATOR_MARKER,
@@ -371,8 +372,8 @@ export default class MatrixService extends Service {
         async (e) => {
           switch (e.event.type) {
             case APP_BOXEL_REALMS_EVENT_TYPE:
-              await this.realmServer.setAvailableRealmURLs(
-                e.event.content.realms,
+              await this.realmServer.setAvailableRealmIdentifiers(
+                (e.event.content.realms as string[]).map(ri),
               );
               // Only do this after we've completed our overall login
               if (this.postLoginCompleted) {
@@ -654,7 +655,7 @@ export default class MatrixService extends Service {
     await this.client.setAccountData(APP_BOXEL_REALMS_EVENT_TYPE, {
       realms: newRealms,
     });
-    await this.realmServer.setAvailableRealmURLs(newRealms);
+    await this.realmServer.setAvailableRealmIdentifiers(newRealms.map(ri));
   }
 
   public async removeRealmFromAccountData(realmURLString: string) {
@@ -667,7 +668,7 @@ export default class MatrixService extends Service {
     await this.client.setAccountData(APP_BOXEL_REALMS_EVENT_TYPE, {
       realms: newRealms,
     });
-    await this.realmServer.setAvailableRealmURLs(newRealms);
+    await this.realmServer.setAvailableRealmIdentifiers(newRealms.map(ri));
   }
 
   public async getWorkspaceFavorites(): Promise<string[]> {
@@ -767,13 +768,13 @@ export default class MatrixService extends Service {
 
         await Promise.all([
           this.realmServer.fetchCatalogRealms(),
-          this.realmServer.setAvailableRealmURLs(
-            accountDataContent?.realms ?? [],
+          this.realmServer.setAvailableRealmIdentifiers(
+            (accountDataContent?.realms ?? []).map(ri),
           ),
         ]);
 
         await this.realm.prefetchRealmInfos(
-          this.realmServer.availableRealmURLs,
+          this.realmServer.availableRealmIdentifiers,
         );
 
         await this.initSlidingSync(accountDataContent);
@@ -882,7 +883,7 @@ export default class MatrixService extends Service {
   async loginToRealms() {
     // This is where we would actually load user-specific choices out of the
     // user's profile based on this.client.getUserId();
-    let activeRealms = this.realmServer.availableRealmURLs;
+    let activeRealms = this.realmServer.availableRealmIdentifiers;
 
     await Promise.all(
       activeRealms.map(async (realmURL: string) => {

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

@@ -1468,16 +1468,18 @@ export default class OperatorModeStateService extends Service {
   ): Promise<BoxelContext> {
     let codeMode: BoxelContext['codeMode'] = undefined;
     if (this._state.workspaceChooserOpened) {
-      let userWorkspaces = this.realmServer.userRealmURLs.map((url) => ({
+      let userWorkspaces = this.realmServer.userRealmIdentifiers.map((url) => ({
         url,
         name: this.realm.info(url).name,
         type: 'user-workspace' as const,
       }));
-      let catalogWorkspaces = this.realmServer.catalogRealmURLs.map((url) => ({
-        url,
-        name: this.realm.info(url).name,
-        type: 'catalog-workspace' as const,
-      }));
+      let catalogWorkspaces = this.realmServer.catalogRealmIdentifiers.map(
+        (url) => ({
+          url,
+          name: this.realm.info(url).name,
+          type: 'catalog-workspace' as const,
+        }),
+      );
       let result: BoxelContext = {
         agentId: this.matrixService.agentId,
         submode: 'workspace-chooser',

package/bundled-types/host-app/services/realm-server.ts

@@ -17,7 +17,9 @@ import {
   ensureTrailingSlash,
   SupportedMimeType,
   Deferred,
+  ri,
   testRealmURL,
+  type RealmIdentifier,
   type RealmInfo,
   type JWTPayload,
 } from '@cardstack/runtime-common';
@@ -253,8 +255,8 @@ export default class RealmServerService extends Service {
   }
 
   @cached
-  get availableRealmURLs() {
-    return this.availableRealms.map((r) => r.url);
+  get availableRealmIdentifiers(): RealmIdentifier[] {
+    return this.availableRealms.map((r) => ri(r.url));
   }
 
   assertOwnRealmServer(realmServerURLs: string[]): void {
@@ -338,27 +340,27 @@ export default class RealmServerService extends Service {
   }
 
   @cached
-  get userRealmURLs() {
+  get userRealmIdentifiers(): RealmIdentifier[] {
     return this.availableRealms
       .filter((r) => r.type === 'user')
-      .map((r) => r.url);
+      .map((r) => ri(r.url));
   }
 
   @cached
-  get catalogRealmURLs() {
+  get catalogRealmIdentifiers(): RealmIdentifier[] {
     return this.availableRealms
       .filter((r) => r.type === 'catalog')
-      .map((r) => r.url);
+      .map((r) => ri(r.url));
   }
 
   @cached
-  get displayedCatalogRealmURLs() {
-    return this.catalogRealmURLs;
+  get displayedCatalogRealmIdentifiers(): RealmIdentifier[] {
+    return this.catalogRealmIdentifiers;
   }
 
   @cached
   get availableRealmIndexCardIds() {
-    return this.availableRealmURLs.map((url) => `${url}index`);
+    return this.availableRealmIdentifiers.map((url) => `${url}index`);
   }
 
   async authenticateToAllAccessibleRealms() {
@@ -389,22 +391,22 @@ export default class RealmServerService extends Service {
     }
   }
 
-  async setAvailableRealmURLs(userRealmURLs: string[]) {
+  async setAvailableRealmIdentifiers(userRealmIdentifiers: RealmIdentifier[]) {
     await this._ready.promise;
-    userRealmURLs.forEach((userRealmURL) => {
-      if (!this.availableRealms.find((r) => r.url === userRealmURL)) {
+    userRealmIdentifiers.forEach((userRealmIdentifier) => {
+      if (!this.availableRealms.find((r) => r.url === userRealmIdentifier)) {
         this.availableRealms.push({
           type: 'user',
-          url: userRealmURL,
+          url: userRealmIdentifier,
         });
       }
     });
 
-    // pluck out any user realms that aren't a part of the userRealmsURLs
+    // pluck out any user realms that aren't a part of userRealmIdentifiers
     this.availableRealms
       .filter((r) => r.type === 'user')
       .forEach((realm) => {
-        if (!userRealmURLs.includes(realm.url)) {
+        if (!userRealmIdentifiers.includes(ri(realm.url))) {
           this.availableRealms.splice(
             this.availableRealms.findIndex((r) => r.url === realm.url),
             1,
@@ -414,7 +416,7 @@ export default class RealmServerService extends Service {
   }
 
   async fetchCatalogRealms() {
-    if (this.catalogRealmURLs.length > 0) {
+    if (this.catalogRealmIdentifiers.length > 0) {
       return;
     }
     let response = await this.network.fetch(

package/bundled-types/host-app/services/store.ts

@@ -943,7 +943,7 @@ export default class StoreService extends Service implements StoreInterface {
     let searchRealms =
       normalizedRealms.length > 0
         ? normalizedRealms
-        : this.realmServer.availableRealmURLs;
+        : this.realmServer.availableRealmIdentifiers;
     if (searchRealms.length === 0) {
       if (query.asData) {
         return opts?.includeMeta

package/bundled-types/host-app/utils/card-search/url.ts

@@ -1,3 +1,5 @@
+import type { RealmIdentifier } from '@cardstack/runtime-common';
+
 export function isURLSearchKey(searchKey: string): boolean {
   try {
     new URL(searchKey);
@@ -13,11 +15,13 @@ export function isSearchKeyEmpty(searchKey: string): boolean {
 
 export function resolveSearchKeyAsURL(
   searchKey: string,
-  availableRealmURLs: string[],
+  availableRealmIdentifiers: readonly RealmIdentifier[],
 ): string | undefined {
   if (!isURLSearchKey(searchKey)) {
     return undefined;
   }
-  let maybeIndexCardURL = availableRealmURLs.find((u) => u === searchKey + '/');
+  let maybeIndexCardURL = availableRealmIdentifiers.find(
+    (u) => u === searchKey + '/',
+  );
   return maybeIndexCardURL ?? searchKey;
 }

package/bundled-types/host-tests/helpers/index.gts

@@ -1367,8 +1367,8 @@ async function setupTestRealm({
   }
 
   let realmServer = getService('realm-server');
-  if (!realmServer.availableRealmURLs.includes(realmURL)) {
-    await realmServer.setAvailableRealmURLs([realmURL]);
+  if (!realmServer.availableRealmIdentifiers.includes(ri(realmURL))) {
+    await realmServer.setAvailableRealmIdentifiers([ri(realmURL)]);
   }
 
   return { realm, adapter };