@dxos/client-services 0.1.30-next.7c60cd3 → 0.1.30

package/src/packlets/services/index.ts

@@ -2,9 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './local-client-services';
 export * from './service-context';
-export * from './service-definitions';
 export * from './service-host';
-export * from './service-proxy';
 export * from './service-registry';
-export * from './local-client-services';
+export * from './utils';

package/src/packlets/services/local-client-services.ts

@@ -2,9 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
+import { ClientServices, ClientServicesProvider } from '@dxos/client';
 import { ServiceBundle } from '@dxos/rpc';
 
-import { ClientServices, ClientServicesProvider } from './service-definitions';
 import { ClientServicesHost, ClientServicesHostParams } from './service-host';
 
 /**
@@ -25,6 +25,10 @@ export class LocalClientServices implements ClientServicesProvider {
     return this._host.services;
   }
 
+  get host(): ClientServicesHost {
+    return this._host;
+  }
+
   async open(): Promise<void> {
     await this._host.open();
   }

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

@@ -5,7 +5,7 @@
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { describe, test } from '@dxos/test';
 
-import { createServiceContext, syncItems } from '../testing';
+import { createServiceContext, syncItemsLocal } from '../testing';
 import { performInvitation } from '../testing/invitation-utils';
 
 describe('services/ServiceContext', () => {
@@ -19,7 +19,7 @@ describe('services/ServiceContext', () => {
     await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
   });
 
   test('new space is synchronized on device invitations', async () => {
@@ -33,7 +33,7 @@ describe('services/ServiceContext', () => {
     const space1 = await device1.dataSpaceManager!.createSpace();
     await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
   });
 
   test('joined space is synchronized on device invitations', async () => {
@@ -51,6 +51,6 @@ describe('services/ServiceContext', () => {
 
     await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
   });
 });

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

@@ -24,7 +24,7 @@ import { Storage } from '@dxos/random-access-storage';
 
 import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
 import { DeviceInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
-import { DataSpaceManager } from '../spaces/data-space-manager';
+import { DataSpaceManager } from '../spaces';
 
 /**
  * Shared backend for all client services.

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

@@ -5,16 +5,15 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
+import { clientServiceBundle, ClientServices, createDefaultModelFactory } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
-import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
-import { TextModel } from '@dxos/text-model';
 
 import { TracingServiceImpl } from '../deprecated';
 import { DevicesServiceImpl } from '../devices';
@@ -27,23 +26,24 @@ import { createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
 import { VaultResourceLock } from '../vault';
 import { ServiceContext } from './service-context';
-import { ClientServices, clientServiceBundle } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
-// TODO(burdon): Factor out to spaces.
-// TODO(burdon): Defaults (with TextModel).
-export const createDefaultModelFactory = () => {
-  return new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
-};
-
 export type ClientServicesHostParams = {
-  config: Config;
+  /**
+   * Can be omitted if `initialize` is later called.
+   */
+  config?: Config;
   modelFactory?: ModelFactory;
-  networkManager: NetworkManager;
+  networkManager?: NetworkManager;
   storage?: Storage;
   lockKey?: string;
 };
 
+export type InitializeOptions = {
+  config?: Config;
+  networkManager?: NetworkManager;
+};
+
 /**
  * Remote service implementation.
  */
@@ -52,11 +52,11 @@ export class ClientServicesHost {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _systemService: SystemServiceImpl;
 
-  private readonly _config: Config;
+  private _config?: Config;
   private readonly _statusUpdate = new Event<void>();
   private readonly _modelFactory: ModelFactory;
-  private readonly _networkManager: NetworkManager;
-  private readonly _storage: Storage;
+  private _networkManager?: NetworkManager;
+  private _storage?: Storage;
 
   /**
    * @internal
@@ -69,14 +69,16 @@ export class ClientServicesHost {
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager,
-    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage,
+    storage,
     // TODO(wittjosiah): Turn this on by default.
     lockKey
-  }: ClientServicesHostParams) {
-    this._config = config;
-    this._modelFactory = modelFactory;
-    this._networkManager = networkManager;
+  }: ClientServicesHostParams = {}) {
     this._storage = storage;
+    this._modelFactory = modelFactory;
+
+    if (config) {
+      this.initialize({ config, networkManager });
+    }
 
     this._resourceLock = lockKey
       ? new VaultResourceLock({
@@ -117,6 +119,10 @@ export class ClientServicesHost {
     return this._open;
   }
 
+  get serviceRegistry() {
+    return this._serviceRegistry;
+  }
+
   get descriptors() {
     return this._serviceRegistry.descriptors;
   }
@@ -125,11 +131,38 @@ export class ClientServicesHost {
     return this._serviceRegistry.services;
   }
 
+  /**
+   * Initialize the service host with the config.
+   * Config can also be provided in the constructor.
+   * Can only be called once.
+   */
+  initialize({ config, networkManager }: InitializeOptions) {
+    assert(!this._open, 'service host is open');
+
+    if (config) {
+      assert(!this._config, 'config already set');
+
+      this._config = config;
+      if (!this._storage) {
+        this._storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage;
+      }
+    }
+
+    if (networkManager) {
+      assert(!this._networkManager, 'network manager already set');
+      this._networkManager = networkManager;
+    }
+  }
+
   async open() {
     if (this._open) {
       return;
     }
 
+    assert(this._config, 'config not set');
+    assert(this._storage, 'storage not set');
+    assert(this._networkManager, 'network manager not set');
+
     log('opening...');
     await this._resourceLock?.acquire();
 

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

@@ -5,15 +5,15 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
+import { ClientServices, SpaceInvitationsProxy } from '@dxos/client';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
 import { Invitation, SpaceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
 import { describe, test } from '@dxos/test';
 
-import { SpaceInvitationsProxy, SpaceInvitationsServiceImpl } from '../invitations';
+import { SpaceInvitationsServiceImpl } from '../invitations';
 import { createServiceContext } from '../testing';
-import { ClientServices } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).

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

@@ -11,7 +11,7 @@ export class ServiceRegistry<Services> {
   // prettier-ignore
   constructor (
     private readonly _serviceBundle: ServiceBundle<Services>,
-    private _handlers: Partial<Services>
+    private _handlers: Partial<Services> = {}
   ) {}
 
   get descriptors() {
@@ -25,4 +25,12 @@ export class ServiceRegistry<Services> {
   setServices(services: Partial<Services>) {
     this._handlers = services;
   }
+
+  addService(name: keyof Services, service: Services[keyof Services]) {
+    this._handlers[name] = service;
+  }
+
+  removeService(name: keyof Services) {
+    delete this._handlers[name];
+  }
 }

package/src/packlets/services/utils.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ClientServicesProvider } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { log } from '@dxos/log';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import {
+  createWebRTCTransportFactory,
+  MemoryTransportFactory,
+  NetworkManager,
+  NetworkManagerOptions
+} from '@dxos/network-manager';
+
+import { LocalClientServices } from './local-client-services';
+
+/**
+ * Creates stand-alone services without rpc.
+ */
+export const fromHost = (config: Config = new Config()): ClientServicesProvider => {
+  return new LocalClientServices({
+    config,
+    networkManager: createNetworkManager(config)
+  });
+};
+
+/**
+ * Creates a WebRTC network manager connected to the specified signal server.
+ */
+// TODO(burdon): Move to client-services and remove dependencies from here.
+const createNetworkManager = (config: Config, options: Partial<NetworkManagerOptions> = {}): NetworkManager => {
+  const signalServer = config.get('runtime.services.signal.server');
+  if (signalServer) {
+    const {
+      log = true,
+      signalManager = new WebsocketSignalManager([signalServer]),
+      transportFactory = createWebRTCTransportFactory({
+        iceServers: config.get('runtime.services.ice')
+      })
+    } = options;
+
+    return new NetworkManager({ log, signalManager, transportFactory });
+  }
+
+  // TODO(burdon): Should not provide a memory signal manager since no shared context.
+  //  Use TestClientBuilder for shared memory tests.
+  log.warn('P2P network is not configured.');
+  return new NetworkManager({
+    signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
+    transportFactory: MemoryTransportFactory
+  });
+};

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

@@ -4,6 +4,7 @@
 
 import { expect } from 'chai';
 
+import { latch } from '@dxos/async';
 import { createAdmissionCredentials } from '@dxos/credentials';
 import { DocumentModel } from '@dxos/document-model';
 import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
@@ -12,12 +13,12 @@ import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { test, describe } from '@dxos/test';
 
-import { createSigningContext, syncItems, TestBuilder } from '../testing';
+import { createSigningContext, HostTestBuilder, syncItemsLocal } from '../testing';
 import { DataSpaceManager } from './data-space-manager';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
-    const builder = new TestBuilder();
+    const builder = new HostTestBuilder();
 
     const peer = builder.createPeer();
     const identity = await createSigningContext(peer.keyring);
@@ -43,7 +44,7 @@ describe('DataSpaceManager', () => {
   });
 
   test('sync between peers', async () => {
-    const builder = new TestBuilder();
+    const builder = new HostTestBuilder();
 
     const peer1 = builder.createPeer();
     const identity1 = await createSigningContext(peer1.keyring);
@@ -121,11 +122,70 @@ describe('DataSpaceManager', () => {
     });
     log.break();
 
-    await syncItems(space1.dataPipelineController, space2.dataPipelineController);
+    await syncItemsLocal(space1.dataPipelineController, space2.dataPipelineController);
 
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)).to.exist;
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
     expect(space2.inner.protocol.sessions.get(identity1.deviceKey)).to.exist;
     expect(space2.inner.protocol.sessions.get(identity1.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
   });
+
+  test('pub/sub API', async () => {
+    const builder = new HostTestBuilder();
+
+    const peer1 = builder.createPeer();
+    const identity1 = await createSigningContext(peer1.keyring);
+    const dataSpaceManager1 = new DataSpaceManager(
+      peer1.spaceManager,
+      peer1.metadataStore,
+      new DataServiceSubscriptions(),
+      peer1.keyring,
+      identity1,
+      new ModelFactory().registerModel(DocumentModel),
+      peer1.feedStore,
+      peer1.snapshotStore
+    );
+
+    const peer2 = builder.createPeer();
+    const identity2 = await createSigningContext(peer2.keyring);
+    const dataSpaceManager2 = new DataSpaceManager(
+      peer2.spaceManager,
+      peer2.metadataStore,
+      new DataServiceSubscriptions(),
+      peer2.keyring,
+      identity2,
+      new ModelFactory().registerModel(DocumentModel),
+      peer2.feedStore,
+      peer1.snapshotStore
+    );
+
+    const space1 = await dataSpaceManager1.createSpace();
+    await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
+
+    // Admit peer2 to space1.
+    await writeMessages(
+      space1.inner.controlPipeline.writer,
+      await createAdmissionCredentials(
+        identity1.credentialSigner,
+        identity2.identityKey,
+        space1.key,
+        space1.inner.genesisFeedKey
+      )
+    );
+
+    // Accept must be called after admission so that the peer can authenticate for notarization.
+    const space2 = await dataSpaceManager2.acceptSpace({
+      spaceKey: space1.key,
+      genesisFeedKey: space1.inner.genesisFeedKey
+    });
+
+    const [receivedMessage, inc] = latch({ count: 1 });
+    space2.listen('test', (message) => {
+      expect(message.channelId).to.equal('test');
+      inc();
+    });
+
+    await space1.postMessage('test', { '@type': 'google.protobuf.Any', test: true });
+    await receivedMessage();
+  });
 });

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

@@ -24,7 +24,7 @@ import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { Presence } from '@dxos/teleport-extension-presence';
+import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { ComplexMap, deferFunction } from '@dxos/util';
 
 import { createAuthProvider } from '../identity';
@@ -150,11 +150,14 @@ export class DataSpaceManager {
   }
 
   private async _constructSpace(metadata: SpaceMetadata) {
+    const gossip = new Gossip({
+      localPeerId: this._signingContext.deviceKey
+    });
     const presence = new Presence({
-      localPeerId: this._signingContext.deviceKey,
-      announceInterval: 1_000,
-      offlineTimeout: 10_000, // TODO(burdon): Config.
-      identityKey: this._signingContext.identityKey
+      announceInterval: 500,
+      offlineTimeout: 5_000, // TODO(burdon): Config.
+      identityKey: this._signingContext.identityKey,
+      gossip
     });
     const snapshotManager = new SnapshotManager(this._snapshotStore);
 
@@ -171,8 +174,8 @@ export class DataSpaceManager {
       },
       onNetworkConnection: (session) => {
         session.addExtension(
-          'dxos.mesh.teleport.presence',
-          presence.createExtension({ remotePeerId: session.remotePeerId })
+          'dxos.mesh.teleport.gossip',
+          gossip.createExtension({ remotePeerId: session.remotePeerId })
         );
         session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
@@ -186,6 +189,7 @@ export class DataSpaceManager {
       modelFactory: this._modelFactory,
       metadataStore: this._metadataStore,
       snapshotManager,
+      gossip,
       presence,
       memberKey: this._signingContext.identityKey,
       keyring: this._keyring,

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

@@ -20,7 +20,8 @@ import { PublicKey } from '@dxos/keys';
 import { ModelFactory } from '@dxos/model-factory';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed, Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { Presence } from '@dxos/teleport-extension-presence';
+import { GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
+import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from '../identity';
@@ -33,6 +34,7 @@ export type DataSpaceParams = {
   modelFactory: ModelFactory;
   metadataStore: MetadataStore;
   snapshotManager: SnapshotManager;
+  gossip: Gossip;
   presence: Presence;
   keyring: Keyring;
   feedStore: FeedStore<FeedMessage>;
@@ -47,6 +49,7 @@ export class DataSpace {
   private readonly _ctx = new Context();
   private readonly _dataPipelineController: DataPipelineControllerImpl;
   private readonly _inner: Space;
+  private readonly _gossip: Gossip;
   private readonly _presence: Presence;
   private readonly _keyring: Keyring;
   private readonly _feedStore: FeedStore<FeedMessage>;
@@ -58,6 +61,7 @@ export class DataSpace {
 
   constructor(params: DataSpaceParams) {
     this._inner = params.inner;
+    this._gossip = params.gossip;
     this._presence = params.presence;
     this._keyring = params.keyring;
     this._feedStore = params.feedStore;
@@ -129,6 +133,14 @@ export class DataSpace {
     await this._presence.destroy();
   }
 
+  async postMessage(channel: string, message: any) {
+    return this._gossip.postMessage(channel, message);
+  }
+
+  listen(channel: string, callback: (message: GossipMessage) => void) {
+    return this._gossip.listen(channel, callback);
+  }
+
   async initializeDataPipeline() {
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
       timeout: CONTROL_PIPELINE_READY_TIMEFRAME

package/src/packlets/spaces/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './data-space-manager';
+export * from './data-space';
 export * from './spaces-service';

package/src/packlets/spaces/notarization-plugin.ts

@@ -4,7 +4,7 @@
 
 import assert from 'node:assert';
 
-import { DeferredTask, Event, scheduleTask, TimeoutError, Trigger } from '@dxos/async';
+import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { CredentialProcessor } from '@dxos/credentials';
 import { FeedWriter } from '@dxos/feed-store';
@@ -16,7 +16,13 @@ import { NotarizationService, NotarizeRequest } from '@dxos/protocols/proto/dxos
 import { ExtensionContext, RpcExtension } from '@dxos/teleport';
 import { ComplexMap, ComplexSet, entry } from '@dxos/util';
 
-const RETRY_TIMEOUT = 1000;
+// Timeout for retrying notarization.
+const RETRY_TIMEOUT = 1_000;
+
+// Minimum wait time after a peer confirms successful notarization before attempting with a new peer.
+const SUCCESS_DELAY = 1_000;
+
+// Timeout for the whole notarization process.
 const NOTARIZE_TIMEOUT = 10_000;
 
 /**
@@ -92,6 +98,7 @@ export class NotarizationPlugin implements CredentialProcessor {
           credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!))
         });
         log('success');
+        await sleep(SUCCESS_DELAY); // wait before trying with a new peer
       } catch (err) {
         log.warn('error notarizing (recoverable)', err);
         notarizeTask.schedule(); // retry immediately with next peer

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

@@ -8,16 +8,19 @@ import { raise, todo } from '@dxos/debug';
 import { DataServiceSubscriptions, SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import {
+  PostMessageRequest,
   QueryCredentialsRequest,
   QuerySpacesResponse,
   Space,
   SpaceMember,
   SpacesService,
   SpaceStatus,
+  SubscribeMessagesRequest,
   UpdateSpaceRequest,
   WriteCredentialsRequest
 } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { humanize, Provider } from '@dxos/util';
 
 import { IdentityManager } from '../identity';
@@ -96,6 +99,25 @@ export class SpacesServiceImpl implements SpacesService {
     });
   }
 
+  async postMessage({ spaceKey, channel, message }: PostMessageRequest) {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+    await space.postMessage(getChannelId(channel), message);
+  }
+
+  subscribeMessages({ spaceKey, channel }: SubscribeMessagesRequest) {
+    return new Stream<GossipMessage>(({ ctx, next }) => {
+      scheduleTask(ctx, async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+        const handle = space.listen(getChannelId(channel), (message) => {
+          next(message);
+        });
+        ctx.onDispose(() => handle.unsubscribe());
+      });
+    });
+  }
+
   queryCredentials({ spaceKey }: QueryCredentialsRequest): Stream<Credential> {
     return new Stream(({ ctx, next }) => {
       const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
@@ -137,3 +159,6 @@ export class SpacesServiceImpl implements SpacesService {
     };
   }
 }
+
+// Add `user-channel` prefix to the channel name, so that it doesn't collide with the internal channels.
+const getChannelId = (channel: string): string => `user-channel/${channel}`;

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

@@ -14,7 +14,7 @@ import {
 import { MaybePromise } from '@dxos/util';
 
 export type SystemServiceOptions = {
-  config: Config;
+  config?: Config;
   statusUpdate: Event<void>;
   getCurrentStatus: () => SystemStatus;
   onUpdateStatus: (status: SystemStatus) => MaybePromise<void>;
@@ -25,7 +25,7 @@ export type SystemServiceOptions = {
  *
  */
 export class SystemServiceImpl implements SystemService {
-  private readonly _config: SystemServiceOptions['config'];
+  private readonly _config?: SystemServiceOptions['config'];
   private readonly _statusUpdate: SystemServiceOptions['statusUpdate'];
   private readonly _getCurrentStatus: SystemServiceOptions['getCurrentStatus'];
   private readonly _onUpdateStatus: SystemServiceOptions['onUpdateStatus'];
@@ -40,7 +40,7 @@ export class SystemServiceImpl implements SystemService {
   }
 
   async getConfig() {
-    return this._config.values;
+    return this._config?.values ?? {};
   }
 
   async updateStatus({ status }: UpdateSystemStatusRequest) {