@dxos/client-services 0.1.22 → 0.1.24-next.6b1f434

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

@@ -3,33 +3,32 @@
 //
 
 import { Trigger } from '@dxos/async';
+import { CredentialConsumer, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
-  MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER,
   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';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Storage } from '@dxos/random-access-storage';
 
-import { CreateIdentityOptions, IdentityManager } from '../identity';
+import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
 import { HaloInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
 import { DataSpaceManager } from '../spaces/data-space-manager';
 
 /**
  * Shared backend for all client services.
  */
-
 // TODO(burdon): Rename/break-up into smaller components. And/or make members private.
 export class ServiceContext {
   public readonly initialized = new Trigger();
@@ -42,6 +41,8 @@ export class ServiceContext {
   public readonly identityManager: IdentityManager;
   public readonly haloInvitations: HaloInvitationsHandler;
 
+  private _deviceSpaceSync?: CredentialConsumer<any>;
+
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
   public spaceInvitations?: SpaceInvitationsHandler;
@@ -66,19 +67,27 @@ export class ServiceContext {
         }
       })
     });
+
     this.spaceManager = new SpaceManager({
       feedStore: this.feedStore,
       networkManager: this.networkManager
     });
+
     this.identityManager = new IdentityManager(
       this.metadataStore,
       this.keyring,
+      this.feedStore,
       this.spaceManager
     );
 
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
-    this.haloInvitations = new HaloInvitationsHandler(this.networkManager, this.identityManager);
+    this.haloInvitations = new HaloInvitationsHandler({
+      networkManager: this.networkManager,
+      getIdentity: () => this.identityManager.identity ?? failUndefined(),
+      acceptIdentity: this._acceptIdentity.bind(this),
+      keyring: this.keyring
+    });
   }
 
   async open() {
@@ -94,6 +103,7 @@ export class ServiceContext {
 
   async close() {
     log('closing...');
+    await this._deviceSpaceSync?.close();
     await this.dataSpaceManager?.close();
     await this.identityManager.close();
     await this.spaceManager.close();
@@ -117,17 +127,25 @@ export class ServiceContext {
     return identity;
   }
 
+  private async _acceptIdentity(params: JoinIdentityParams) {
+    const identity = await this.identityManager.acceptIdentity(params);
+
+    await this._initialize();
+    return identity;
+  }
+
   // Called when identity is created.
   private async _initialize() {
     log('initializing spaces...');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
-      credentialProvider: MOCK_AUTH_PROVIDER,
-      credentialAuthenticator: MOCK_AUTH_VERIFIER,
       credentialSigner: identity.getIdentityCredentialSigner(),
       identityKey: identity.identityKey,
       deviceKey: identity.deviceKey,
-      profile: identity.profileDocument
+      profile: identity.profileDocument,
+      recordCredential: async (credential) => {
+        await identity.controlPipeline.writer.write({ credential: { credential } });
+      }
     };
 
     this.dataSpaceManager = new DataSpaceManager(
@@ -137,9 +155,11 @@ export class ServiceContext {
       this.keyring,
       signingContext,
       this.modelFactory,
+      this.feedStore,
       this.snapshotStore
     );
     await this.dataSpaceManager.open();
+
     this.spaceInvitations = new SpaceInvitationsHandler(
       this.networkManager,
       this.dataSpaceManager,
@@ -147,5 +167,37 @@ export class ServiceContext {
       this.keyring
     );
     this.initialized.wake();
+
+    this._deviceSpaceSync = identity.space.spaceState.registerProcessor({
+      process: async (credential: Credential) => {
+        const assertion = getCredentialAssertion(credential);
+        if (assertion['@type'] !== 'dxos.halo.credentials.SpaceMember') {
+          return;
+        }
+        if (assertion.spaceKey.equals(identity.space.key)) {
+          // ignore halo space
+          return;
+        }
+        if (!this.dataSpaceManager) {
+          log('dataSpaceManager not initialized yet, ignoring space admission', { details: assertion });
+          return;
+        }
+        if (this.dataSpaceManager.spaces.has(assertion.spaceKey)) {
+          log('space already exists, ignoring space admission', { details: assertion });
+          return;
+        }
+
+        try {
+          log('accepting space recorded in halo', { details: assertion });
+          await this.dataSpaceManager.acceptSpace({
+            spaceKey: assertion.spaceKey,
+            genesisFeedKey: assertion.genesisFeedKey
+          });
+        } catch (err) {
+          log.catch(err);
+        }
+      }
+    });
+    await this._deviceSpaceSync.open();
   }
 }

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

@@ -42,7 +42,7 @@ export type ClientServices = {
  */
 export interface ClientServicesProvider {
   descriptors: ServiceBundle<ClientServices>;
-  services: ClientServices;
+  services: Partial<ClientServices>;
 
   open(): Promise<void>;
   close(): Promise<void>;

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

@@ -2,12 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { latch } from '@dxos/async';
+import { expect } from 'chai';
+
+import { latch, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
+import { verifyPresentation } from '@dxos/credentials';
+import { PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { afterTest, describe, test } from '@dxos/test';
 
-import { createServiceHost } from '../testing';
+import { createMockCredential, createServiceHost } from '../testing';
 
 describe('ClientServicesHost', () => {
   test('queryCredentials', async () => {
@@ -15,10 +20,10 @@ describe('ClientServicesHost', () => {
     await host.open();
     afterTest(() => host.close());
 
-    await host.services.ProfileService.createProfile({});
-    const { publicKey: spaceKey } = await host.services.SpaceService.createSpace();
+    await host.services.ProfileService!.createProfile({});
+    const { publicKey: spaceKey } = await host.services.SpaceService!.createSpace();
 
-    const stream = host.services.SpacesService.queryCredentials({ spaceKey });
+    const stream = host.services.SpacesService!.queryCredentials({ spaceKey });
     const [done, tick] = latch({ count: 3 });
     stream.subscribe((credential) => {
       tick();
@@ -28,4 +33,68 @@ describe('ClientServicesHost', () => {
 
     await done();
   });
+
+  test('write and query credentials', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open();
+    afterTest(() => host.close());
+
+    await host.services.ProfileService!.createProfile({});
+
+    const testCredential = await createMockCredential({
+      signer: host._serviceContext.keyring,
+      issuer: host._serviceContext.identityManager.identity!.deviceKey
+    });
+
+    // Test if Profile exposes haloSpace key.
+    const haloSpace = new Trigger<PublicKey>();
+    host.services.ProfileService!.subscribeProfile()!.subscribe(({ profile }) => {
+      if (profile?.haloSpace) {
+        haloSpace.wake(profile.haloSpace);
+      }
+    });
+
+    await host.services.SpacesService?.writeCredentials({
+      spaceKey: await haloSpace.wait(),
+      credentials: [testCredential]
+    });
+
+    const credentials = host.services.SpacesService!.queryCredentials({ spaceKey: await haloSpace.wait() });
+    const queriedCredential = new Trigger<Credential>();
+    credentials.subscribe((credential) => {
+      if (credential.subject.id.equals(testCredential.subject.id)) {
+        queriedCredential.wake(credential);
+      }
+    });
+    afterTest(() => credentials.close());
+
+    await queriedCredential.wait();
+  });
+
+  test('sign presentation', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open();
+    afterTest(() => host.close());
+
+    await host.services.ProfileService!.createProfile({});
+
+    const testCredential = await createMockCredential({
+      signer: host._serviceContext.keyring,
+      issuer: host._serviceContext.identityManager.identity!.deviceKey
+    });
+
+    const nonce = new Uint8Array([0, 0, 0, 0]);
+
+    const presentation = await host.services.ProfileService!.signPresentation({
+      presentation: {
+        credentials: [testCredential]
+      },
+      nonce
+    });
+
+    expect(presentation.proofs?.[0].nonce).to.deep.equal(nonce);
+    expect(await verifyPresentation(presentation)).to.deep.equal({
+      kind: 'pass'
+    });
+  });
 });

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

@@ -4,21 +4,23 @@
 
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
-import { DataServiceImpl } from '@dxos/echo-db';
+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 { ObjectModel } from '@dxos/object-model';
+import { Status } from '@dxos/protocols/proto/dxos/client';
 import { Storage } from '@dxos/random-access-storage';
 import { TextModel } from '@dxos/text-model';
 
-import { SpaceServiceImpl, ProfileServiceImpl, SystemServiceImpl, TracingServiceImpl } from '../deprecated';
+import { SpaceServiceImpl, ProfileServiceImpl, TracingServiceImpl, SystemServiceImpl } from '../deprecated';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
 import { DevicesServiceImpl } from '../identity/devices-service-impl';
 import { HaloInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
 import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
+import { VaultResourceLock } from '../vault';
 import { ServiceContext } from './service-context';
 import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
@@ -26,7 +28,7 @@ import { ServiceRegistry } from './service-registry';
 // TODO(burdon): Factor out to spaces.
 // TODO(burdon): Defaults (with TextModel).
 export const createDefaultModelFactory = () => {
-  return new ModelFactory().registerModel(ObjectModel).registerModel(TextModel);
+  return new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
 };
 
 type ClientServicesHostParams = {
@@ -34,31 +36,77 @@ type ClientServicesHostParams = {
   modelFactory?: ModelFactory;
   networkManager: NetworkManager;
   storage?: Storage;
+  lockKey?: string;
 };
 
 /**
  * Remote service implementation.
  */
 export class ClientServicesHost implements ClientServicesProvider {
-  private _serviceContext!: ServiceContext;
-  private _serviceRegistry!: ServiceRegistry<ClientServices>;
+  private readonly _resourceLock?: VaultResourceLock;
+  private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
+  private readonly _systemService: SystemServiceImpl;
 
   private readonly _config: Config;
   private readonly _modelFactory: ModelFactory;
   private readonly _networkManager: NetworkManager;
-  private _storage: Storage;
+  private readonly _storage: Storage;
+
+  /**
+   * @internal
+   */
+  _serviceContext!: ServiceContext;
+  private _open = false;
 
   constructor({
     config,
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager,
-    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage
+    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage,
+    lockKey
   }: ClientServicesHostParams) {
     this._config = config;
     this._modelFactory = modelFactory;
     this._networkManager = networkManager;
     this._storage = storage;
+
+    this._resourceLock = lockKey
+      ? new VaultResourceLock({
+          lockKey,
+          onAcquire: () => this.open(),
+          onRelease: () => this.close()
+        })
+      : undefined;
+
+    this._systemService = new SystemServiceImpl({
+      config: this._config,
+
+      onInit: async () => {
+        await this._resourceLock?.acquire();
+      },
+
+      onStatus: async () => {
+        if (!this.isOpen) {
+          return { status: Status.INACTIVE };
+        }
+
+        return { status: Status.ACTIVE };
+      },
+
+      onReset: async () => {
+        await this._serviceContext?.reset();
+      }
+    });
+
+    // TODO(burdon): Start to think of DMG (dynamic services).
+    this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
+      SystemService: this._systemService
+    });
+  }
+
+  get isOpen() {
+    return this._open;
   }
 
   get descriptors() {
@@ -70,27 +118,21 @@ export class ClientServicesHost implements ClientServicesProvider {
   }
 
   async open() {
-    log('opening...');
-    await this._initialize();
-    await this._serviceContext.open();
-    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
-    log('opened', { deviceKey });
-  }
+    if (this._open) {
+      return;
+    }
 
-  async close() {
-    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
-    log('closing...', { deviceKey });
-    await this._serviceContext.close();
-    log('closed', { deviceKey });
-  }
+    log('opening...');
 
-  // TODO(burdon): Move into open.
-  async _initialize() {
+    // TODO(wittjosiah): Make re-entrant.
     // TODO(burdon): Break into components.
     this._serviceContext = new ServiceContext(this._storage, this._networkManager, this._modelFactory);
 
     // TODO(burdon): Start to think of DMG (dynamic services).
-    this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
+    this._serviceRegistry.setServices({
+      // TODO(burdon): Move to new protobuf definitions.
+      SystemService: this._systemService,
+
       HaloInvitationsService: new HaloInvitationsServiceImpl(
         this._serviceContext.identityManager,
         this._serviceContext.haloInvitations
@@ -112,8 +154,10 @@ export class ClientServicesHost implements ClientServicesProvider {
 
       // TODO(burdon): Move to new protobuf definitions.
       ProfileService: new ProfileServiceImpl(this._serviceContext),
+
+      // TODO(burdon): Port old SubscribeSpaces to QueryServices>
       SpaceService: new SpaceServiceImpl(this._serviceContext),
-      SystemService: new SystemServiceImpl(this._config, this._serviceContext),
+
       TracingService: new TracingServiceImpl(this._config),
       DevtoolsHost: new DevtoolsServiceImpl({
         events: new DevtoolsHostEvents(),
@@ -121,5 +165,23 @@ export class ClientServicesHost implements ClientServicesProvider {
         context: this._serviceContext
       })
     });
+
+    await this._serviceContext.open();
+    this._open = true;
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('opened', { deviceKey });
+  }
+
+  async close() {
+    if (!this._open) {
+      return;
+    }
+
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('closing...', { deviceKey });
+    this._serviceRegistry.setServices({ SystemService: this._systemService });
+    await this._serviceContext.close();
+    this._open = false;
+    log('closed', { deviceKey });
   }
 }

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

@@ -13,6 +13,7 @@ import { describe, test } from '@dxos/test';
 
 import { SpaceInvitationsProxy, 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).
@@ -54,7 +55,7 @@ describe('service registry', () => {
 
     const server = createProtoRpcPeer({
       exposed: serviceRegistry.descriptors,
-      handlers: serviceRegistry.services,
+      handlers: serviceRegistry.services as ClientServices,
       port: serverPort
     });
 

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

@@ -11,7 +11,7 @@ export class ServiceRegistry<Services> {
   // prettier-ignore
   constructor (
     private readonly _serviceBundle: ServiceBundle<Services>,
-    private readonly _handlers: Services
+    private _handlers: Partial<Services>
   ) {}
 
   get descriptors() {
@@ -21,4 +21,8 @@ export class ServiceRegistry<Services> {
   get services() {
     return this._handlers;
   }
+
+  setServices(services: Partial<Services>) {
+    this._handlers = services;
+  }
 }

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

@@ -0,0 +1,131 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { createAdmissionCredentials } from '@dxos/credentials';
+import { DocumentModel } from '@dxos/document-model';
+import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
+import { writeMessages } from '@dxos/feed-store';
+import { log } from '@dxos/log';
+import { ModelFactory } from '@dxos/model-factory';
+import { test, describe } from '@dxos/test';
+
+import { createSigningContext, syncItems, TestBuilder } from '../testing';
+import { DataSpaceManager } from './data-space-manager';
+
+describe('DataSpaceManager', () => {
+  test('create space', async () => {
+    const builder = new TestBuilder();
+
+    const peer = builder.createPeer();
+    const identity = await createSigningContext(peer.keyring);
+    const dataSpaceManager = new DataSpaceManager(
+      peer.spaceManager,
+      peer.metadataStore,
+      new DataServiceSubscriptions(),
+      peer.keyring,
+      identity,
+      new ModelFactory().registerModel(DocumentModel),
+      peer.feedStore,
+      peer.snapshotStore
+    );
+    const space = await dataSpaceManager.createSpace();
+
+    // Process all written mutations.
+    await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+
+    expect(space.inner.spaceState.genesisCredential).to.exist;
+    expect(space.inner.spaceState.members.size).to.equal(1);
+    expect(space.inner.spaceState.feeds.size).to.equal(2);
+    expect(space.inner.protocol.feeds.size).to.equal(2);
+  });
+
+  test('sync between peers', async () => {
+    const builder = new TestBuilder();
+
+    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
+    });
+
+    log('', {
+      peer1: {
+        identity: identity1.identityKey,
+        device: identity1.deviceKey,
+        control: space1.inner.controlFeedKey,
+        data: space1.inner.dataFeedKey
+      },
+      peer2: {
+        identity: identity2.identityKey,
+        device: identity2.deviceKey,
+        control: space2.inner.controlFeedKey,
+        data: space2.inner.dataFeedKey
+      }
+    });
+
+    await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
+    await space2.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
+
+    log('', {
+      space1: {
+        timeframe: space1.inner.controlPipeline.state.timeframe,
+        endTimeframe: space1.inner.controlPipeline.state.endTimeframe
+      },
+      space2: {
+        timeframe: space2.inner.controlPipeline.state.timeframe,
+        endTimeframe: space2.inner.controlPipeline.state.endTimeframe
+      }
+    });
+    log.break();
+
+    await syncItems(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);
+  });
+});