@dxos/client-services 0.1.9 → 0.1.10

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

@@ -44,14 +44,14 @@ export class HaloInvitationsHandler extends AbstractInvitationsHandler {
    */
   createInvitation(context: void, options?: InvitationsOptions): InvitationObservable {
     let swarmConnection: SwarmConnection | undefined;
-    const { type, timeout = INVITATION_TIMEOUT } = options ?? {};
+    const { type, timeout = INVITATION_TIMEOUT, swarmKey } = options ?? {};
     assert(type !== Invitation.Type.OFFLINE);
     const identity = this._identityManager.identity ?? failUndefined();
 
     const invitation: Invitation = {
       type,
       invitationId: PublicKey.random().toHex(),
-      swarmKey: PublicKey.random(),
+      swarmKey: swarmKey ?? PublicKey.random(),
       authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH)
     };
 
@@ -140,7 +140,7 @@ export class HaloInvitationsHandler extends AbstractInvitationsHandler {
     setTimeout(async () => {
       const topic = invitation.swarmKey!;
       const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.openSwarmConnection({
+      swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: topic,
         protocol: createProtocolFactory(topic, peerId, [plugin]),
@@ -237,7 +237,7 @@ export class HaloInvitationsHandler extends AbstractInvitationsHandler {
       assert(invitation.swarmKey);
       const topic = invitation.swarmKey;
       const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.openSwarmConnection({
+      swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: PublicKey.random(),
         protocol: createProtocolFactory(topic, peerId, [plugin]),

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

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+import { PublicKey } from '@dxos/keys';
 import { NetworkManager } from '@dxos/network-manager';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
@@ -10,6 +11,8 @@ import { AuthenticatingInvitationObservable, InvitationObservable } from './invi
 export type InvitationsOptions = {
   type?: Invitation.Type;
   timeout?: number;
+  // Used for debugging.
+  swarmKey?: PublicKey;
 };
 
 /**

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

@@ -43,8 +43,8 @@ export abstract class AbstractInvitationsService<T = void> implements Invitation
       log('stream opened', this.getLoggingContext());
 
       let invitationId: string;
-      const { type } = invitation;
-      const observable = invitationsHandler.createInvitation(context, { type });
+      const { type, swarmKey } = invitation;
+      const observable = invitationsHandler.createInvitation(context, { type, swarmKey });
       observable.subscribe({
         onConnecting: (invitation) => {
           assert(invitation.invitationId);

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

@@ -14,6 +14,7 @@ import { createProtocolFactory, NetworkManager, StarTopology, SwarmConnection }
 import { createRpcPlugin, RpcPlugin } from '@dxos/protocol-plugin-rpc';
 import { schema } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { createProtoRpcPeer } from '@dxos/rpc';
 
 import {
@@ -44,14 +45,14 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
    */
   createInvitation(space: Space, options?: InvitationsOptions): InvitationObservable {
     let swarmConnection: SwarmConnection | undefined;
-    const { type, timeout = INVITATION_TIMEOUT } = options ?? {};
+    const { type, timeout = INVITATION_TIMEOUT, swarmKey } = options ?? {};
     assert(type !== Invitation.Type.OFFLINE);
     assert(space);
 
     const invitation: Invitation = {
       type,
       invitationId: PublicKey.random().toHex(),
-      swarmKey: PublicKey.random(),
+      swarmKey: swarmKey ?? PublicKey.random(),
       spaceKey: space.key,
       authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH)
     };
@@ -64,19 +65,25 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
     let authenticationCode: string;
     const complete = new Trigger<PublicKey>();
     const plugin = new RpcPlugin(async (port) => {
+      let guestProfile: ProfileDocument | undefined;
+
       const peer = createProtoRpcPeer({
         exposed: {
           SpaceHostService: schema.getService('dxos.halo.invitations.SpaceHostService')
         },
         handlers: {
           SpaceHostService: {
-            requestAdmission: async () => {
+            requestAdmission: async ({ profile }) => {
               log('responding with admission offer', {
+                guestProfile: profile,
                 host: this._signingContext.deviceKey,
                 spaceKey: space.key
               });
 
+              guestProfile = profile;
+
               // TODO(burdon): Is this the right place to set this state?
+              // TODO(dmaretskyi): Should we expose guest's profile in this callback?
               observable.callback.onAuthenticating?.(invitation);
               return {
                 spaceKey: space.key,
@@ -111,7 +118,8 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
                     deviceKey,
                     space.key,
                     controlFeedKey,
-                    dataFeedKey
+                    dataFeedKey,
+                    guestProfile
                   )
                 );
 
@@ -150,7 +158,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
     setTimeout(async () => {
       const topic = invitation.swarmKey!;
       const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.openSwarmConnection({
+      swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: topic,
         protocol: createProtocolFactory(topic, peerId, [plugin]),
@@ -206,7 +214,9 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
 
         // 1. Send request.
         log('sending admission request', { guest: this._signingContext.deviceKey });
-        const { spaceKey, genesisFeedKey } = await peer.rpc.SpaceHostService.requestAdmission();
+        const { spaceKey, genesisFeedKey } = await peer.rpc.SpaceHostService.requestAdmission({
+          profile: this._signingContext.profile
+        });
 
         // 2. Get authentication code.
         // TODO(burdon): Test timeout (options for timeouts at different steps).
@@ -248,7 +258,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
       assert(invitation.swarmKey);
       const topic = invitation.swarmKey;
       const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.openSwarmConnection({
+      swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: PublicKey.random(),
         protocol: createProtocolFactory(topic, peerId, [plugin]),

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

@@ -21,7 +21,7 @@ import { NetworkManager } from '@dxos/network-manager';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { Storage } from '@dxos/random-access-storage';
 
-import { IdentityManager } from '../identity';
+import { CreateIdentityOptions, IdentityManager } from '../identity';
 import { HaloInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
 
 /**
@@ -87,13 +87,17 @@ export class ServiceContext {
     await this.identityManager.close();
     await this.spaceManager?.close();
     await this.feedStore.close();
-    await this.networkManager.destroy(); // TODO(burdon): Close.
+    await this.networkManager.close();
     this.dataServiceSubscriptions.clear();
     log('closed');
   }
 
-  async createIdentity() {
-    const identity = await this.identityManager.createIdentity();
+  // TODO(burdon): Rename.
+  async destroy() {}
+
+  async createIdentity(params: CreateIdentityOptions = {}) {
+    const identity = await this.identityManager.createIdentity(params);
+
     this.dataServiceSubscriptions.registerSpace(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
     await this._initialize();
     return identity;
@@ -107,7 +111,8 @@ export class ServiceContext {
       credentialAuthenticator: MOCK_AUTH_VERIFIER,
       credentialSigner: identity.getIdentityCredentialSigner(),
       identityKey: identity.identityKey,
-      deviceKey: identity.deviceKey
+      deviceKey: identity.deviceKey,
+      profile: identity.profileDocument
     };
 
     // Create in constructor (avoid all of these private variables).

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

@@ -21,22 +21,21 @@ import { ServiceContext } from './service-context';
 import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
-type ClientServicesHostParams = {
-  config: Config;
-  modelFactory?: ModelFactory;
-  networkManager: NetworkManager;
-};
-
 // TODO(burdon): Factor out to spaces.
 // TODO(burdon): Defaults (with TextModel).
 export const createDefaultModelFactory = () => {
   return new ModelFactory().registerModel(ObjectModel).registerModel(TextModel);
 };
 
+type ClientServicesHostParams = {
+  config: Config;
+  modelFactory?: ModelFactory;
+  networkManager: NetworkManager;
+};
+
 /**
  * Remote service implementation.
  */
-// TODO(burdon): Reconcile Host/Backend, etc.
 export class ClientServicesHost implements ClientServicesProvider {
   private readonly _serviceContext: ServiceContext;
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;