@dxos/client-services 0.1.26 → 0.1.27-next.a0dff21

package/src/packlets/invitations/{halo-invitations-service.test.ts → device-invitations-service.test.ts}

@@ -8,20 +8,20 @@ import waitForExpect from 'wait-for-expect';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
-import { Invitation, HaloInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { Invitation, DeviceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test, afterTest } from '@dxos/test';
 
 import { ServiceContext } from '../services';
 import { createPeers } from '../testing';
-import { HaloInvitationsProxy } from './halo-invitations-proxy';
-import { HaloInvitationsServiceImpl } from './halo-invitations-service';
+import { DeviceInvitationsProxy } from './device-invitations-proxy';
+import { DeviceInvitationsServiceImpl } from './device-invitations-service';
 
 const closeAfterTest = async (peer: ServiceContext) => {
   afterTest(() => peer.close());
   return peer;
 };
 
-describe('services/halo-invitation-service', () => {
+describe('services/device-invitation-service', () => {
   test('creates identity and invites peer', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([closeAfterTest])(createPeers(2));
 
@@ -29,14 +29,14 @@ describe('services/halo-invitation-service', () => {
     expect(host.identityManager.identity!.authorizedDeviceKeys.size).to.eq(1);
 
     // prettier-ignore
-    const service1: HaloInvitationsService = new HaloInvitationsServiceImpl(
+    const service1: DeviceInvitationsService = new DeviceInvitationsServiceImpl(
       host.identityManager,
-      host.haloInvitations
+      host.deviceInvitations
     );
     // prettier-ignore
-    const service2: HaloInvitationsService = new HaloInvitationsServiceImpl(
+    const service2: DeviceInvitationsService = new DeviceInvitationsServiceImpl(
       guest.identityManager,
-      guest.haloInvitations
+      guest.deviceInvitations
     );
 
     const success1 = new Trigger<Invitation>();
@@ -45,11 +45,11 @@ describe('services/halo-invitation-service', () => {
     const authenticationCode = new Trigger<string>();
 
     {
-      const proxy1 = new HaloInvitationsProxy(service1);
+      const proxy1 = new DeviceInvitationsProxy(service1);
       const observable1 = proxy1.createInvitation();
       observable1.subscribe({
         onConnecting: (invitation: Invitation) => {
-          const proxy2 = new HaloInvitationsProxy(service2);
+          const proxy2 = new DeviceInvitationsProxy(service2);
           const observable2 = proxy2.acceptInvitation(invitation);
           observable2.subscribe({
             onAuthenticating: async () => {

package/src/packlets/invitations/{halo-invitations-service.ts → device-invitations-service.ts}

@@ -11,7 +11,7 @@ import { AbstractInvitationsService } from './invitations-service';
 /**
  * Adapts invitation service observable to client/service stream.
  */
-export class HaloInvitationsServiceImpl extends AbstractInvitationsService {
+export class DeviceInvitationsServiceImpl extends AbstractInvitationsService {
   // prettier-ignore
   constructor (
     identityManager: IdentityManager,

package/src/packlets/invitations/index.ts

@@ -3,9 +3,9 @@
 //
 
 export * from './encoder';
-export * from './halo-invitations-handler';
-export * from './halo-invitations-proxy';
-export * from './halo-invitations-service';
+export * from './device-invitations-handler';
+export * from './device-invitations-proxy';
+export * from './device-invitations-service';
 export * from './invitations';
 export * from './invitations-handler';
 export * from './invitations-proxy';

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

@@ -5,6 +5,7 @@
 import { PublicKey } from '@dxos/keys';
 import { NetworkManager } from '@dxos/network-manager';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { AuthMethod } from '@dxos/protocols/proto/dxos/halo/invitations';
 
 import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from './invitations';
 
@@ -13,6 +14,11 @@ export type InvitationsOptions = {
   timeout?: number;
   // Used for debugging.
   swarmKey?: PublicKey;
+  /**
+   * Authentication method.
+   * @default AuthMethod.SHARED_SECRET
+   */
+  authMethod?: AuthMethod;
 };
 
 /**

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, swarmKey } = invitation;
-      const observable = invitationsHandler.createInvitation(context, { type, swarmKey });
+      const { type, swarmKey, authMethod } = invitation;
+      const observable = invitationsHandler.createInvitation(context, { type, swarmKey, authMethod });
       observable.subscribe({
         onConnecting: (invitation) => {
           assert(invitation.invitationId);

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

@@ -7,7 +7,7 @@ import assert from 'node:assert';
 
 import { asyncChain, latch, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
-import { testLocalDatabase } from '@dxos/echo-db/testing';
+import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
 import { PublicKey } from '@dxos/keys';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { afterTest, describe, test } from '@dxos/test';

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

@@ -7,7 +7,7 @@ import assert from 'node:assert';
 import { scheduleTask, sleep, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createAdmissionCredentials, generatePasscode, getCredentialAssertion } from '@dxos/credentials';
-import { SigningContext } from '@dxos/echo-db';
+import { SigningContext } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -20,7 +20,9 @@ import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   AuthenticationRequest,
   AuthenticationResponse,
+  AuthMethod,
   Introduction,
+  IntroductionResponse,
   SpaceAdmissionCredentials,
   SpaceAdmissionRequest,
   SpaceHostService
@@ -70,7 +72,8 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
       invitationId: PublicKey.random().toHex(),
       swarmKey: swarmKey ?? PublicKey.random(),
       spaceKey: space.key,
-      authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH)
+      authMethod: options?.authMethod ?? AuthMethod.SHARED_SECRET,
+      authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH) // TODO(dmaretskyi): Don't generate if authMethod === NONE .
     };
 
     const ctx = new Context({
@@ -85,7 +88,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
       await swarmConnection?.close();
     });
 
-    let authenticationCode: string;
+    let authenticationPassed = false;
     let authenticationRetry = 0;
 
     // Called for every connecting peer.
@@ -106,18 +109,41 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
           // 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:
+              type === Invitation.Type.INTERACTIVE_TESTING || type === Invitation.Type.MULTIUSE_TESTING
+                ? space.key
+                : undefined,
+            authMethod: invitation.authMethod!
+          };
         },
 
         authenticate: async ({ authenticationCode: code }) => {
           log('received authentication request', { authenticationCode: code });
           let status = AuthenticationResponse.Status.OK;
-          if (invitation.authenticationCode) {
-            if (authenticationRetry++ > MAX_OTP_ATTEMPTS) {
-              status = AuthenticationResponse.Status.INVALID_OPT_ATTEMPTS;
-            } else if (code !== invitation.authenticationCode) {
-              status = AuthenticationResponse.Status.INVALID_OTP;
-            } else {
-              authenticationCode = code;
+
+          switch (invitation.authMethod) {
+            case AuthMethod.NONE: {
+              log('authentication not required');
+              return { status: AuthenticationResponse.Status.OK };
+            }
+            case AuthMethod.SHARED_SECRET: {
+              if (invitation.authenticationCode) {
+                if (authenticationRetry++ > MAX_OTP_ATTEMPTS) {
+                  status = AuthenticationResponse.Status.INVALID_OPT_ATTEMPTS;
+                } else if (code !== invitation.authenticationCode) {
+                  status = AuthenticationResponse.Status.INVALID_OTP;
+                } else {
+                  authenticationPassed = true;
+                }
+              }
+              break;
+            }
+            default: {
+              log.error('invalid authentication method', { authMethod: invitation.authMethod });
+              status = AuthenticationResponse.Status.INTERNAL_ERROR;
+              break;
             }
           }
 
@@ -127,13 +153,8 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
         requestAdmission: async ({ identityKey, deviceKey, controlFeedKey, dataFeedKey }) => {
           try {
             // Check authenticated.
-            if (
-              invitation.type !== Invitation.Type.INTERACTIVE_TESTING &&
-              invitation.type !== Invitation.Type.MULTIUSE_TESTING
-            ) {
-              if (invitation.authenticationCode === undefined || invitation.authenticationCode !== authenticationCode) {
-                throw new Error(`invalid authentication code: ${authenticationCode}`);
-              }
+            if (isAuthenticationRequired(invitation) && !authenticationPassed) {
+              throw new Error('Not authenticated');
             }
 
             log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
@@ -252,13 +273,22 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
 
               // 1. Introduce guest to host.
               log('introduce', { guest: this._signingContext.deviceKey });
-              await extension.rpc.SpaceHostService.introduce({
+              const introductionResponse = await extension.rpc.SpaceHostService.introduce({
                 profile: this._signingContext.profile
               });
+              log('introduce response', { guest: this._signingContext.deviceKey, response: introductionResponse });
+              invitation.authMethod = introductionResponse.authMethod;
+              if (introductionResponse.spaceKey) {
+                invitation.spaceKey = introductionResponse.spaceKey;
+              }
+
+              // TODO(dmaretskyi): Add a callback here to notify that we have introduced ourselves to the host (regradless of auth requirements).
 
               // 2. Get authentication code.
               // TODO(burdon): Test timeout (options for timeouts at different steps).
-              if (invitation.type === undefined || invitation.type === Invitation.Type.INTERACTIVE) {
+              if (isAuthenticationRequired(invitation)) {
+                observable.callback.onAuthenticating?.(invitation);
+
                 for (let attempt = 1; attempt <= MAX_OTP_ATTEMPTS; attempt++) {
                   log('guest waiting for authentication code...');
                   observable.callback.onAuthenticating?.(invitation);
@@ -346,11 +376,16 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
   }
 }
 
+const isAuthenticationRequired = (invitation: Invitation) =>
+  invitation.authMethod !== AuthMethod.NONE &&
+  invitation.type !== Invitation.Type.INTERACTIVE_TESTING &&
+  invitation.type !== Invitation.Type.MULTIUSE_TESTING;
+
 type HostSpaceInvitationExtensionCallbacks = {
   // Deliberately not async to not block the extensions opening.
   onOpen: () => void;
 
-  introduce: (introduction: Introduction) => Promise<void>;
+  introduce: (introduction: Introduction) => Promise<IntroductionResponse>;
   authenticate: (request: AuthenticationRequest) => Promise<AuthenticationResponse>;
   requestAdmission: (request: SpaceAdmissionRequest) => Promise<SpaceAdmissionCredentials>;
 };

package/src/packlets/services/index.ts

@@ -7,4 +7,3 @@ export * from './service-definitions';
 export * from './service-host';
 export * from './service-proxy';
 export * from './service-registry';
-export * from './signer';

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

@@ -16,7 +16,7 @@ describe('services/ServiceContext', () => {
     const space1 = await device1.dataSpaceManager!.createSpace();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
     await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
@@ -28,7 +28,7 @@ describe('services/ServiceContext', () => {
     await device1.createIdentity();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
     const space1 = await device1.dataSpaceManager!.createSpace();
     await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
@@ -42,7 +42,7 @@ describe('services/ServiceContext', () => {
     await device1.createIdentity();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
     const identity2 = createServiceContext({ signalContext: networkContext });
     await identity2.createIdentity();

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

@@ -7,12 +7,12 @@ import { CredentialConsumer, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
   valueEncoding,
-  DataServiceSubscriptions,
   MetadataStore,
   SpaceManager,
   SigningContext,
+  DataServiceSubscriptions,
   SnapshotStore
-} from '@dxos/echo-db';
+} from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { log } from '@dxos/log';
@@ -23,7 +23,7 @@ import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Storage } from '@dxos/random-access-storage';
 
 import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
-import { HaloInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
+import { DeviceInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
 import { DataSpaceManager } from '../spaces/data-space-manager';
 
 /**
@@ -39,7 +39,7 @@ export class ServiceContext {
   public readonly keyring: Keyring;
   public readonly spaceManager: SpaceManager;
   public readonly identityManager: IdentityManager;
-  public readonly haloInvitations: HaloInvitationsHandler;
+  public readonly deviceInvitations: DeviceInvitationsHandler;
 
   private _deviceSpaceSync?: CredentialConsumer<any>;
 
@@ -82,7 +82,7 @@ export class ServiceContext {
 
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
-    this.haloInvitations = new HaloInvitationsHandler({
+    this.deviceInvitations = new DeviceInvitationsHandler({
       networkManager: this.networkManager,
       getIdentity: () => this.identityManager.identity ?? failUndefined(),
       acceptIdentity: this._acceptIdentity.bind(this),

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

@@ -3,13 +3,14 @@
 //
 
 import { schema } from '@dxos/protocols';
-import { ProfileService, SystemService, SpaceService } from '@dxos/protocols/proto/dxos/client';
 import {
-  HaloInvitationsService,
+  DevicesService,
+  DeviceInvitationsService,
+  IdentityService,
+  NetworkService,
   SpaceInvitationsService,
   SpacesService,
-  DevicesService,
-  NetworkService
+  SystemService
 } from '@dxos/protocols/proto/dxos/client/services';
 import { DevtoolsHost, TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
 import { DataService } from '@dxos/protocols/proto/dxos/echo/service';
@@ -20,19 +21,19 @@ import { createServiceBundle, ServiceBundle } from '@dxos/rpc';
 //
 
 export type ClientServices = {
-  HaloInvitationsService: HaloInvitationsService;
+  SystemService: SystemService;
+
+  IdentityService: IdentityService;
+  DeviceInvitationsService: DeviceInvitationsService;
   DevicesService: DevicesService;
 
   SpaceInvitationsService: SpaceInvitationsService;
   SpacesService: SpacesService;
+  DataService: DataService;
 
   NetworkService: NetworkService;
 
   // TODO(burdon): Deprecated.
-  SpaceService: SpaceService;
-  DataService: DataService;
-  ProfileService: ProfileService;
-  SystemService: SystemService;
   DevtoolsHost: DevtoolsHost;
   TracingService: TracingService;
 };
@@ -52,17 +53,16 @@ export interface ClientServicesProvider {
  * Services supported by host.
  */
 export const clientServiceBundle = createServiceBundle<ClientServices>({
-  HaloInvitationsService: schema.getService('dxos.client.services.HaloInvitationsService'),
+  SystemService: schema.getService('dxos.client.services.SystemService'),
+  IdentityService: schema.getService('dxos.client.services.IdentityService'),
+  DeviceInvitationsService: schema.getService('dxos.client.services.DeviceInvitationsService'),
   DevicesService: schema.getService('dxos.client.services.DevicesService'),
   SpaceInvitationsService: schema.getService('dxos.client.services.SpaceInvitationsService'),
   SpacesService: schema.getService('dxos.client.services.SpacesService'),
+  DataService: schema.getService('dxos.echo.service.DataService'),
   NetworkService: schema.getService('dxos.client.services.NetworkService'),
 
   // TODO(burdon): Deprecated.
-  SpaceService: schema.getService('dxos.client.SpaceService'),
-  DataService: schema.getService('dxos.echo.service.DataService'),
-  ProfileService: schema.getService('dxos.client.ProfileService'),
-  SystemService: schema.getService('dxos.client.SystemService'),
   DevtoolsHost: schema.getService('dxos.devtools.host.DevtoolsHost'),
   TracingService: schema.getService('dxos.devtools.host.TracingService')
 });

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

@@ -20,8 +20,8 @@ describe('ClientServicesHost', () => {
     await host.open();
     afterTest(() => host.close());
 
-    await host.services.ProfileService!.createProfile({});
-    const { publicKey: spaceKey } = await host.services.SpaceService!.createSpace();
+    await host.services.IdentityService!.createIdentity({});
+    const { spaceKey } = await host.services.SpacesService!.createSpace();
 
     const stream = host.services.SpacesService!.queryCredentials({ spaceKey });
     const [done, tick] = latch({ count: 3 });
@@ -39,18 +39,18 @@ describe('ClientServicesHost', () => {
     await host.open();
     afterTest(() => host.close());
 
-    await host.services.ProfileService!.createProfile({});
+    await host.services.IdentityService!.createIdentity({});
 
     const testCredential = await createMockCredential({
       signer: host._serviceContext.keyring,
       issuer: host._serviceContext.identityManager.identity!.deviceKey
     });
 
-    // Test if Profile exposes haloSpace key.
+    // Test if Identity exposes haloSpace key.
     const haloSpace = new Trigger<PublicKey>();
-    host.services.ProfileService!.subscribeProfile()!.subscribe(({ profile }) => {
-      if (profile?.haloSpace) {
-        haloSpace.wake(profile.haloSpace);
+    host.services.IdentityService!.queryIdentity()!.subscribe(({ identity }) => {
+      if (identity?.spaceKey) {
+        haloSpace.wake(identity.spaceKey);
       }
     });
 
@@ -76,7 +76,7 @@ describe('ClientServicesHost', () => {
     await host.open();
     afterTest(() => host.close());
 
-    await host.services.ProfileService!.createProfile({});
+    await host.services.IdentityService!.createIdentity({});
 
     const testCredential = await createMockCredential({
       signer: host._serviceContext.keyring,
@@ -85,7 +85,7 @@ describe('ClientServicesHost', () => {
 
     const nonce = new Uint8Array([0, 0, 0, 0]);
 
-    const presentation = await host.services.ProfileService!.signPresentation({
+    const presentation = await host.services.IdentityService!.signPresentation({
       presentation: {
         credentials: [testCredential]
       },

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

@@ -2,24 +2,29 @@
 // Copyright 2021 DXOS.org
 //
 
+import assert from 'node:assert';
+
+import { Event } from '@dxos/async';
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
 import { DocumentModel } from '@dxos/document-model';
-import { DataServiceImpl } from '@dxos/echo-db';
+import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
-import { Status } from '@dxos/protocols/proto/dxos/client';
+import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
 import { TextModel } from '@dxos/text-model';
 
-import { SpaceServiceImpl, ProfileServiceImpl, TracingServiceImpl, SystemServiceImpl } from '../deprecated';
+import { TracingServiceImpl } from '../deprecated';
+import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
-import { DevicesServiceImpl } from '../identity/devices-service-impl';
-import { HaloInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
+import { IdentityServiceImpl } from '../identity';
+import { DeviceInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
 import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
+import { SystemServiceImpl } from '../system';
 import { VaultResourceLock } from '../vault';
 import { ServiceContext } from './service-context';
 import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
@@ -48,6 +53,7 @@ export class ClientServicesHost implements ClientServicesProvider {
   private readonly _systemService: SystemServiceImpl;
 
   private readonly _config: Config;
+  private readonly _statusUpdate = new Event<void>();
   private readonly _modelFactory: ModelFactory;
   private readonly _networkManager: NetworkManager;
   private readonly _storage: Storage;
@@ -64,6 +70,7 @@ export class ClientServicesHost implements ClientServicesProvider {
     // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager,
     storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage,
+    // TODO(wittjosiah): Turn this on by default.
     lockKey
   }: ClientServicesHostParams) {
     this._config = config;
@@ -82,20 +89,21 @@ export class ClientServicesHost implements ClientServicesProvider {
     this._systemService = new SystemServiceImpl({
       config: this._config,
 
-      onInit: async () => {
-        await this._resourceLock?.acquire();
-      },
+      statusUpdate: this._statusUpdate,
 
-      onStatus: async () => {
-        if (!this.isOpen) {
-          return { status: Status.INACTIVE };
-        }
+      getCurrentStatus: () => (this.isOpen ? SystemStatus.ACTIVE : SystemStatus.INACTIVE),
 
-        return { status: Status.ACTIVE };
+      onUpdateStatus: async (status: SystemStatus) => {
+        if (!this.isOpen && status === SystemStatus.ACTIVE) {
+          await this._resourceLock?.acquire();
+        } else if (this.isOpen && status === SystemStatus.INACTIVE) {
+          await this._resourceLock?.release();
+        }
       },
 
       onReset: async () => {
-        await this._serviceContext?.reset();
+        assert(this._serviceContext, 'service host is closed');
+        await this._serviceContext.reset();
       }
     });
 
@@ -123,6 +131,7 @@ export class ClientServicesHost implements ClientServicesProvider {
     }
 
     log('opening...');
+    await this._resourceLock?.acquire();
 
     // TODO(wittjosiah): Make re-entrant.
     // TODO(burdon): Break into components.
@@ -130,34 +139,38 @@ export class ClientServicesHost implements ClientServicesProvider {
 
     // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry.setServices({
-      // TODO(burdon): Move to new protobuf definitions.
       SystemService: this._systemService,
 
-      HaloInvitationsService: new HaloInvitationsServiceImpl(
-        this._serviceContext.identityManager,
-        this._serviceContext.haloInvitations
-      ),
+      IdentityService: new IdentityServiceImpl(this._serviceContext),
 
       DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
 
+      DeviceInvitationsService: new DeviceInvitationsServiceImpl(
+        this._serviceContext.identityManager,
+        this._serviceContext.deviceInvitations
+      ),
+
       SpaceInvitationsService: new SpaceInvitationsServiceImpl(
         this._serviceContext.identityManager,
         () => this._serviceContext.spaceInvitations ?? raise(new Error('SpaceInvitations not initialized')),
         () => this._serviceContext.dataSpaceManager ?? raise(new Error('SpaceManager not initialized'))
       ),
 
-      SpacesService: new SpacesServiceImpl(this._serviceContext.spaceManager),
+      SpacesService: new SpacesServiceImpl(
+        this._serviceContext.identityManager,
+        this._serviceContext.spaceManager,
+        this._serviceContext.dataServiceSubscriptions,
+        async () => {
+          await this._serviceContext.initialized.wait();
+          return this._serviceContext.dataSpaceManager!;
+        }
+      ),
 
       DataService: new DataServiceImpl(this._serviceContext.dataServiceSubscriptions),
 
       NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager),
 
       // TODO(burdon): Move to new protobuf definitions.
-      ProfileService: new ProfileServiceImpl(this._serviceContext),
-
-      // TODO(burdon): Port old SubscribeSpaces to QueryServices>
-      SpaceService: new SpaceServiceImpl(this._serviceContext),
-
       TracingService: new TracingServiceImpl(this._config),
       DevtoolsHost: new DevtoolsServiceImpl({
         events: new DevtoolsHostEvents(),
@@ -168,6 +181,7 @@ export class ClientServicesHost implements ClientServicesProvider {
 
     await this._serviceContext.open();
     this._open = true;
+    this._statusUpdate.emit();
     const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
     log('opened', { deviceKey });
   }
@@ -182,6 +196,7 @@ export class ClientServicesHost implements ClientServicesProvider {
     this._serviceRegistry.setServices({ SystemService: this._systemService });
     await this._serviceContext.close();
     this._open = false;
+    this._statusUpdate.emit();
     log('closed', { deviceKey });
   }
 }

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

@@ -6,7 +6,7 @@ import { expect } from 'chai';
 
 import { createAdmissionCredentials } from '@dxos/credentials';
 import { DocumentModel } from '@dxos/document-model';
-import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-db';
+import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';

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

@@ -8,15 +8,15 @@ import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { getCredentialAssertion } from '@dxos/credentials';
 import {
-  DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
-  SnapshotStore,
   Space,
   spaceGenesis,
   SpaceManager,
-  SnapshotManager
-} from '@dxos/echo-db';
+  DataServiceSubscriptions,
+  SnapshotManager,
+  SnapshotStore
+} from '@dxos/echo-pipeline';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';