@dxos/client-services 0.6.12 → 0.6.13-main.548ca8d

package/src/packlets/invitations/edge-invitation-handler.ts

@@ -0,0 +1,184 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type MutexGuard, scheduleMicroTask, scheduleTask } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { ed25519Signature } from '@dxos/crypto';
+import { type EdgeHttpClient } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import {
+  EdgeAuthChallengeError,
+  EdgeCallFailedError,
+  type JoinSpaceRequest,
+  type JoinSpaceResponseBody,
+} from '@dxos/protocols';
+import { schema } from '@dxos/protocols/proto';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import {
+  type AdmissionResponse,
+  type AdmissionRequest,
+  type SpaceAdmissionRequest,
+} from '@dxos/protocols/proto/dxos/halo/invitations';
+
+import { type InvitationProtocol } from './invitation-protocol';
+import { type FlowLockHolder, type GuardedInvitationState } from './invitation-state';
+import { tryAcquireBeforeContextDisposed } from './utils';
+
+export interface EdgeInvitationHandlerCallbacks {
+  onInvitationSuccess(response: AdmissionResponse, request: AdmissionRequest): Promise<void>;
+}
+
+export const DEFAULT_REQUEST_RETRY_INTERVAL_MS = 3000;
+export const DEFAULT_REQUEST_RETRY_JITTER_MS = 500;
+
+export type EdgeInvitationConfig = {
+  retryInterval?: number;
+  retryJitter?: number;
+};
+
+export class EdgeInvitationHandler implements FlowLockHolder {
+  private _flowLock: MutexGuard | undefined;
+
+  private readonly _retryInterval: number;
+  private readonly _retryJitter: number;
+
+  constructor(
+    config: EdgeInvitationConfig | undefined,
+    private readonly _client: EdgeHttpClient | undefined,
+    private readonly _callbacks: EdgeInvitationHandlerCallbacks,
+  ) {
+    this._retryInterval = config?.retryInterval ?? DEFAULT_REQUEST_RETRY_INTERVAL_MS;
+    this._retryJitter = config?.retryJitter ?? DEFAULT_REQUEST_RETRY_JITTER_MS;
+  }
+
+  public handle(
+    ctx: Context,
+    guardedState: GuardedInvitationState,
+    protocol: InvitationProtocol,
+    deviceProfile?: DeviceProfileDocument,
+  ) {
+    if (!this._client) {
+      log('edge disabled');
+      return;
+    }
+
+    const invitation = guardedState.current;
+    const spaceId = invitation.spaceId;
+    const canBeHandledByEdge =
+      invitation.authMethod !== Invitation.AuthMethod.SHARED_SECRET &&
+      invitation.type === Invitation.Type.DELEGATED &&
+      invitation.kind === Invitation.Kind.SPACE &&
+      spaceId != null &&
+      SpaceId.isValid(spaceId);
+
+    if (!canBeHandledByEdge) {
+      log('invitation could not be handled by edge', { invitation });
+      return;
+    }
+
+    ctx.onDispose(() => {
+      this._flowLock?.release();
+      this._flowLock = undefined;
+    });
+
+    const tryHandleInvitation = async () => {
+      const admissionRequest = await protocol.createAdmissionRequest(deviceProfile);
+      if (admissionRequest.space) {
+        try {
+          await this._handleSpaceInvitationFlow(ctx, guardedState, admissionRequest.space, spaceId);
+        } catch (error) {
+          if (error instanceof EdgeCallFailedError) {
+            log.info('join space with edge unsuccessful', {
+              reason: error.message,
+              retryable: error.isRetryable,
+              after: error.retryAfterMs ?? this._calculateNextRetryMs(),
+            });
+            if (error.isRetryable) {
+              scheduleTask(ctx, tryHandleInvitation, error.retryAfterMs ?? this._calculateNextRetryMs());
+            }
+          } else {
+            log.info('failed to handle invitation with edge', { error });
+            scheduleTask(ctx, tryHandleInvitation, this._calculateNextRetryMs());
+          }
+        }
+      }
+    };
+    scheduleMicroTask(ctx, tryHandleInvitation);
+  }
+
+  private async _handleSpaceInvitationFlow(
+    ctx: Context,
+    guardedState: GuardedInvitationState,
+    admissionRequest: SpaceAdmissionRequest,
+    spaceId: SpaceId,
+  ) {
+    try {
+      log('edge invitation flow');
+      this._flowLock = await tryAcquireBeforeContextDisposed(ctx, guardedState.mutex);
+      log('edge invitation flow acquired the lock');
+
+      guardedState.set(this, Invitation.State.CONNECTING);
+
+      const response = await this._joinSpaceByInvitation(guardedState, spaceId, {
+        identityKey: admissionRequest.identityKey.toHex(),
+        invitationId: guardedState.current.invitationId,
+      });
+
+      const admissionResponse = await this._mapToAdmissionResponse(response);
+      await this._callbacks.onInvitationSuccess(admissionResponse, { space: admissionRequest });
+    } catch (error) {
+      guardedState.set(this, Invitation.State.ERROR);
+      throw error;
+    } finally {
+      this._flowLock?.release();
+      this._flowLock = undefined;
+    }
+  }
+
+  private async _mapToAdmissionResponse(edgeResponse: JoinSpaceResponseBody): Promise<AdmissionResponse> {
+    const credentialBytes = Buffer.from(edgeResponse.spaceMemberCredential, 'base64');
+    const codec = schema.getCodecForType('dxos.halo.credentials.Credential');
+    return {
+      space: {
+        credential: codec.decode(credentialBytes),
+      },
+    };
+  }
+
+  private async _joinSpaceByInvitation(
+    guardedState: GuardedInvitationState,
+    spaceId: SpaceId,
+    request: JoinSpaceRequest,
+  ): Promise<JoinSpaceResponseBody> {
+    invariant(this._client);
+    try {
+      return await this._client.joinSpaceByInvitation(spaceId, request);
+    } catch (error: any) {
+      if (error instanceof EdgeAuthChallengeError) {
+        guardedState.set(this, Invitation.State.AUTHENTICATING);
+        const publicKey = guardedState.current.guestKeypair?.publicKey;
+        const privateKey = guardedState.current.guestKeypair?.privateKey;
+        if (!privateKey || !publicKey) {
+          throw error;
+        }
+        const signature = await ed25519Signature(privateKey, Buffer.from(error.challenge, 'base64'));
+        request.signature = Buffer.from(signature).toString('base64');
+        return this._client.joinSpaceByInvitation(spaceId, request);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  public hasFlowLock(): boolean {
+    return this._flowLock != null;
+  }
+
+  private _calculateNextRetryMs() {
+    return this._retryInterval + Math.random() * this._retryJitter;
+  }
+}

package/src/packlets/invitations/invitation-guest-extenstion.ts

@@ -12,6 +12,7 @@ import { type Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type InvitationHostService, InvitationOptions } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
+import { type FlowLockHolder } from './invitation-state';
 import { tryAcquireBeforeContextDisposed } from './utils';
 
 const OPTIONS_TIMEOUT = 10_000;
@@ -27,10 +28,13 @@ type InvitationGuestExtensionCallbacks = {
 /**
  * Guest's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationGuestExtension extends RpcExtension<
-  { InvitationHostService: InvitationHostService },
-  { InvitationHostService: InvitationHostService }
-> {
+export class InvitationGuestExtension
+  extends RpcExtension<
+    { InvitationHostService: InvitationHostService },
+    { InvitationHostService: InvitationHostService }
+  >
+  implements FlowLockHolder
+{
   private _ctx = new Context();
   private _remoteOptions?: InvitationOptions;
   private _remoteOptionsTrigger = new Trigger();

package/src/packlets/invitations/invitation-host-extension.ts

@@ -21,6 +21,7 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
+import type { FlowLockHolder } from './invitation-state';
 import { stateToString, tryAcquireBeforeContextDisposed } from './utils';
 
 /// Timeout for the options exchange.
@@ -43,10 +44,13 @@ type InvitationHostExtensionCallbacks = {
 /**
  * Host's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationHostExtension extends RpcExtension<
-  { InvitationHostService: InvitationHostService },
-  { InvitationHostService: InvitationHostService }
-> {
+export class InvitationHostExtension
+  extends RpcExtension<
+    { InvitationHostService: InvitationHostService },
+    { InvitationHostService: InvitationHostService }
+  >
+  implements FlowLockHolder
+{
   /**
    * @internal
    */
@@ -106,13 +110,11 @@ export class InvitationHostExtension extends RpcExtension<
 
         introduce: async (request) => {
           const { profile, invitationId } = request;
-
           const traceId = PublicKey.random().toHex();
           log.trace('dxos.sdk.invitation-handler.host.introduce', trace.begin({ id: traceId }));
 
           const invitation = this._requireActiveInvitation();
           this._assertInvitationState(Invitation.State.CONNECTED);
-
           if (invitationId !== invitation?.invitationId) {
             log.warn('incorrect invitationId', { expected: invitation.invitationId, actual: invitationId });
             this._callbacks.onError(new Error('Incorrect invitationId.'));
@@ -126,7 +128,6 @@ export class InvitationHostExtension extends RpcExtension<
           log('guest introduced themselves', { guestProfile: profile });
           this.guestProfile = profile;
           this._callbacks.onStateUpdate(Invitation.State.READY_FOR_AUTHENTICATION);
-
           this._challenge =
             invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY ? randomBytes(32) : undefined;
 

package/src/packlets/invitations/invitation-state.ts

@@ -0,0 +1,111 @@
+/**
+ * A utility object for serializing invitation state changes by multiple concurrent
+ * invitation flow connections.
+ */
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Mutex, type PushStream } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+import { stateToString } from './utils';
+
+export interface FlowLockHolder {
+  hasFlowLock(): boolean;
+}
+
+export interface GuardedInvitationState {
+  mutex: Mutex;
+  current: Invitation;
+
+  complete(newState: Partial<Invitation>): void;
+  set(lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean;
+  error(lockHolder: FlowLockHolder | null, error: any): boolean;
+}
+
+export const createGuardedInvitationState = (
+  ctx: Context,
+  invitation: Invitation,
+  stream: PushStream<Invitation>,
+): GuardedInvitationState => {
+  // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
+  // deadlocks seem very unlikely because hosts don't initiate multiple connections
+  // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
+  //  A has lock for flow with 1, B has lock for flow with 2
+  //  1 has lock for flow with B, 2 has lock for flow with A
+  // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
+  const mutex = new Mutex();
+  let lastActiveLockHolder: FlowLockHolder | null = null;
+  let currentInvitation = { ...invitation };
+  const isStateChangeAllowed = (lockHolder: FlowLockHolder | null) => {
+    if (ctx.disposed || (lockHolder !== null && mutex.isLocked() && !lockHolder.hasFlowLock())) {
+      return false;
+    }
+    // don't allow transitions from a terminal state unless a new extension acquired mutex
+    // handles a case when error occurs (e.g. connection is closed) after we completed the flow
+    // successfully or already reported another error
+    return lockHolder == null || lastActiveLockHolder !== lockHolder || isNonTerminalState(currentInvitation.state);
+  };
+  return {
+    mutex,
+    get current() {
+      return currentInvitation;
+    },
+    // disposing context prevents any further state updates
+    complete: (newState: Partial<Invitation>) => {
+      currentInvitation = { ...currentInvitation, ...newState };
+      stream.next(currentInvitation);
+      return ctx.dispose();
+    },
+    set: (lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean => {
+      if (isStateChangeAllowed(lockHolder)) {
+        logStateUpdate(currentInvitation, lockHolder, newState);
+        currentInvitation = { ...currentInvitation, state: newState };
+        stream.next(currentInvitation);
+        lastActiveLockHolder = lockHolder;
+        return true;
+      }
+      return false;
+    },
+    error: (lockHolder: FlowLockHolder | null, error: any): boolean => {
+      if (isStateChangeAllowed(lockHolder)) {
+        logStateUpdate(currentInvitation, lockHolder, Invitation.State.ERROR);
+        currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
+        stream.next(currentInvitation);
+        stream.error(error);
+        lastActiveLockHolder = lockHolder;
+        return true;
+      }
+      return false;
+    },
+  };
+};
+
+const logStateUpdate = (invitation: Invitation, actor: any, newState: Invitation.State) => {
+  if (isNonTerminalState(newState)) {
+    log('invitation state update', {
+      actor: actor?.constructor.name,
+      newState: stateToString(newState),
+      oldState: stateToString(invitation.state),
+    });
+  } else {
+    log.info('invitation state update', {
+      actor: actor?.constructor.name,
+      newState: stateToString(newState),
+      oldState: stateToString(invitation.state),
+    });
+  }
+};
+
+const isNonTerminalState = (currentState: Invitation.State): boolean => {
+  return ![
+    Invitation.State.SUCCESS,
+    Invitation.State.ERROR,
+    Invitation.State.CANCELLED,
+    Invitation.State.TIMEOUT,
+    Invitation.State.EXPIRED,
+  ].includes(currentState);
+};

package/src/packlets/invitations/invitations-handler.test.ts

@@ -2,13 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
+import { beforeEach, onTestFinished, describe, expect, test } from 'vitest';
 
 import { type PushStream, sleep, Trigger, waitForCondition } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 import { range } from '@dxos/util';
 
 import { type InvitationProtocol } from './invitation-protocol';
@@ -34,6 +34,7 @@ type StateUpdateSink = PushStream<Invitation> & {
 
 describe('InvitationHandler', () => {
   let testBuilder: TestBuilder;
+
   beforeEach(() => {
     testBuilder = new TestBuilder();
   });
@@ -163,7 +164,7 @@ describe('InvitationHandler', () => {
       expect(guest.ctx.disposed).to.be.true;
     });
 
-    test('guest gives up after trying with three hosts', async () => {
+    test('guest gives up after trying with three hosts', { timeout: 20_000 }, async () => {
       const hosts: PeerSetup[] = [await createPeer()];
       const [host] = hosts;
       const invitation = await createInvitation(host, { multiUse: true });
@@ -181,7 +182,7 @@ describe('InvitationHandler', () => {
 
       await sleep(10);
       expect(guest.sink.lastState).to.eq(Invitation.State.ERROR);
-    }).timeout(20_000);
+    });
 
     test('single host - many guests', async () => {
       const hosts: PeerSetup[] = [await createPeer()];
@@ -256,12 +257,14 @@ describe('InvitationHandler', () => {
       const space = await peer.dataSpaceManager.createSpace();
       spaceKey = space.key;
     }
-    const invitationHandler = new InvitationsHandler(peer.networkManager, {
-      controlHeartbeatInterval: 250, // faster peer failure detection
+    const invitationHandler = new InvitationsHandler(peer.networkManager, undefined, {
+      teleport: { controlHeartbeatInterval: 250 }, // faster peer failure detection
     });
     const protocol = new SpaceInvitationProtocol(peer.dataSpaceManager, peer.identity, peer.keyring, spaceKey);
     const ctx = new Context();
-    afterTest(() => ctx.dispose());
+    onTestFinished(async () => {
+      await ctx.dispose();
+    });
     const sink = newStateUpdateSink();
     return { ctx, sink, peer, protocol, handler: invitationHandler, spaceKey };
   };
@@ -269,14 +272,18 @@ describe('InvitationHandler', () => {
   const hostInvitation = async (setup: PeerSetup, invitation: Invitation) => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    afterTest(() => setup.ctx.dispose());
+    onTestFinished(async () => {
+      await setup.ctx.dispose();
+    });
     setup.handler.handleInvitationFlow(setup.ctx, setup.sink, setup.protocol, invitation);
   };
 
   const acceptInvitation = async (setup: PeerSetup, invitation: Invitation): Promise<Trigger<string>> => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    afterTest(() => setup.ctx.dispose());
+    onTestFinished(async () => {
+      await setup.ctx.dispose();
+    });
     const authCodeInput = new Trigger<string>();
     setup.handler.acceptInvitation(setup.ctx, setup.sink, setup.protocol, invitation, authCodeInput);
     return authCodeInput;

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

@@ -2,10 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Mutex, type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
+import { type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
 import { INVITATION_TIMEOUT } from '@dxos/client-protocol';
 import { type Context, ContextDisposedError } from '@dxos/context';
 import { createKeyPair, sign } from '@dxos/crypto';
+import { type EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -19,17 +20,21 @@ import { type ExtensionContext, type TeleportExtension, type TeleportParams } fr
 import { trace as _trace } from '@dxos/tracing';
 import { ComplexSet } from '@dxos/util';
 
+import { type EdgeInvitationConfig, EdgeInvitationHandler } from './edge-invitation-handler';
 import { InvitationGuestExtension } from './invitation-guest-extenstion';
 import { InvitationHostExtension, isAuthenticationRequired, MAX_OTP_ATTEMPTS } from './invitation-host-extension';
 import { type InvitationProtocol } from './invitation-protocol';
+import { createGuardedInvitationState } from './invitation-state';
 import { InvitationTopology } from './invitation-topology';
-import { stateToString } from './utils';
 
 const metrics = _trace.metrics;
 
 const MAX_DELEGATED_INVITATION_HOST_TRIES = 3;
 
-type InvitationExtension = InvitationHostExtension | InvitationGuestExtension;
+export type InvitationConnectionParams = {
+  teleport: Partial<TeleportParams>;
+  edgeInvitations?: EdgeInvitationConfig;
+};
 
 /**
  * Generic handler for Halo and Space invitations.
@@ -65,7 +70,8 @@ export class InvitationsHandler {
    */
   constructor(
     private readonly _networkManager: SwarmNetworkManager,
-    private readonly _defaultTeleportParams?: Partial<TeleportParams>,
+    private readonly _edgeClient?: EdgeHttpClient,
+    private readonly _connectionParams?: InvitationConnectionParams,
   ) {}
 
   handleInvitationFlow(
@@ -75,7 +81,7 @@ export class InvitationsHandler {
     invitation: Invitation,
   ): void {
     metrics.increment('dxos.invitation.created');
-    const guardedState = this._createGuardedState(ctx, invitation, stream);
+    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
       const extension = new InvitationHostExtension(guardedState.mutex, {
@@ -208,7 +214,7 @@ export class InvitationsHandler {
     }
 
     const triedPeersIds = new ComplexSet(PublicKey.hash);
-    const guardedState = this._createGuardedState(ctx, invitation, stream);
+    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
 
     const shouldCancelInvitationFlow = (extension: InvitationGuestExtension) => {
       const isLockedByAnotherConnection = guardedState.mutex.isLocked() && !extension.hasFlowLock();
@@ -310,7 +316,7 @@ export class InvitationsHandler {
 
               // 5. Success.
               log('admitted by host', { ...protocol.toJSON() });
-              await guardedState.complete({
+              guardedState.complete({
                 ...guardedState.current,
                 ...result,
                 state: Invitation.State.SUCCESS,
@@ -346,6 +352,15 @@ export class InvitationsHandler {
       return extension;
     };
 
+    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
+      onInvitationSuccess: async (admissionResponse, admissionRequest) => {
+        const result = await protocol.accept(admissionResponse, admissionRequest);
+        log('admitted by edge', { ...protocol.toJSON() });
+        guardedState.complete({ ...guardedState.current, ...result, state: Invitation.State.SUCCESS });
+      },
+    });
+    edgeInvitationHandler.handle(ctx, guardedState, protocol, deviceProfile);
+
     scheduleTask(ctx, async () => {
       const error = protocol.checkInvitation(invitation);
       if (error) {
@@ -389,7 +404,7 @@ export class InvitationsHandler {
       topic: invitation.swarmKey,
       protocolProvider: createTeleportProtocolFactory(async (teleport) => {
         teleport.addExtension('dxos.halo.invitations', extensionFactory());
-      }, this._defaultTeleportParams),
+      }, this._connectionParams?.teleport),
       topology: new InvitationTopology(role),
       label,
     });
@@ -397,90 +412,6 @@ export class InvitationsHandler {
     return swarmConnection;
   }
 
-  /**
-   * A utility object for serializing invitation state changes by multiple concurrent
-   * invitation flow connections.
-   */
-  private _createGuardedState(ctx: Context, invitation: Invitation, stream: PushStream<Invitation>) {
-    // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
-    // deadlocks seem very unlikely because hosts don't initiate multiple connections
-    // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
-    //  A has lock for flow with 1, B has lock for flow with 2
-    //  1 has lock for flow with B, 2 has lock for flow with A
-    // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
-    const mutex = new Mutex();
-    let lastActiveExtension: any = null;
-    let currentInvitation = { ...invitation };
-    const isStateChangeAllowed = (extension: InvitationExtension | null) => {
-      if (ctx.disposed || (extension !== null && mutex.isLocked() && !extension.hasFlowLock())) {
-        return false;
-      }
-      // don't allow transitions from a terminal state unless a new extension acquired mutex
-      // handles a case when error occurs (e.g. connection is closed) after we completed the flow
-      // successfully or already reported another error
-      return extension == null || lastActiveExtension !== extension || this._isNotTerminal(currentInvitation.state);
-    };
-    return {
-      mutex,
-      get current() {
-        return currentInvitation;
-      },
-      // disposing context prevents any further state updates
-      complete: (newState: Partial<Invitation>) => {
-        currentInvitation = { ...currentInvitation, ...newState };
-        stream.next(currentInvitation);
-        return ctx.dispose();
-      },
-      set: (extension: InvitationExtension | null, newState: Invitation.State): boolean => {
-        if (isStateChangeAllowed(extension)) {
-          this._logStateUpdate(currentInvitation, extension, newState);
-          currentInvitation = { ...currentInvitation, state: newState };
-          stream.next(currentInvitation);
-          lastActiveExtension = extension;
-          return true;
-        }
-        return false;
-      },
-      error: (extension: InvitationExtension | null, error: any): boolean => {
-        if (isStateChangeAllowed(extension)) {
-          this._logStateUpdate(currentInvitation, extension, Invitation.State.ERROR);
-          currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
-          stream.next(currentInvitation);
-          stream.error(error);
-          lastActiveExtension = extension;
-          return true;
-        }
-        return false;
-      },
-    };
-  }
-
-  private _logStateUpdate(invitation: Invitation, actor: any, newState: Invitation.State) {
-    if (this._isNotTerminal(newState)) {
-      log('invitation state update', {
-        actor: actor?.constructor.name,
-        newState: stateToString(newState),
-        oldState: stateToString(invitation.state),
-      });
-    } else {
-      log.info('invitation state update', {
-        actor: actor?.constructor.name,
-        newState: stateToString(newState),
-        oldState: stateToString(invitation.state),
-      });
-    }
-  }
-
-  private _isNotTerminal(currentState: Invitation.State): boolean {
-    return ![
-      Invitation.State.SUCCESS,
-      Invitation.State.ERROR,
-      Invitation.State.CANCELLED,
-      Invitation.State.TIMEOUT,
-      Invitation.State.EXPIRED,
-    ].includes(currentState);
-  }
-
   private async _handleGuestOtpAuth(
     extension: InvitationGuestExtension,
     setState: (newState: Invitation.State) => void,

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

@@ -2,20 +2,21 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { onTestFinished, describe, expect, test } from 'vitest';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest, describe, test } from '@dxos/test';
 
 import { type ServiceContext } from '../services';
 import { createIdentity, createPeers } from '../testing';
 import { acceptInvitation, createInvitation, performInvitation } from '../testing/invitation-utils';
 
 const closeAfterTest = async (peer: ServiceContext) => {
-  afterTest(() => peer.close());
+  onTestFinished(async () => {
+    await peer.close();
+  });
   return peer;
 };
 

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

@@ -60,9 +60,13 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
   }
 
   getInvitationContext(): Partial<Invitation> & Pick<Invitation, 'kind'> {
+    invariant(this._spaceKey);
+    const space = this._spaceManager.spaces.get(this._spaceKey);
+    invariant(space);
     return {
       kind: Invitation.Kind.SPACE,
       spaceKey: this._spaceKey,
+      spaceId: space.id,
     };
   }