@dxos/client-services 0.4.10-main.3e0c8a5 → 0.4.10-main.3f5e2d2

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

@@ -2,43 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, scheduleTask } from '@dxos/async';
-import { type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
 import { Stream } from '@dxos/codec-protobuf';
-import { Context } from '@dxos/context';
-import { type MetadataStore } from '@dxos/echo-pipeline';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
 import {
   type AuthenticationRequest,
   type AcceptInvitationRequest,
-  Invitation,
+  type Invitation,
   type InvitationsService,
   QueryInvitationsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 
-import { type InvitationProtocol } from './invitation-protocol';
-import { invitationExpired, type InvitationsHandler } from './invitations-handler';
+import { type InvitationsManager } from './invitations-manager';
 
 /**
  * Adapts invitation service observable to client/service stream.
  */
 export class InvitationsServiceImpl implements InvitationsService {
-  private readonly _createInvitations = new Map<string, CancellableInvitation>();
-  private readonly _acceptInvitations = new Map<string, AuthenticatingInvitation>();
-  private readonly _invitationCreated = new Event<Invitation>();
-  private readonly _invitationAccepted = new Event<Invitation>();
-  private readonly _removedCreated = new Event<Invitation>();
-  private readonly _removedAccepted = new Event<Invitation>();
-  private readonly _saved = new Event<Invitation>();
-  private readonly _persistentInvitationsLoadedEvent = new Event();
-  private _persistentInvitationsLoaded = false;
-
-  constructor(
-    private readonly _invitationsHandler: InvitationsHandler,
-    private readonly _getHandler: (invitation: Invitation) => InvitationProtocol,
-    private readonly _metadataStore: MetadataStore,
-  ) {}
+  constructor(private readonly _invitationsManager: InvitationsManager) {}
 
   // TODO(burdon): Guest/host label.
   getLoggingContext() {
@@ -48,148 +27,33 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   createInvitation(options: Invitation): Stream<Invitation> {
-    let invitation: CancellableInvitation;
-
-    const savePersistentInvitationCtx = new Context();
-    const existingInvitation = this._createInvitations.get(options.invitationId);
-    if (existingInvitation) {
-      invitation = existingInvitation;
-    } else {
-      const handler = this._getHandler(options);
-      invitation = this._invitationsHandler.createInvitation(handler, options);
-      this._createInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationCreated.emit(invitation.get());
-    }
-
     return new Stream<Invitation>(({ next, close }) => {
-      if (invitation.get().persistent) {
-        scheduleTask(savePersistentInvitationCtx, async () => {
-          try {
-            await this._metadataStore.addInvitation(invitation.get());
-            this._saved.emit(invitation.get());
-          } catch (err: any) {
-            close(err);
-          }
-        });
-      }
-      invitation.subscribe(
-        (invitation) => {
-          next(invitation);
-        },
-        async (err: Error) => {
-          await savePersistentInvitationCtx.dispose();
-
-          // TODO(nf): also remove from storage?
-          close(err);
-        },
-        async () => {
-          close();
-          if (invitation.get().persistent) {
-            await savePersistentInvitationCtx.dispose();
-            // TODO(nf): remove on all complete conditions?
-            await this._metadataStore.removeInvitation(invitation.get().invitationId);
-          }
-
-          this._createInvitations.delete(invitation.get().invitationId);
-          if (invitation.get().type !== Invitation.Type.MULTIUSE) {
-            this._removedCreated.emit(invitation.get());
-          }
-        },
-      );
-    });
-  }
-
-  async loadPersistentInvitations() {
-    const persistentInvitations = this._metadataStore.getInvitations();
-
-    // get saved persistent invitations, filter and remove from storage those that have expired.
-    const freshInvitations = persistentInvitations.filter(async (invitation) => !invitationExpired(invitation));
-
-    const cInvitations = freshInvitations.map((persistentInvitation) => {
-      invariant(!this._createInvitations.get(persistentInvitation.invitationId), 'invitation already exists');
-
-      const handler = this._getHandler(persistentInvitation);
-      const invitation = this._invitationsHandler.createInvitation(handler, persistentInvitation);
-      this._createInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationCreated.emit(invitation.get());
-      return persistentInvitation;
+      void this._invitationsManager
+        .createInvitation(options)
+        .then((invitation) => invitation.subscribe(next, close, close))
+        .catch(close);
     });
-    this._persistentInvitationsLoadedEvent.emit();
-    this._persistentInvitationsLoaded = true;
-    return { invitations: cInvitations };
   }
 
-  acceptInvitation({ invitation: options, deviceProfile }: AcceptInvitationRequest): Stream<Invitation> {
-    let invitation: AuthenticatingInvitation;
-
-    // TODO(nf): duplicate check in InvitationHandler
-    if (deviceProfile) {
-      invariant(options.kind === Invitation.Kind.DEVICE, 'deviceProfile provided for non-device invitation');
-    }
-
-    const existingInvitation = this._acceptInvitations.get(options.invitationId);
-    if (existingInvitation) {
-      invitation = existingInvitation;
-    } else {
-      const handler = this._getHandler(options);
-      invitation = this._invitationsHandler.acceptInvitation(handler, options, deviceProfile);
-      this._acceptInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationAccepted.emit(invitation.get());
-    }
-
+  acceptInvitation(request: AcceptInvitationRequest): Stream<Invitation> {
+    const invitation = this._invitationsManager.acceptInvitation(request);
     return new Stream<Invitation>(({ next, close }) => {
-      invitation.subscribe(
-        (invitation) => {
-          next(invitation);
-        },
-        (err: Error) => {
-          close(err);
-        },
-        () => {
-          close();
-          this._acceptInvitations.delete(invitation.get().invitationId);
-          if (invitation.get().type !== Invitation.Type.MULTIUSE) {
-            this._removedAccepted.emit(invitation.get());
-          }
-        },
-      );
+      invitation.subscribe(next, close, close);
     });
   }
 
-  async authenticate({ invitationId, authCode }: AuthenticationRequest): Promise<void> {
-    log('authenticating...');
-    invariant(invitationId);
-    const observable = this._acceptInvitations.get(invitationId);
-    if (!observable) {
-      log.warn('invalid invitation', { invitationId });
-    } else {
-      await observable.authenticate(authCode);
-    }
+  async authenticate(request: AuthenticationRequest): Promise<void> {
+    return this._invitationsManager.authenticate(request);
   }
 
-  async cancelInvitation({ invitationId }: { invitationId: string }): Promise<void> {
-    log('cancelInvitation...', { invitationId });
-    invariant(invitationId);
-    const created = this._createInvitations.get(invitationId);
-    const accepted = this._acceptInvitations.get(invitationId);
-    if (created) {
-      await created.cancel();
-      this._createInvitations.delete(invitationId);
-      this._removedCreated.emit(created.get());
-      if (created.get().persistent) {
-        await this._metadataStore.removeInvitation(created.get().invitationId);
-      }
-    } else if (accepted) {
-      await accepted.cancel();
-      this._acceptInvitations.delete(invitationId);
-      this._removedAccepted.emit(accepted.get());
-    }
+  async cancelInvitation(request: { invitationId: string }): Promise<void> {
+    return this._invitationsManager.cancelInvitation(request);
   }
 
   queryInvitations(): Stream<QueryInvitationsResponse> {
     return new Stream<QueryInvitationsResponse>(({ next, ctx }) => {
       // Push added invitations to the stream.
-      this._invitationCreated.on(ctx, (invitation) => {
+      this._invitationsManager.invitationCreated.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -197,7 +61,7 @@ export class InvitationsServiceImpl implements InvitationsService {
         });
       });
 
-      this._invitationAccepted.on(ctx, (invitation) => {
+      this._invitationsManager.invitationAccepted.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
@@ -206,7 +70,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       // Push removed invitations to the stream.
-      this._removedCreated.on(ctx, (invitation) => {
+      this._invitationsManager.removedCreated.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -214,7 +78,7 @@ export class InvitationsServiceImpl implements InvitationsService {
         });
       });
 
-      this._removedAccepted.on(ctx, (invitation) => {
+      this._invitationsManager.removedAccepted.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
@@ -223,7 +87,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       // used only for testing
-      this._saved.on(ctx, (invitation) => {
+      this._invitationsManager.saved.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.SAVED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -235,33 +99,24 @@ export class InvitationsServiceImpl implements InvitationsService {
       next({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.CREATED,
-        invitations: Array.from(this._createInvitations.values()).map((invitation) => invitation.get()),
+        invitations: this._invitationsManager.getCreatedInvitations(),
         existing: true,
       });
 
       next({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.ACCEPTED,
-        invitations: Array.from(this._acceptInvitations.values()).map((invitation) => invitation.get()),
+        invitations: this._invitationsManager.getAcceptedInvitations(),
         existing: true,
       });
 
-      if (this._persistentInvitationsLoaded) {
+      this._invitationsManager.onPersistentInvitationsLoaded(ctx, () => {
         next({
           action: QueryInvitationsResponse.Action.LOAD_COMPLETE,
           type: QueryInvitationsResponse.Type.CREATED,
           // TODO(nf): populate with invitations
         });
-      } else {
-        this._persistentInvitationsLoadedEvent.on(ctx, () => {
-          next({
-            action: QueryInvitationsResponse.Action.LOAD_COMPLETE,
-            type: QueryInvitationsResponse.Type.CREATED,
-            // TODO(nf): populate with invitations
-          });
-        });
-      }
-
+      });
       // TODO(nf): expired invitations?
     });
   }

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

@@ -2,7 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { createAdmissionCredentials, getCredentialAssertion } from '@dxos/credentials';
+import {
+  createAdmissionCredentials,
+  createDelegatedSpaceInvitationCredential,
+  getCredentialAssertion,
+} from '@dxos/credentials';
 import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -11,7 +15,7 @@ import { log } from '@dxos/log';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
   type AdmissionResponse,
@@ -43,7 +47,11 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  async admit(request: AdmissionRequest, guestProfile?: ProfileDocument | undefined): Promise<AdmissionResponse> {
+  async admit(
+    invitation: Invitation,
+    request: AdmissionRequest,
+    guestProfile?: ProfileDocument | undefined,
+  ): Promise<AdmissionResponse> {
     invariant(this._spaceKey);
     const space = await this._spaceManager.spaces.get(this._spaceKey);
     invariant(space);
@@ -59,6 +67,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
       space.key,
       space.inner.genesisFeedKey,
       guestProfile,
+      invitation.delegationCredentialId,
     );
 
     // TODO(dmaretskyi): Refactor.
@@ -76,6 +85,39 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
+  async delegate(invitation: Invitation): Promise<PublicKey> {
+    invariant(this._spaceKey);
+    const space = await this._spaceManager.spaces.get(this._spaceKey);
+    invariant(space);
+    if (invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY) {
+      invariant(invitation.guestKeypair?.publicKey);
+    }
+
+    log('writing delegate space invitation', { host: this._signingContext.deviceKey, id: invitation.invitationId });
+    const credential = await createDelegatedSpaceInvitationCredential(
+      this._signingContext.credentialSigner,
+      space.key,
+      {
+        invitationId: invitation.invitationId,
+        authMethod: invitation.authMethod,
+        swarmKey: invitation.swarmKey,
+        role: SpaceMember.Role.ADMIN,
+        expiresOn: invitation.lifetime
+          ? new Date((invitation.created?.getTime() ?? Date.now()) + invitation.lifetime)
+          : undefined,
+        multiUse: invitation.multiUse ?? false,
+        guestKey:
+          invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY
+            ? invitation.guestKeypair!.publicKey
+            : undefined,
+      },
+    );
+
+    invariant(credential.credential);
+    await writeMessages(space.inner.controlPipeline.writer, [credential]);
+    return credential.credential.credential.id!;
+  }
+
   checkInvitation(invitation: Partial<Invitation>) {
     if (invitation.spaceKey && this._spaceManager.spaces.has(invitation.spaceKey)) {
       return new AlreadyJoinedError('Already joined space.');

package/src/packlets/network/network-service.test.ts

@@ -18,7 +18,7 @@ describe('NetworkService', () => {
   let networkService: NetworkService;
 
   beforeEach(async () => {
-    serviceContext = createServiceContext();
+    serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
     networkService = new NetworkServiceImpl(serviceContext.networkManager, serviceContext.signalManager);
   });

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

@@ -4,10 +4,11 @@
 
 import { expect } from 'chai';
 
-import { asyncTimeout, sleep } from '@dxos/async';
+import { asyncTimeout } from '@dxos/async';
+import { getHeads } from '@dxos/automerge/automerge';
+import { AutomergeContext } from '@dxos/echo-db';
 import { AutomergeHost, DataServiceImpl } from '@dxos/echo-pipeline';
-import { AutomergeContext } from '@dxos/echo-schema';
-import { StorageType, createStorage } from '@dxos/random-access-storage';
+import { createTestLevel } from '@dxos/echo-pipeline/testing';
 import { afterTest, describe, test } from '@dxos/test';
 
 describe('AutomergeHost', () => {
@@ -19,10 +20,16 @@ describe('AutomergeHost', () => {
     // creates repo and document | replicates repo | finds document in repo
     //
 
-    const storageDirectory = createStorage({ type: StorageType.RAM }).createDirectory();
+    const level = createTestLevel();
+    await level.open();
+    afterTest(() => level.close());
 
-    const host = new AutomergeHost({ directory: storageDirectory });
+    const host = new AutomergeHost({
+      db: level.sublevel('automerge'),
+    });
+    await host.open();
     afterTest(() => host.close());
+
     const dataService = new DataServiceImpl(host);
     const client = new AutomergeContext(dataService);
     afterTest(() => client.close());
@@ -44,9 +51,8 @@ describe('AutomergeHost', () => {
     doc.change((doc: any) => {
       doc.text = newText;
     });
+    await client.flush({ states: [{ documentId: doc.documentId, heads: getHeads(doc.docSync()) }] });
 
-    // TODO(mykola): Is there a way to know when automerge has started replication?
-    await sleep(100);
     await asyncTimeout(handle.whenReady(), 1_000);
     expect(handle.docSync().text).to.equal(newText);
   });

package/src/packlets/services/index.ts

@@ -3,7 +3,7 @@
 //
 
 export * from './client-rpc-server';
-export * from './diagnostics';
 export * from './service-context';
 export * from './service-host';
 export * from './service-registry';
+export { ClientServicesProviderResource } from './util';

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

@@ -4,7 +4,7 @@
 
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { describe, test } from '@dxos/test';
+import { describe, openAndClose, test } from '@dxos/test';
 
 import { createServiceContext } from '../testing';
 import { performInvitation } from '../testing/invitation-utils';
@@ -12,10 +12,10 @@ import { performInvitation } from '../testing/invitation-utils';
 describe('services/ServiceContext', () => {
   test('new space is synchronized on device invitations', async () => {
     const networkContext = new MemorySignalManagerContext();
-    const device1 = createServiceContext({ signalContext: networkContext });
+    const device1 = await createServiceContext({ signalContext: networkContext });
     await device1.createIdentity();
 
-    const device2 = createServiceContext({ signalContext: networkContext });
+    const device2 = await createServiceContext({ signalContext: networkContext });
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
     const space1 = await device1.dataSpaceManager!.createSpace();
@@ -26,13 +26,16 @@ describe('services/ServiceContext', () => {
 
   test('joined space is synchronized on device invitations', async () => {
     const networkContext = new MemorySignalManagerContext();
-    const device1 = createServiceContext({ signalContext: networkContext });
+    const device1 = await createServiceContext({ signalContext: networkContext });
+    await openAndClose(device1.echoHost);
     await device1.createIdentity();
 
-    const device2 = createServiceContext({ signalContext: networkContext });
+    const device2 = await createServiceContext({ signalContext: networkContext });
+    await openAndClose(device2.echoHost);
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
-    const identity2 = createServiceContext({ signalContext: networkContext });
+    const identity2 = await createServiceContext({ signalContext: networkContext });
+    await openAndClose(identity2.echoHost);
     await identity2.createIdentity();
     const space1 = await identity2.dataSpaceManager!.createSpace();
     await Promise.all(

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

@@ -2,13 +2,15 @@
 // Copyright 2022 DXOS.org
 //
 
+import { type Level } from 'level';
+
 import { Trigger } from '@dxos/async';
-import { Context } from '@dxos/context';
+import { Context, Resource } from '@dxos/context';
 import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { AutomergeHost, MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
+import { EchoHost } from '@dxos/echo-db';
+import { MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { IndexMetadataStore, IndexStore, Indexer } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -30,13 +32,13 @@ import {
   type IdentityManagerRuntimeParams,
   type JoinIdentityParams,
 } from '../identity';
-import { createDocumentsIterator, createSelectedDocumentsIterator } from '../indexing';
 import {
   DeviceInvitationProtocol,
   InvitationsHandler,
   SpaceInvitationProtocol,
   type InvitationProtocol,
 } from '../invitations';
+import { InvitationsManager } from '../invitations/invitations-manager';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
 export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams & DataSpaceManagerRuntimeParams;
@@ -47,7 +49,7 @@ export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams & DataSpa
 // TODO(dmaretskyi): Gets duplicated in CJS build between normal and testing bundles.
 @safeInstanceof('dxos.client-services.ServiceContext')
 @Trace.resource()
-export class ServiceContext {
+export class ServiceContext extends Resource {
   public readonly initialized = new Trigger();
   public readonly metadataStore: MetadataStore;
   /**
@@ -60,9 +62,8 @@ export class ServiceContext {
   public readonly spaceManager: SpaceManager;
   public readonly identityManager: IdentityManager;
   public readonly invitations: InvitationsHandler;
-  public readonly automergeHost: AutomergeHost;
-  public readonly indexMetadata: IndexMetadataStore;
-  public readonly indexer: Indexer;
+  public readonly invitationsManager: InvitationsManager;
+  public readonly echoHost: EchoHost;
 
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
@@ -78,10 +79,13 @@ export class ServiceContext {
 
   constructor(
     public readonly storage: Storage,
+    public readonly level: Level<string, string>,
     public readonly networkManager: NetworkManager,
     public readonly signalManager: SignalManager,
     public readonly _runtimeParams?: IdentityManagerRuntimeParams & DataSpaceManagerRuntimeParams,
   ) {
+    super();
+
     // TODO(burdon): Move strings to constants.
     this.metadataStore = new MetadataStore(storage.createDirectory('metadata'));
     this.snapshotStore = new SnapshotStore(storage.createDirectory('snapshots'));
@@ -115,21 +119,17 @@ export class ServiceContext {
       this._runtimeParams as IdentityManagerRuntimeParams,
     );
 
-    this.indexMetadata = new IndexMetadataStore({ directory: storage.createDirectory('index-metadata') });
-
-    this.automergeHost = new AutomergeHost({
-      directory: storage.createDirectory('automerge'),
-      metadata: this.indexMetadata,
-    });
-
-    this.indexer = new Indexer({
-      indexStore: new IndexStore({ directory: storage.createDirectory('index-store') }),
-      metadataStore: this.indexMetadata,
-      loadDocuments: createSelectedDocumentsIterator(this.automergeHost),
-      getAllDocuments: createDocumentsIterator(this.automergeHost),
+    this.echoHost = new EchoHost({
+      kv: this.level,
+      storage: this.storage,
     });
 
     this.invitations = new InvitationsHandler(this.networkManager);
+    this.invitationsManager = new InvitationsManager(
+      this.invitations,
+      (invitation) => this.getInvitationHandler(invitation),
+      this.metadataStore,
+    );
 
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
@@ -145,7 +145,7 @@ export class ServiceContext {
   }
 
   @Trace.span()
-  async open(ctx: Context) {
+  protected override async _open(ctx: Context) {
     await this._checkStorageVersion();
 
     log('opening...');
@@ -153,30 +153,34 @@ export class ServiceContext {
     await this.signalManager.open();
     await this.networkManager.open();
 
+    await this.echoHost.open(ctx);
     await this.metadataStore.load();
     await this.spaceManager.open();
     await this.identityManager.open(ctx);
     if (this.identityManager.identity) {
       await this._initialize(ctx);
     }
+
+    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations();
+    log('loaded persistent invitations', { count: loadedInvitations.invitations?.length });
+
     log.trace('dxos.sdk.service-context.open', trace.end({ id: this._instanceId }));
     log('opened');
   }
 
-  async close() {
+  protected override async _close(ctx: Context) {
     log('closing...');
     if (this._deviceSpaceSync && this.identityManager.identity) {
       await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
     }
-    await this.automergeHost.close();
     await this.dataSpaceManager?.close();
     await this.identityManager.close();
     await this.spaceManager.close();
     await this.feedStore.close();
+    await this.metadataStore.close();
+    await this.echoHost.close(ctx);
     await this.networkManager.close();
     await this.signalManager.close();
-    await this.metadataStore.close();
-    await this.indexer.destroy();
     log('closed');
   }
 
@@ -237,7 +241,8 @@ export class ServiceContext {
       this.keyring,
       signingContext,
       this.feedStore,
-      this.automergeHost,
+      this.echoHost,
+      this.invitationsManager,
       this._runtimeParams as DataSpaceManagerRuntimeParams,
     );
     await this.dataSpaceManager.open();

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

@@ -29,6 +29,12 @@ describe('ClientServicesHost', () => {
     isNode() && rmSync(dataRoot, { recursive: true, force: true });
   });
 
+  test('open and close', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open(new Context());
+    await host.close();
+  });
+
   test('queryCredentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());