@dxos/client-services 0.6.14-main.8b352a0 → 0.6.14-staging.3e2eaca

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

@@ -125,7 +125,7 @@ export class InvitationHostExtension
             };
           }
 
-          log('guest introduced themselves', { guestProfile: profile });
+          log.verbose('guest introduced themselves', { guestProfile: profile });
           this.guestProfile = profile;
           this._callbacks.onStateUpdate(Invitation.State.READY_FOR_AUTHENTICATION);
           this._challenge =
@@ -143,7 +143,7 @@ export class InvitationHostExtension
           log.trace('dxos.sdk.invitation-handler.host.authenticate', trace.begin({ id: traceId }));
 
           const invitation = this._requireActiveInvitation();
-          log('received authentication request', { authCode: code });
+          log.verbose('received authentication request', { authCode: code });
           let status = AuthenticationResponse.Status.OK;
 
           this._assertInvitationState([Invitation.State.AUTHENTICATING, Invitation.State.READY_FOR_AUTHENTICATION]);
@@ -236,18 +236,15 @@ export class InvitationHostExtension
     await super.onOpen(context);
 
     try {
-      log('host acquire lock');
+      log.verbose('host acquire lock');
       this._invitationFlowLock = await tryAcquireBeforeContextDisposed(this._ctx, this._invitationFlowMutex);
-      log('host lock acquired');
-      const lastState = this._requireActiveInvitation().state;
+      log.verbose('host lock acquired');
       this._callbacks.onStateUpdate(Invitation.State.CONNECTING);
       await this.rpc.InvitationHostService.options({ role: InvitationOptions.Role.HOST });
-      log('options sent');
+      log.verbose('options sent');
       await cancelWithContext(this._ctx, this._remoteOptionsTrigger.wait({ timeout: OPTIONS_TIMEOUT }));
-      log('options received');
+      log.verbose('options received');
       if (this._remoteOptions?.role !== InvitationOptions.Role.GUEST) {
-        // we connected with another host, restore previous real invitation flow status
-        this._callbacks.onStateUpdate(lastState);
         throw new InvalidInvitationExtensionRoleError(undefined, {
           expected: InvitationOptions.Role.GUEST,
           remoteOptions: this._remoteOptions,
@@ -299,7 +296,7 @@ export class InvitationHostExtension
     if (this._invitationFlowLock != null) {
       this._invitationFlowLock?.release();
       this._invitationFlowLock = null;
-      log('invitation flow lock released');
+      log.verbose('invitation flow lock released');
     }
   }
 }

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

@@ -71,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);
@@ -91,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;
@@ -134,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);
@@ -143,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 () => {

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

@@ -86,7 +86,7 @@ export class InvitationsHandler {
       kind: invitation.kind,
       type: invitation.type,
     });
-    metrics.increment('dxos.invitation.created');
+    metrics.increment('dxos.invitation.host');
     const guardedState = createGuardedInvitationState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
@@ -96,7 +96,9 @@ 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;
         },
 
@@ -125,7 +127,7 @@ export class InvitationsHandler {
           let admitted = false;
           connectionCtx.onDispose(() => {
             if (!admitted) {
-              guardedState.error(extension, new ContextDisposedError());
+              guardedState.set(extension, Invitation.State.CONNECTING);
             }
           });
 
@@ -133,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 }));
@@ -145,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);
                 }
@@ -163,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);
             }
@@ -187,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;
@@ -262,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)) {
@@ -353,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);
@@ -369,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);
           }
         },

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

@@ -190,7 +190,7 @@ export class InvitationsManager {
     }
   }
 
-  private _createInvitation(protocol: InvitationProtocol, options?: Partial<Invitation>): Invitation {
+  private _createInvitation(protocol: InvitationProtocol, _options?: Partial<Invitation>): Invitation {
     const {
       invitationId = PublicKey.random().toHex(),
       type = Invitation.Type.INTERACTIVE,
@@ -198,13 +198,14 @@ export class InvitationsManager {
       state = Invitation.State.INIT,
       timeout = INVITATION_TIMEOUT,
       swarmKey = PublicKey.random(),
-      persistent = options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY, // default no not storing keypairs
+      persistent = _options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY, // default no not storing keypairs
       created = new Date(),
       guestKeypair = undefined,
       role = SpaceMember.Role.ADMIN,
       lifetime = 86400, // 1 day,
       multiUse = false,
-    } = options ?? {};
+      ...options
+    } = _options ?? {};
     const authCode =
       options?.authCode ??
       (authMethod === Invitation.AuthMethod.SHARED_SECRET ? generatePasscode(AUTHENTICATION_CODE_LENGTH) : undefined);
@@ -225,6 +226,7 @@ export class InvitationsManager {
       role,
       multiUse,
       delegationCredentialId: options?.delegationCredentialId,
+      ...options,
       ...protocol.getInvitationContext(),
     } satisfies Invitation;
   }

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/services/service-context.ts

@@ -381,12 +381,12 @@ export class ServiceContext extends Resource {
         identity: identity.identityKey.toHex(),
         swarms: this.networkManager.topics,
       });
-      if (params?.deviceCredential) {
+      if (params?.deviceCredential || Boolean((globalThis as any)?.DEVICE_INVITE_INTEROP)) {
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,
           identity.identityKey,
           identity.deviceKey,
-          { credential: params.deviceCredential },
+          params?.deviceCredential && { credential: params.deviceCredential },
           [], // TODO(dmaretskyi): Service access credentials.
         );
       } else {

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

@@ -318,7 +318,7 @@ export class ClientServicesHost {
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
-      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
+      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager, this._edgeConnection),
 
       SpacesService: new SpacesServiceImpl(
         this._serviceContext.identityManager,

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -65,15 +65,16 @@ describe('EdgeFeedReplicator', () => {
 
   test('re-requests metadata on reconnect', async () => {
     const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger } = await createClient(endpoint);
+    const { messenger, reconnectTrigger } = await createClient(endpoint);
 
     await attachReplicator(messenger);
 
     admitConnection.wake();
     await expect.poll(() => messageSink.length).toEqual(1);
 
+    reconnectTrigger.reset();
     await updateIdentity(messenger);
-    await messenger.reconnect.waitForCount(1);
+    await reconnectTrigger.wait();
 
     await expect.poll(() => messageSink.length).toEqual(2);
     expect(messageSink[1].type).toEqual('get-metadata');
@@ -100,7 +101,7 @@ describe('EdgeFeedReplicator', () => {
 
   test('recovers after response sending failure during identity change', async () => {
     const { endpoint, admitConnection, messageSink, sendResponseMessage } = await createEdge();
-    const { messenger, sendSpy } = await createClient(endpoint);
+    const { messenger, sendSpy, reconnectTrigger } = await createClient(endpoint);
 
     const { feed } = await attachReplicator(messenger);
     await appendMessage(feed);
@@ -117,9 +118,11 @@ describe('EdgeFeedReplicator', () => {
     await expect.poll(() => sendSpy.mock.calls.length).toEqual(2);
     sendSpy.mockRestore();
     expect(messageSink.length).toEqual(0);
+
+    reconnectTrigger.reset();
     await updateIdentity(messenger);
+    await reconnectTrigger.wait();
 
-    await messenger.reconnect.waitForCount(1);
     await expect.poll(() => messageSink.find((msg) => msg.type === 'data')).toBeDefined();
   });
 
@@ -151,8 +154,8 @@ describe('EdgeFeedReplicator', () => {
     await sleep(100);
     admitConnection.wake();
 
-    await expect.poll(() => messageSink.length).toEqual(2);
-    expect(messageSink.map((m) => m.type)).toStrictEqual(range(2, () => 'get-metadata'));
+    await expect.poll(() => messageSink.length).toEqual(1);
+    expect(messageSink.map((m) => m.type)).toStrictEqual(range(1, () => 'get-metadata'));
   });
 
   test('block appended during reconnect', async () => {
@@ -213,10 +216,12 @@ describe('EdgeFeedReplicator', () => {
   };
 
   const createClient = async (endpoint: string) => {
+    const reconnectTrigger = new Trigger();
     const messenger = new EdgeClient(await createEphemeralEdgeIdentity(), { socketEndpoint: endpoint });
+    messenger.onReconnected(() => reconnectTrigger.wake());
     const sendSpy = vi.spyOn(messenger, 'send');
     await openAndClose(messenger);
-    return { messenger, sendSpy };
+    return { messenger, sendSpy, reconnectTrigger };
   };
 
   const attachReplicator = async (messenger: EdgeClient, options?: { skipOpen?: boolean }) => {

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -56,7 +56,7 @@ export class EdgeFeedReplicator extends Resource {
     log('open');
     // TODO: handle reconnects
     this._ctx.onDispose(
-      this._messenger.addListener((message: RouterMessage) => {
+      this._messenger.onMessage((message: RouterMessage) => {
         if (!message.serviceId) {
           return;
         }
@@ -77,11 +77,15 @@ export class EdgeFeedReplicator extends Resource {
       }),
     );
 
-    this._messenger.connected.on(this._ctx, async () => {
-      await this._resetConnection();
-      this._startReplication();
-    });
+    this._ctx.onDispose(
+      this._messenger.onReconnected(() => {
+        scheduleMicroTask(this._ctx, () => this._handleReconnect());
+      }),
+    );
+  }
 
+  private async _handleReconnect() {
+    await this._resetConnection();
     if (this._messenger.isConnected) {
       this._startReplication();
     }

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

@@ -62,6 +62,7 @@ export const performInvitation = ({
 }: PerformInvitationParams): [Promise<Result>, Promise<Result>] => {
   let guestError = false;
   let guestConnected = false;
+  let wereConnected = false;
   const hostComplete = new Trigger<Result>();
   const guestComplete = new Trigger<Result>();
   const authCode = new Trigger<string>();
@@ -72,12 +73,17 @@ export const performInvitation = ({
         switch (hostInvitation.state) {
           case Invitation.State.CONNECTING: {
             if (guestConnected) {
+              if (wereConnected) {
+                hostComplete.wake({ invitation: hostInvitation });
+              }
               break;
             }
+
             guestConnected = true;
             if (hooks?.host?.onConnecting?.(hostObservable)) {
               break;
             }
+
             const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
             guestObservable.subscribe(
               async (guestInvitation: Invitation) => {
@@ -153,6 +159,7 @@ export const performInvitation = ({
           }
 
           case Invitation.State.CONNECTED: {
+            wereConnected = true;
             hooks?.host?.onConnected?.(hostObservable);
             break;
           }

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.6.14-main.8b352a0";
+export const DXOS_VERSION = "0.6.14-staging.3e2eaca";