@dxos/client-services 0.6.13 → 0.6.14-main.1366248

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

@@ -0,0 +1,112 @@
+/**
+ * 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>) => {
+      logStateUpdate(currentInvitation, undefined, invitation.state);
+      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, 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, error?: Error) => {
+  const logContext = {
+    invitationId: invitation.invitationId,
+    actor: actor?.constructor.name,
+    newState: stateToString(newState),
+    oldState: stateToString(invitation.state),
+    error: error?.message,
+    errorStack: error?.stack,
+  };
+  if (isNonTerminalState(newState)) {
+    log.verbose('dxos.sdk.invitations-handler.state.update', logContext);
+  } else {
+    log.info('dxos.sdk.invitations-handler.state.update', logContext);
+  }
+};
+
+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();
   });
@@ -70,7 +71,7 @@ describe('InvitationHandler', () => {
 
       await guest.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
       await sleep(200);
-      await host.sink.waitFor(Invitation.State.TIMEOUT);
+      await host.sink.waitFor(Invitation.State.CONNECTING);
       await guest.sink.waitFor(Invitation.State.TIMEOUT);
 
       await sleep(10);
@@ -90,7 +91,7 @@ describe('InvitationHandler', () => {
 
       await guest.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
       await guest.peer.networkManager.close();
-      await host.sink.waitFor(Invitation.State.ERROR);
+      await host.sink.waitFor(Invitation.State.CONNECTING);
 
       await sleep(10);
       expect(host.ctx.disposed).to.be.false;
@@ -133,7 +134,7 @@ describe('InvitationHandler', () => {
       const host = await createPeer();
       const invitation = await createInvitation(host, { multiUse: true });
       await hostInvitation(host, invitation);
-      const anotherHost = await createNewHost(invitation);
+      await createNewHost(invitation);
 
       const guest = await createPeer(host.spaceKey);
       const codeInput = await failAuth(guest, invitation);
@@ -142,9 +143,6 @@ describe('InvitationHandler', () => {
         await sleep(10);
       }
       await guest.sink.waitFor(Invitation.State.SUCCESS);
-
-      const hostFailed = [host, anotherHost].map((h) => h.sink.hasState(0, Invitation.State.ERROR));
-      expect(hostFailed.sort()).to.deep.eq([false, true]);
     });
 
     test('single guest - many hosts', async () => {
@@ -163,7 +161,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 +179,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 +254,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 +269,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(
@@ -74,8 +80,14 @@ export class InvitationsHandler {
     protocol: InvitationProtocol,
     invitation: Invitation,
   ): void {
-    metrics.increment('dxos.invitation.created');
-    const guardedState = this._createGuardedState(ctx, invitation, stream);
+    log.verbose('dxos.sdk.invitations-handler.handleInvitationFlow', {
+      state: invitation.state,
+      invitationId: invitation.invitationId,
+      kind: invitation.kind,
+      type: invitation.type,
+    });
+    metrics.increment('dxos.invitation.host');
+    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
       const extension = new InvitationHostExtension(guardedState.mutex, {
@@ -84,12 +96,18 @@ export class InvitationsHandler {
         },
 
         onStateUpdate: (newState: Invitation.State): Invitation => {
-          guardedState.set(extension, newState);
+          if (newState !== Invitation.State.ERROR && newState !== Invitation.State.TIMEOUT) {
+            guardedState.set(extension, newState);
+          }
           return guardedState.current;
         },
 
         admit: async (admissionRequest) => {
           try {
+            log.verbose('dxos.sdk.invitations-handler.host.admit', {
+              invitationId: invitation.invitationId,
+              ...protocol.toJSON(),
+            });
             const deviceKey = admissionRequest.device?.deviceKey ?? admissionRequest.space?.deviceKey;
             invariant(deviceKey);
             const admissionResponse = await protocol.admit(invitation, admissionRequest, extension.guestProfile);
@@ -109,7 +127,7 @@ export class InvitationsHandler {
           let admitted = false;
           connectionCtx.onDispose(() => {
             if (!admitted) {
-              guardedState.error(extension, new ContextDisposedError());
+              guardedState.set(extension, Invitation.State.CONNECTING);
             }
           });
 
@@ -117,9 +135,9 @@ export class InvitationsHandler {
             const traceId = PublicKey.random().toHex();
             try {
               log.trace('dxos.sdk.invitations-handler.host.onOpen', trace.begin({ id: traceId }));
-              log('connected', { ...protocol.toJSON() });
+              log.verbose('connected', { ...protocol.toJSON() });
               const deviceKey = await extension.completedTrigger.wait({ timeout: invitation.timeout });
-              log('admitted guest', { guest: deviceKey, ...protocol.toJSON() });
+              log.verbose('admitted guest', { guest: deviceKey, ...protocol.toJSON() });
               guardedState.set(extension, Invitation.State.SUCCESS);
               metrics.increment('dxos.invitation.success');
               log.trace('dxos.sdk.invitations-handler.host.onOpen', trace.end({ id: traceId }));
@@ -129,13 +147,14 @@ export class InvitationsHandler {
                 await ctx.dispose();
               }
             } catch (err: any) {
+              const stateChanged = guardedState.set(extension, Invitation.State.CONNECTING);
               if (err instanceof TimeoutError) {
-                if (guardedState.set(extension, Invitation.State.TIMEOUT)) {
+                if (stateChanged) {
                   metrics.increment('dxos.invitation.timeout');
-                  log('timeout', { ...protocol.toJSON() });
+                  log.verbose('timeout', { ...protocol.toJSON() });
                 }
               } else {
-                if (guardedState.error(extension, err)) {
+                if (stateChanged) {
                   metrics.increment('dxos.invitation.failed');
                   log.error('failed', err);
                 }
@@ -147,17 +166,18 @@ export class InvitationsHandler {
           });
         },
         onError: (err) => {
+          const stateChanged = guardedState.set(extension, Invitation.State.CONNECTING);
           if (err instanceof InvalidInvitationExtensionRoleError) {
             log('invalid role', { ...err.context });
             return;
           }
           if (err instanceof TimeoutError) {
-            if (guardedState.set(extension, Invitation.State.TIMEOUT)) {
+            if (stateChanged) {
               metrics.increment('dxos.invitation.timeout');
-              log('timeout', { err });
+              log.verbose('timeout', { err });
             }
           } else {
-            if (guardedState.error(extension, err)) {
+            if (stateChanged) {
               metrics.increment('dxos.invitation.failed');
               log.error('failed', err);
             }
@@ -171,19 +191,21 @@ export class InvitationsHandler {
     if (invitation.lifetime && invitation.created) {
       if (invitation.created.getTime() + invitation.lifetime * 1000 < Date.now()) {
         log.warn('invitation has already expired');
-      } else {
-        scheduleTask(
-          ctx,
-          async () => {
-            // ensure the swarm is closed before changing state and closing the stream.
-            await swarmConnection.close();
-            guardedState.set(null, Invitation.State.EXPIRED);
-            metrics.increment('dxos.invitation.expired');
-            await ctx.dispose();
-          },
-          invitation.created.getTime() + invitation.lifetime * 1000 - Date.now(),
-        );
+        guardedState.set(null, Invitation.State.EXPIRED);
+        void ctx.dispose().catch((err) => log.catch(err));
+        return;
       }
+      scheduleTask(
+        ctx,
+        async () => {
+          // ensure the swarm is closed before changing state and closing the stream.
+          await swarmConnection.close();
+          guardedState.set(null, Invitation.State.EXPIRED);
+          metrics.increment('dxos.invitation.expired');
+          await ctx.dispose();
+        },
+        invitation.created.getTime() + invitation.lifetime * 1000 - Date.now(),
+      );
     }
 
     let swarmConnection: SwarmConnection;
@@ -201,6 +223,12 @@ export class InvitationsHandler {
     otpEnteredTrigger: Trigger<string>,
     deviceProfile?: DeviceProfileDocument,
   ): void {
+    log.verbose('dxos.sdk.invitations-handler.acceptInvitation', {
+      state: invitation.state,
+      invitationId: invitation.invitationId,
+      kind: invitation.kind,
+      type: invitation.type,
+    });
     const { timeout = INVITATION_TIMEOUT } = invitation;
 
     if (deviceProfile) {
@@ -208,7 +236,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();
@@ -240,7 +268,7 @@ export class InvitationsHandler {
           }
 
           connectionCtx.onDispose(async () => {
-            log('extension disposed', { admitted, currentState: guardedState.current.state });
+            log.verbose('extension disposed', { admitted, currentState: guardedState.current.state });
             if (!admitted) {
               guardedState.error(extension, new ContextDisposedError());
               if (shouldCancelInvitationFlow(extension)) {
@@ -263,16 +291,23 @@ export class InvitationsHandler {
                 timeout,
               );
 
-              log('connected', { ...protocol.toJSON() });
+              log.verbose('dxos.sdk.invitations-handler.guest.connected', { ...protocol.toJSON() });
               guardedState.set(extension, Invitation.State.CONNECTED);
 
               // 1. Introduce guest to host.
-              log('introduce', { ...protocol.toJSON() });
+              log.verbose('dxos.sdk.invitations-handler.guest.introduce', {
+                invitationId: invitation.invitationId,
+                ...protocol.toJSON(),
+              });
               const introductionResponse = await extension.rpc.InvitationHostService.introduce({
                 invitationId: invitation.invitationId,
                 ...protocol.createIntroduction(),
               });
-              log('introduce response', { ...protocol.toJSON(), response: introductionResponse });
+              log.verbose('dxos.sdk.invitations-handler.guest.introduce-response', {
+                invitationId: invitation.invitationId,
+                ...protocol.toJSON(),
+                authMethod: introductionResponse.authMethod,
+              });
               invitation.authMethod = introductionResponse.authMethod;
 
               // 2. Get authentication code.
@@ -298,7 +333,10 @@ export class InvitationsHandler {
               }
 
               // 3. Send admission credentials to host (with local space keys).
-              log('request admission', { ...protocol.toJSON() });
+              log.verbose('dxos.sdk.invitations-handler.guest.request-admission', {
+                invitationId: invitation.invitationId,
+                ...protocol.toJSON(),
+              });
               const admissionRequest = await protocol.createAdmissionRequest(deviceProfile);
               const admissionResponse = await extension.rpc.InvitationHostService.admit(admissionRequest);
 
@@ -309,8 +347,11 @@ export class InvitationsHandler {
               const result = await protocol.accept(admissionResponse, admissionRequest);
 
               // 5. Success.
-              log('admitted by host', { ...protocol.toJSON() });
-              await guardedState.complete({
+              log.verbose('dxos.sdk.invitations-handler.guest.admitted-by-host', {
+                invitationId: invitation.invitationId,
+                ...protocol.toJSON(),
+              });
+              guardedState.complete({
                 ...guardedState.current,
                 ...result,
                 state: Invitation.State.SUCCESS,
@@ -318,10 +359,10 @@ export class InvitationsHandler {
               log.trace('dxos.sdk.invitations-handler.guest.onOpen', trace.end({ id: traceId }));
             } catch (err: any) {
               if (err instanceof TimeoutError) {
-                log('timeout', { ...protocol.toJSON() });
+                log.verbose('timeout', { ...protocol.toJSON() });
                 guardedState.set(extension, Invitation.State.TIMEOUT);
               } else {
-                log('auth failed', err);
+                log.verbose('auth failed', err);
                 guardedState.error(extension, err);
               }
               extensionCtx.close(err);
@@ -334,10 +375,10 @@ export class InvitationsHandler {
             return;
           }
           if (err instanceof TimeoutError) {
-            log('timeout', { ...protocol.toJSON() });
+            log.verbose('timeout', { ...protocol.toJSON() });
             guardedState.set(extension, Invitation.State.TIMEOUT);
           } else {
-            log('auth failed', err);
+            log.verbose('auth failed', err);
             guardedState.error(extension, err);
           }
         },
@@ -346,6 +387,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.info('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 +439,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 +447,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,
@@ -523,7 +489,6 @@ export class InvitationsHandler {
       throw new Error('challenge missing in the introduction');
     }
     log('sending authentication request');
-    setState(Invitation.State.AUTHENTICATING);
     const signature = sign(Buffer.from(introductionResponse.challenge), invitation.guestKeypair.privateKey);
     const response = await extension.rpc.InvitationHostService.authenticate({
       signedChallenge: signature,

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

@@ -10,6 +10,7 @@ import {
   type InvitationsService,
   QueryInvitationsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
+import { trace } from '@dxos/tracing';
 
 import { type InvitationsManager } from './invitations-manager';
 
@@ -30,7 +31,10 @@ export class InvitationsServiceImpl implements InvitationsService {
     return new Stream<Invitation>(({ next, close }) => {
       void this._invitationsManager
         .createInvitation(options)
-        .then((invitation) => invitation.subscribe(next, close, close))
+        .then((invitation) => {
+          trace.metrics.increment('dxos.invitation.created');
+          invitation.subscribe(next, close, close);
+        })
         .catch(close);
     });
   }

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;
 };