@dxos/client-services 0.4.10-main.e6ba7bc → 0.4.10-main.e96274c

package/src/packlets/invitations/invitations-manager.ts

@@ -2,27 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Event, PushStream } from '@dxos/async';
-import {
-  type AuthenticatingInvitation,
-  AUTHENTICATION_CODE_LENGTH,
-  CancellableInvitation,
-  INVITATION_TIMEOUT,
-} from '@dxos/client-protocol';
-import { Context } from '@dxos/context';
-import { generatePasscode } from '@dxos/credentials';
+import { Event } from '@dxos/async';
+import type { AuthenticatingInvitation, CancellableInvitation } from '@dxos/client-protocol';
+import { type Context } from '@dxos/context';
 import { hasInvitationExpired, type MetadataStore } from '@dxos/echo-pipeline';
 import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
   type AcceptInvitationRequest,
+  type Invitation,
   type AuthenticationRequest,
-  Invitation,
 } from '@dxos/protocols/proto/dxos/client/services';
 
 import type { InvitationProtocol } from './invitation-protocol';
-import { createAdmissionKeypair, type InvitationsHandler } from './invitations-handler';
+import type { InvitationsHandler } from './invitations-handler';
 
 /**
  * Entry point for creating and accepting invitations, keeps track of existing invitation set and
@@ -43,44 +36,36 @@ export class InvitationsManager {
 
   constructor(
     private readonly _invitationsHandler: InvitationsHandler,
-    private readonly _getHandler: (invitation: Partial<Invitation> & Pick<Invitation, 'kind'>) => InvitationProtocol,
+    private readonly _getHandler: (invitation: Invitation) => InvitationProtocol,
     private readonly _metadataStore: MetadataStore,
   ) {}
 
-  async createInvitation(options: Partial<Invitation> & Pick<Invitation, 'kind'>): Promise<CancellableInvitation> {
-    if (options.invitationId) {
-      const existingInvitation = this._createInvitations.get(options.invitationId);
-      if (existingInvitation) {
-        return existingInvitation;
-      }
+  createInvitation(options: Invitation): CancellableInvitation {
+    const existingInvitation = this._createInvitations.get(options.invitationId);
+    if (existingInvitation) {
+      return existingInvitation;
     }
 
     const handler = this._getHandler(options);
-    const invitation = this._createInvitation(handler, options);
-    const { ctx, stream, observableInvitation } = this._createObservableInvitation(handler, invitation);
+    const invitation = this._invitationsHandler.createInvitation(handler, options);
+    this._createInvitations.set(invitation.get().invitationId, invitation);
+    this.invitationCreated.emit(invitation.get());
+
+    const saveInvitationTask = invitation.get().persistent
+      ? this._safePersistInBackground(invitation)
+      : Promise.resolve();
 
-    this._createInvitations.set(invitation.invitationId, observableInvitation);
-    this.invitationCreated.emit(invitation);
     // onComplete is called on cancel, expiration, or redemption of a single-use invitation
-    this._onInvitationComplete(observableInvitation, async () => {
-      this._createInvitations.delete(observableInvitation.get().invitationId);
-      this.removedCreated.emit(observableInvitation.get());
-      if (observableInvitation.get().persistent) {
-        await this._safeDeleteInvitation(observableInvitation.get());
+    this._onInvitationComplete(invitation, async () => {
+      this._createInvitations.delete(invitation.get().invitationId);
+      this.removedCreated.emit(invitation.get());
+      if (invitation.get().persistent) {
+        await saveInvitationTask;
+        await this._safeDeleteInvitation(invitation.get());
       }
     });
 
-    try {
-      await this._persistIfRequired(handler, stream, invitation);
-    } catch (err) {
-      log.catch(err);
-      await observableInvitation.cancel();
-      return observableInvitation;
-    }
-
-    this._invitationsHandler.handleInvitationFlow(ctx, stream, handler, observableInvitation.get());
-
-    return observableInvitation;
+    return invitation;
   }
 
   async loadPersistentInvitations(): Promise<{ invitations: Invitation[] }> {
@@ -93,13 +78,12 @@ export class InvitationsManager {
       // get saved persistent invitations, filter and remove from storage those that have expired.
       const freshInvitations = persistentInvitations.filter((invitation) => !hasInvitationExpired(invitation));
 
-      const loadTasks = freshInvitations.map((persistentInvitation) => {
+      const cInvitations = freshInvitations.map((persistentInvitation) => {
         invariant(!this._createInvitations.get(persistentInvitation.invitationId), 'invitation already exists');
-        return this.createInvitation({ ...persistentInvitation, persistent: false });
+        return this.createInvitation({ ...persistentInvitation, persistent: false }).get();
       });
-      const cInvitations = await Promise.all(loadTasks);
 
-      return { invitations: cInvitations.map((invitation) => invitation.get()) };
+      return { invitations: cInvitations };
     } catch (err) {
       log.catch(err);
       return { invitations: [] };
@@ -179,78 +163,20 @@ export class InvitationsManager {
     }
   }
 
-  private _createInvitation(protocol: InvitationProtocol, options?: Partial<Invitation>): Invitation {
-    const {
-      invitationId = PublicKey.random().toHex(),
-      type = Invitation.Type.INTERACTIVE,
-      authMethod = Invitation.AuthMethod.SHARED_SECRET,
-      state = Invitation.State.INIT,
-      timeout = INVITATION_TIMEOUT,
-      swarmKey = PublicKey.random(),
-      persistent = options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY, // default no not storing keypairs
-      created = new Date(),
-      guestKeypair = undefined,
-      lifetime = 86400, // 1 day,
-      multiUse = false,
-    } = options ?? {};
-    const authCode =
-      options?.authCode ??
-      (authMethod === Invitation.AuthMethod.SHARED_SECRET ? generatePasscode(AUTHENTICATION_CODE_LENGTH) : undefined);
-
-    return {
-      invitationId,
-      type,
-      authMethod,
-      state,
-      swarmKey,
-      authCode,
-      timeout,
-      persistent: persistent && type !== Invitation.Type.DELEGATED, // delegated invitations are persisted in control feed
-      guestKeypair:
-        guestKeypair ?? (authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY ? createAdmissionKeypair() : undefined),
-      created,
-      lifetime,
-      multiUse,
-      delegationCredentialId: options?.delegationCredentialId,
-      ...protocol.getInvitationContext(),
-    } satisfies Invitation;
-  }
-
-  private _createObservableInvitation(handler: InvitationProtocol, invitation: Invitation) {
-    const stream = new PushStream<Invitation>();
-    const ctx = new Context({
-      onError: (err) => {
-        stream.error(err);
-        void ctx.dispose();
-      },
-    });
-    ctx.onDispose(() => {
-      log('complete', { ...handler.toJSON() });
-      stream.complete();
-    });
-    const observableInvitation = new CancellableInvitation({
-      initialInvitation: invitation,
-      subscriber: stream.observable,
-      onCancel: async () => {
-        stream.next({ ...invitation, state: Invitation.State.CANCELLED });
-        await ctx.dispose();
-      },
+  private _safePersistInBackground(invitation: CancellableInvitation): Promise<void> {
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        try {
+          await this._metadataStore.addInvitation(invitation.get());
+          this.saved.emit(invitation.get());
+        } catch (err: any) {
+          log.catch(err);
+          await invitation.cancel();
+        } finally {
+          resolve();
+        }
+      });
     });
-    return { ctx, stream, observableInvitation };
-  }
-
-  private async _persistIfRequired(
-    handler: InvitationProtocol,
-    changeStream: PushStream<Invitation>,
-    invitation: Invitation,
-  ): Promise<void> {
-    if (invitation.type === Invitation.Type.DELEGATED && invitation.delegationCredentialId == null) {
-      const delegationCredentialId = await handler.delegate(invitation);
-      changeStream.next({ ...invitation, delegationCredentialId });
-    } else if (invitation.persistent) {
-      await this._metadataStore.addInvitation(invitation);
-      this.saved.emit(invitation);
-    }
   }
 
   private async _safeDeleteInvitation(invitation: Invitation): Promise<void> {

package/src/packlets/invitations/invitations-service.ts

@@ -27,11 +27,9 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   createInvitation(options: Invitation): Stream<Invitation> {
+    const invitation = this._invitationsManager.createInvitation(options);
     return new Stream<Invitation>(({ next, close }) => {
-      void this._invitationsManager
-        .createInvitation(options)
-        .then((invitation) => invitation.subscribe(next, close, close))
-        .catch(close);
+      invitation.subscribe(next, close, close);
     });
   }
 

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -2,11 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import {
-  createAdmissionCredentials,
-  createDelegatedSpaceInvitationCredential,
-  getCredentialAssertion,
-} from '@dxos/credentials';
+import { createAdmissionCredentials, getCredentialAssertion } from '@dxos/credentials';
 import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -15,7 +11,7 @@ import { log } from '@dxos/log';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
   type AdmissionResponse,
@@ -47,11 +43,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  async admit(
-    invitation: Invitation,
-    request: AdmissionRequest,
-    guestProfile?: ProfileDocument | undefined,
-  ): Promise<AdmissionResponse> {
+  async admit(request: AdmissionRequest, guestProfile?: ProfileDocument | undefined): Promise<AdmissionResponse> {
     invariant(this._spaceKey);
     const space = await this._spaceManager.spaces.get(this._spaceKey);
     invariant(space);
@@ -67,7 +59,6 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
       space.key,
       space.inner.genesisFeedKey,
       guestProfile,
-      invitation.delegationCredentialId,
     );
 
     // TODO(dmaretskyi): Refactor.
@@ -85,39 +76,6 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  async delegate(invitation: Invitation): Promise<PublicKey> {
-    invariant(this._spaceKey);
-    const space = await this._spaceManager.spaces.get(this._spaceKey);
-    invariant(space);
-    if (invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY) {
-      invariant(invitation.guestKeypair?.publicKey);
-    }
-
-    log('writing delegate space invitation', { host: this._signingContext.deviceKey, id: invitation.invitationId });
-    const credential = await createDelegatedSpaceInvitationCredential(
-      this._signingContext.credentialSigner,
-      space.key,
-      {
-        invitationId: invitation.invitationId,
-        authMethod: invitation.authMethod,
-        swarmKey: invitation.swarmKey,
-        role: SpaceMember.Role.ADMIN,
-        expiresOn: invitation.lifetime
-          ? new Date((invitation.created?.getTime() ?? Date.now()) + invitation.lifetime)
-          : undefined,
-        multiUse: invitation.multiUse ?? false,
-        guestKey:
-          invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY
-            ? invitation.guestKeypair!.publicKey
-            : undefined,
-      },
-    );
-
-    invariant(credential.credential);
-    await writeMessages(space.inner.controlPipeline.writer, [credential]);
-    return credential.credential.credential.id!;
-  }
-
   checkInvitation(invitation: Partial<Invitation>) {
     if (invitation.spaceKey && this._spaceManager.spaces.has(invitation.spaceKey)) {
       return new AlreadyJoinedError('Already joined space.');

package/src/packlets/services/service-context.ts

@@ -32,7 +32,7 @@ import {
   type IdentityManagerRuntimeParams,
   type JoinIdentityParams,
 } from '../identity';
-import { createSelectedDocumentsIterator } from '../indexing';
+import { createDocumentsIterator, createSelectedDocumentsIterator } from '../indexing';
 import {
   DeviceInvitationProtocol,
   InvitationsHandler,
@@ -131,10 +131,10 @@ export class ServiceContext extends Resource {
     });
 
     this.indexer = new Indexer({
-      db: this.level,
       indexStore: new IndexStore({ db: level.sublevel('index-storage') }),
       metadataStore: this.indexMetadata,
       loadDocuments: createSelectedDocumentsIterator(this.automergeHost),
+      getAllDocuments: createDocumentsIterator(this.automergeHost),
     });
 
     this.invitations = new InvitationsHandler(this.networkManager);
@@ -256,7 +256,6 @@ export class ServiceContext extends Resource {
       signingContext,
       this.feedStore,
       this.automergeHost,
-      this.invitationsManager,
       this._runtimeParams as DataSpaceManagerRuntimeParams,
     );
     await this.dataSpaceManager.open();

package/src/packlets/spaces/data-space-manager.ts

@@ -4,7 +4,7 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context, cancelWithContext } from '@dxos/context';
-import { getCredentialAssertion, type CredentialSigner, type DelegateInvitationCredential } from '@dxos/credentials';
+import { getCredentialAssertion, type CredentialSigner } from '@dxos/credentials';
 import { type AutomergeHost, type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
@@ -12,11 +12,10 @@ import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
-import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
+import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
@@ -24,7 +23,6 @@ import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
-import { type InvitationsManager } from '../invitations';
 
 const PRESENCE_ANNOUNCE_INTERVAL = 10_000;
 const PRESENCE_OFFLINE_TIMEOUT = 20_000;
@@ -80,7 +78,6 @@ export class DataSpaceManager {
     private readonly _signingContext: SigningContext,
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _automergeHost: AutomergeHost,
-    private readonly _invitationsManager: InvitationsManager,
     params?: DataSpaceManagerRuntimeParams,
   ) {
     const {
@@ -250,9 +247,6 @@ export class DataSpaceManager {
         log.warn('auth failure');
       },
       memberKey: this._signingContext.identityKey,
-      onDelegatedInvitationStatusChange: (invitation, isActive) => {
-        return this._handleInvitationStatusChange(dataSpace, invitation, isActive);
-      },
     });
     controlFeed && (await space.setControlFeed(controlFeed));
     dataFeed && (await space.setDataFeed(dataFeed));
@@ -273,7 +267,6 @@ export class DataSpaceManager {
         afterReady: async () => {
           log('after space ready', { space: space.key, open: this._isOpen });
           if (this._isOpen) {
-            await this._createDelegatedInvitations(dataSpace, [...space.spaceState.invitations.entries()]);
             this.updated.emit();
           }
         },
@@ -296,43 +289,4 @@ export class DataSpaceManager {
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }
-
-  private async _handleInvitationStatusChange(
-    dataSpace: DataSpace | undefined,
-    delegatedInvitation: DelegateInvitationCredential,
-    isActive: boolean,
-  ): Promise<void> {
-    if (dataSpace?.state !== SpaceState.READY) {
-      return;
-    }
-    if (isActive) {
-      await this._createDelegatedInvitations(dataSpace, [
-        [delegatedInvitation.credentialId, delegatedInvitation.invitation],
-      ]);
-    } else {
-      await this._invitationsManager.cancelInvitation(delegatedInvitation.invitation);
-    }
-  }
-
-  private async _createDelegatedInvitations(
-    space: DataSpace,
-    invitations: Array<[PublicKey, DelegateSpaceInvitation]>,
-  ): Promise<void> {
-    const tasks = invitations.map(([credentialId, invitation]) => {
-      return this._invitationsManager.createInvitation({
-        type: Invitation.Type.DELEGATED,
-        kind: Invitation.Kind.SPACE,
-        spaceKey: space.key,
-        authMethod: invitation.authMethod,
-        invitationId: invitation.invitationId,
-        swarmKey: invitation.swarmKey,
-        guestKeypair: invitation.guestKey ? { publicKey: invitation.guestKey } : undefined,
-        lifetime: invitation.expiresOn ? invitation.expiresOn.getTime() - Date.now() : undefined,
-        multiUse: invitation.multiUse,
-        delegationCredentialId: credentialId,
-        persistent: false,
-      });
-    });
-    await Promise.all(tasks);
-  }
 }

package/src/packlets/testing/invitation-utils.ts

@@ -60,149 +60,146 @@ export const performInvitation = ({
   const guestComplete = new Trigger<Result>();
   const authCode = new Trigger<string>();
 
-  void createInvitation(host, options).then((hostObservable) => {
-    hostObservable.subscribe(
-      async (hostInvitation: Invitation) => {
-        switch (hostInvitation.state) {
-          case Invitation.State.CONNECTING: {
-            if (hooks?.host?.onConnecting?.(hostObservable)) {
-              break;
-            }
-            const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
-            guestObservable.subscribe(
-              async (guestInvitation: Invitation) => {
-                switch (guestInvitation.state) {
-                  case Invitation.State.CONNECTING: {
-                    if (hooks?.guest?.onConnecting?.(guestObservable)) {
-                      break;
-                    }
-                    invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
+  const hostObservable = createInvitation(host, options);
+  hostObservable.subscribe(
+    async (hostInvitation: Invitation) => {
+      switch (hostInvitation.state) {
+        case Invitation.State.CONNECTING: {
+          if (hooks?.host?.onConnecting?.(hostObservable)) {
+            break;
+          }
+          const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
+          guestObservable.subscribe(
+            async (guestInvitation: Invitation) => {
+              switch (guestInvitation.state) {
+                case Invitation.State.CONNECTING: {
+                  if (hooks?.guest?.onConnecting?.(guestObservable)) {
                     break;
                   }
+                  invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
+                  break;
+                }
 
-                  case Invitation.State.CONNECTED: {
-                    hooks?.guest?.onConnected?.(guestObservable);
-                    break;
-                  }
+                case Invitation.State.CONNECTED: {
+                  hooks?.guest?.onConnected?.(guestObservable);
+                  break;
+                }
 
-                  case Invitation.State.READY_FOR_AUTHENTICATION: {
-                    if (hooks?.guest?.onReady?.(guestObservable)) {
-                      break;
-                    }
-                    await guestObservable.authenticate(await authCode.wait());
+                case Invitation.State.READY_FOR_AUTHENTICATION: {
+                  if (hooks?.guest?.onReady?.(guestObservable)) {
                     break;
                   }
+                  await guestObservable.authenticate(await authCode.wait());
+                  break;
+                }
 
-                  case Invitation.State.AUTHENTICATING: {
-                    hooks?.guest?.onAuthenticating?.(guestObservable);
-                    break;
-                  }
+                case Invitation.State.AUTHENTICATING: {
+                  hooks?.guest?.onAuthenticating?.(guestObservable);
+                  break;
+                }
 
-                  case Invitation.State.SUCCESS: {
-                    if (hooks?.guest?.onSuccess?.(guestObservable)) {
-                      break;
-                    }
-                    guestComplete.wake({ invitation: guestInvitation });
+                case Invitation.State.SUCCESS: {
+                  if (hooks?.guest?.onSuccess?.(guestObservable)) {
                     break;
                   }
+                  guestComplete.wake({ invitation: guestInvitation });
+                  break;
+                }
 
-                  case Invitation.State.CANCELLED: {
-                    if (hooks?.guest?.onCancelled?.(guestObservable)) {
-                      break;
-                    }
-                    guestComplete.wake({ invitation: guestInvitation });
+                case Invitation.State.CANCELLED: {
+                  if (hooks?.guest?.onCancelled?.(guestObservable)) {
                     break;
                   }
+                  guestComplete.wake({ invitation: guestInvitation });
+                  break;
+                }
 
-                  case Invitation.State.TIMEOUT: {
-                    if (hooks?.guest?.onTimeout?.(guestObservable)) {
-                      return;
-                    }
-                    guestComplete.wake({ invitation: guestInvitation });
+                case Invitation.State.TIMEOUT: {
+                  if (hooks?.guest?.onTimeout?.(guestObservable)) {
+                    return;
                   }
+                  guestComplete.wake({ invitation: guestInvitation });
                 }
-              },
-              (error: Error) => {
-                if (hooks?.guest?.onError?.(guestObservable)) {
-                  return;
-                }
-                guestComplete.wake({ error });
-              },
-            );
-            break;
-          }
+              }
+            },
+            (error: Error) => {
+              if (hooks?.guest?.onError?.(guestObservable)) {
+                return;
+              }
+              guestComplete.wake({ error });
+            },
+          );
+          break;
+        }
 
-          case Invitation.State.CONNECTED: {
-            hooks?.host?.onConnected?.(hostObservable);
-            break;
-          }
+        case Invitation.State.CONNECTED: {
+          hooks?.host?.onConnected?.(hostObservable);
+          break;
+        }
 
-          case Invitation.State.READY_FOR_AUTHENTICATION: {
-            if (hooks?.host?.onReady?.(hostObservable)) {
-              break;
-            }
-            if (hostInvitation.authCode) {
-              authCode.wake(hostInvitation.authCode);
-            }
+        case Invitation.State.READY_FOR_AUTHENTICATION: {
+          if (hooks?.host?.onReady?.(hostObservable)) {
             break;
           }
-
-          case Invitation.State.AUTHENTICATING: {
-            hooks?.host?.onAuthenticating?.(hostObservable);
-            break;
+          if (hostInvitation.authCode) {
+            authCode.wake(hostInvitation.authCode);
           }
+          break;
+        }
+
+        case Invitation.State.AUTHENTICATING: {
+          hooks?.host?.onAuthenticating?.(hostObservable);
+          break;
+        }
 
-          case Invitation.State.SUCCESS: {
-            if (hooks?.host?.onSuccess?.(hostObservable)) {
-              break;
-            }
-            hostComplete.wake({ invitation: hostInvitation });
+        case Invitation.State.SUCCESS: {
+          if (hooks?.host?.onSuccess?.(hostObservable)) {
             break;
           }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
+        }
 
-          case Invitation.State.CANCELLED: {
-            if (hooks?.host?.onCancelled?.(hostObservable)) {
-              break;
-            }
-            hostComplete.wake({ invitation: hostInvitation });
+        case Invitation.State.CANCELLED: {
+          if (hooks?.host?.onCancelled?.(hostObservable)) {
             break;
           }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
+        }
 
-          case Invitation.State.TIMEOUT: {
-            if (hooks?.host?.onTimeout?.(hostObservable)) {
-              break;
-            }
-            hostComplete.wake({ invitation: hostInvitation });
+        case Invitation.State.TIMEOUT: {
+          if (hooks?.host?.onTimeout?.(hostObservable)) {
             break;
           }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
         }
-      },
-      (error: Error) => {
-        if (hooks?.host?.onError?.(hostObservable)) {
-          return;
-        }
-        hostComplete.wake({ error });
-      },
-    );
-  });
+      }
+    },
+    (error: Error) => {
+      if (hooks?.host?.onError?.(hostObservable)) {
+        return;
+      }
+      hostComplete.wake({ error });
+    },
+  );
 
   return [hostComplete.wait(), guestComplete.wait()];
 };
 
-const createInvitation = async (
+const createInvitation = (
   host: ServiceContext | InvitationHost,
   options?: Partial<Invitation>,
-): Promise<CancellableInvitation> => {
+): CancellableInvitation => {
   options ??= {
     authMethod: Invitation.AuthMethod.NONE,
     ...(options ?? {}),
   };
 
   if (host instanceof ServiceContext) {
-    return host.invitationsManager.createInvitation({
-      kind: Invitation.Kind.SPACE,
-      ...options,
-    });
+    const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
+    return host.invitations.createInvitation(hostHandler, options);
   }
 
   return host.share(options);