@dxos/client-services 0.1.0

package/src/packlets/services/impl/profile.ts

@@ -0,0 +1,141 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+import { v4 } from 'uuid';
+
+import { latch } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { generatePasscode } from '@dxos/credentials';
+import { todo } from '@dxos/debug';
+import {
+  AuthenticateInvitationRequest,
+  CreateProfileRequest,
+  InvitationRequest,
+  InvitationState,
+  Profile,
+  ProfileService as ProfileServiceRpc,
+  RecoverProfileRequest,
+  RedeemedInvitation,
+  SubscribeProfileResponse
+} from '@dxos/protocols/proto/dxos/client';
+import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+
+import { InviteeInvitation, InviteeInvitations } from '../../invitations';
+import { ServiceContext } from '../service-context';
+
+/**
+ * Profile service implementation.
+ */
+export class ProfileService implements ProfileServiceRpc {
+  private inviteeInvitations: InviteeInvitations = new Map();
+
+  constructor(private readonly context: ServiceContext) {}
+
+  subscribeProfile(): Stream<SubscribeProfileResponse> {
+    return new Stream(({ next }) => {
+      const emitNext = () =>
+        next({
+          profile: this.context.identityManager.identity
+            ? {
+                publicKey: this.context.identityManager.identity.identityKey
+              }
+            : undefined
+        });
+
+      emitNext();
+      return this.context.identityManager.stateUpdate.on(emitNext);
+    });
+  }
+
+  async createProfile(request: CreateProfileRequest): Promise<Profile> {
+    await this.context.createIdentity();
+    return { publicKey: this.context.identityManager.identity!.identityKey };
+  }
+
+  async recoverProfile(request: RecoverProfileRequest): Promise<Profile> {
+    return todo();
+    if (!request.seedPhrase) {
+      throw new Error('Recovery SeedPhrase not provided.');
+    }
+    // await this.echo.open();
+    // await this.echo.halo.recover(request.seed_phrase);
+    // const profile = this.echo.halo.getProfile();
+    // assert(profile, 'Recovering profile failed.');
+    // return profile;
+  }
+
+  createInvitation(): Stream<InvitationRequest> {
+    return new Stream(({ next, close }) => {
+      setTimeout(async () => {
+        const secret = Buffer.from(generatePasscode());
+        // TODO(burdon): Not used.
+        // const secretProvider = async () => {
+        //   next({ descriptor: invitation.toProto(), state: InvitationState.CONNECTED });
+        //   return Buffer.from(secret);
+        // };
+
+        const invitation = await this.context.haloInvitations.createInvitation({
+          onFinish: () => {
+            next({ state: InvitationState.SUCCESS });
+            close();
+          }
+        });
+        invitation.secret = secret;
+
+        next({
+          state: InvitationState.WAITING_FOR_CONNECTION,
+          descriptor: invitation
+        });
+      });
+    });
+  }
+
+  acceptInvitation(invitation: InvitationDescriptor): Stream<RedeemedInvitation> {
+    return new Stream(({ next, close }) => {
+      const id = v4();
+      const [, secretTrigger] = latch();
+      const inviteeInvitation: InviteeInvitation = { secretTrigger };
+
+      // Secret will be provided separately (in AuthenticateInvitation).
+      // Process will continue when `secretLatch` resolves, triggered by `secretTrigger`.
+      // const secretProvider: SecretProvider = async () => {
+      //   await secretLatch;
+      //   const secret = inviteeInvitation.secret;
+      //   if (!secret) {
+      //     throw new Error('Secret not provided.');
+      //   }
+      //   return Buffer.from(secret);
+      // };
+
+      // Joining process is kicked off, and will await authentication with a secret.
+      const haloPartyPromise = this.context.haloInvitations.acceptInvitation(invitation);
+      this.inviteeInvitations.set(id, inviteeInvitation);
+      next({ id, state: InvitationState.CONNECTED });
+
+      haloPartyPromise
+        .then((identity) => {
+          next({
+            id,
+            state: InvitationState.SUCCESS,
+            partyKey: identity.identityKey
+          });
+        })
+        .catch((err) => {
+          next({ id, state: InvitationState.ERROR, error: String(err) });
+        });
+    });
+  }
+
+  async authenticateInvitation(request: AuthenticateInvitationRequest) {
+    assert(request.processId, 'Process ID is missing.');
+    const invitation = this.inviteeInvitations.get(request.processId);
+    assert(invitation, 'Invitation not found.');
+    assert(request.secret, 'Secret not provided.');
+
+    // Supply the secret, and move the internal invitation process by triggering the secretTrigger.
+    invitation.secret = request.secret;
+    invitation.secretTrigger?.();
+  }
+}

package/src/packlets/services/impl/system.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Config } from '@dxos/config';
+import { todo } from '@dxos/debug';
+import { SystemService as SystemServiceRpc } from '@dxos/protocols/proto/dxos/client';
+
+export class SystemService implements SystemServiceRpc {
+  constructor(private readonly _config: Config) {}
+
+  async getConfig(request: void) {
+    return this._config.values;
+  }
+
+  async reset(request: any) {
+    todo();
+  }
+}

package/src/packlets/services/impl/tracing.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Config } from '@dxos/config';
+import { TracingService as TracingServiceRpc } from '@dxos/protocols/proto/dxos/devtools/host';
+
+/**
+ *
+ */
+export class TracingService implements TracingServiceRpc {
+  constructor(private readonly _config: Config) {}
+
+  async setTracingOptions() {
+    throw new Error('Tracing not available.');
+  }
+
+  subscribeToRpcTrace(): any {
+    throw new Error('Tracing not available.');
+  }
+}

package/src/packlets/services/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './service-context';
+export * from './service-factory';
+export * from './service-host';
+export * from './services';
+export * from './signer';

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

@@ -0,0 +1,151 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Trigger } from '@dxos/async';
+import { failUndefined, raise } from '@dxos/debug';
+import {
+  MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER,
+  valueEncoding,
+  DataService,
+  MetadataStore,
+  SpaceManager,
+  SigningContext
+} from '@dxos/echo-db';
+import { FeedFactory, FeedStore } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
+import { PublicKey } from '@dxos/keys';
+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 { Storage } from '@dxos/random-access-storage';
+
+import { IdentityManager } from '../identity';
+import { HaloInvitations, InvitationWrapper, SpaceInvitations } from '../invitations';
+
+/**
+ * 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();
+
+  // TODO(burdon): Factor out with other services.
+  public readonly dataService = new DataService();
+
+  public readonly metadataStore: MetadataStore;
+  public readonly feedStore: FeedStore<FeedMessage>;
+  public readonly keyring: Keyring;
+  public readonly identityManager: IdentityManager;
+  public readonly haloInvitations: HaloInvitations;
+
+  // Initialized after identity is initialized.
+  public spaceManager?: SpaceManager;
+  public spaceInvitations?: SpaceInvitations;
+
+  // prettier-ignore
+  constructor(
+    public readonly storage: Storage,
+    public readonly networkManager: NetworkManager,
+    public readonly modelFactory: ModelFactory
+  ) {
+    // TODO(burdon): Move strings to constants.
+    this.metadataStore = new MetadataStore(storage.createDirectory('metadata'));
+    this.keyring = new Keyring(storage.createDirectory('keyring'));
+    this.feedStore = new FeedStore<FeedMessage>({
+      factory: new FeedFactory<FeedMessage>({
+        root: storage.createDirectory('feeds'),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding
+        }
+      })
+    });
+
+    this.identityManager = new IdentityManager(
+      this.metadataStore,
+      this.feedStore,
+      this.keyring,
+      networkManager,
+      modelFactory
+    );
+
+    // TODO(burdon): _initialize called in multiple places.
+    this.haloInvitations = new HaloInvitations(this.identityManager, this.networkManager, async () => {
+      await this._initialize();
+    });
+  }
+
+  async open() {
+    log('opening...');
+    await this.identityManager.open();
+    if (this.identityManager.identity) {
+      await this._initialize();
+    }
+    log('opened');
+  }
+
+  async close() {
+    log('closing...');
+    await this.identityManager.close();
+    await this.spaceManager?.close();
+    await this.feedStore.close();
+    await this.networkManager.destroy(); // TODO(burdon): Close.
+    log('closed');
+  }
+
+  async createIdentity() {
+    const identity = await this.identityManager.createIdentity();
+    this.dataService.trackParty(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
+    await this._initialize();
+    return identity;
+  }
+
+  async createInvitation(spaceKey: PublicKey, onFinish?: () => void): Promise<InvitationWrapper> {
+    assert(this.spaceManager);
+    assert(this.spaceInvitations);
+
+    const space = this.spaceManager.spaces.get(spaceKey) ?? raise(new Error('Space not found.'));
+    const invitation = await this.spaceInvitations.createInvitation(space, { onFinish });
+    return InvitationWrapper.fromProto(invitation);
+  }
+
+  async acceptInvitation(invitationDescriptor: InvitationWrapper) {
+    assert(this.spaceInvitations);
+
+    return this.spaceInvitations.acceptInvitation(invitationDescriptor.toProto());
+  }
+
+  private async _initialize() {
+    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
+    };
+
+    // Create in constructor (avoid all of these private variables).
+    const spaceManager = new SpaceManager({
+      metadataStore: this.metadataStore,
+      feedStore: this.feedStore,
+      networkManager: this.networkManager,
+      keyring: this.keyring,
+      dataService: this.dataService,
+      modelFactory: this.modelFactory,
+      signingContext
+    });
+
+    await spaceManager.open();
+
+    this.spaceManager = spaceManager;
+    this.spaceInvitations = new SpaceInvitations(this.spaceManager, this.networkManager, signingContext);
+
+    this.initialized.wake();
+  }
+}

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

@@ -0,0 +1,35 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Config } from '@dxos/config';
+import { NetworkManager } from '@dxos/network-manager';
+
+import { DevtoolsHostEvents } from '../devtools';
+import { HaloService, PartyService, ProfileService, SystemService, TracingService } from './impl';
+import { DevtoolsService } from './impl/devtools';
+import { ServiceContext } from './service-context';
+import { ClientServices } from './services';
+import { HaloSigner } from './signer';
+
+/**
+ * Service factory.
+ */
+export const createServices = ({
+  config,
+  context, // TODO(burdon): Too big to pass into services.?
+  signer // TODO(burdon): Remove (legacy?)
+}: {
+  config: Config;
+  context: ServiceContext;
+  networkManager: NetworkManager;
+  signer?: HaloSigner;
+}): ClientServices => ({
+  DataService: context.dataService,
+  HaloService: new HaloService(null, signer), // TODO(burdon): Remove.
+  PartyService: new PartyService(context),
+  ProfileService: new ProfileService(context),
+  SystemService: new SystemService(config),
+  TracingService: new TracingService(config),
+  DevtoolsHost: new DevtoolsService({ events: new DevtoolsHostEvents(), config, context })
+});

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

@@ -0,0 +1,88 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { latch, Trigger } from '@dxos/async';
+import { Config, ConfigProto } from '@dxos/config';
+import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
+import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { InvitationState } from '@dxos/protocols/proto/dxos/client';
+import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { afterTest } from '@dxos/testutils';
+
+import { ClientServiceHost } from './service-host';
+
+const defaultTestingConfig: ConfigProto = {
+  version: 1
+  // runtime: {
+  //   services: {
+  //     signal: {
+  //       server: 'ws://localhost:4000/.well-known/dx/signal'
+  //     }
+  //   }
+  // }
+};
+
+describe('services/service-host', function () {
+  // TODO(burdon): Factor out.
+  const createPeer = (signalManagerContext: MemorySignalManagerContext) => {
+    const networkManager = new NetworkManager({
+      signalManager: new MemorySignalManager(signalManagerContext),
+      transportFactory: MemoryTransportFactory
+    });
+
+    return new ClientServiceHost({
+      config: new Config(defaultTestingConfig),
+      networkManager
+    });
+  };
+
+  it('process device invitation', async function () {
+    const signalManagerContext = new MemorySignalManagerContext();
+
+    const peer1 = createPeer(signalManagerContext);
+    const peer2 = createPeer(signalManagerContext);
+    await peer1.open();
+    await peer2.open();
+    afterTest(() => peer1.close());
+    afterTest(() => peer2.close());
+
+    const invitationTrigger = new Trigger<InvitationDescriptor>();
+    {
+      await peer1.services.ProfileService.createProfile({});
+      const stream = peer1.services.ProfileService.createInvitation();
+      stream.subscribe((msg) => {
+        switch (msg.state) {
+          case InvitationState.WAITING_FOR_CONNECTION: {
+            invitationTrigger.wake(msg.descriptor!);
+            break;
+          }
+        }
+      });
+    }
+
+    const [done, setAck] = latch({ count: 2 });
+    {
+      const invitation = await invitationTrigger.wait();
+      const stream = peer2.services.ProfileService.acceptInvitation(invitation);
+      stream.subscribe((msg) => {
+        switch (msg.state) {
+          case InvitationState.CONNECTED: {
+            setAck();
+            break;
+          }
+
+          case InvitationState.SUCCESS: {
+            expect(msg.partyKey).not.to.be.undefined;
+            setAck();
+            break;
+          }
+        }
+      });
+    }
+
+    await done();
+  });
+});

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

@@ -0,0 +1,101 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import assert from 'assert';
+
+import { Config } from '@dxos/config';
+import { log } from '@dxos/log';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import { ModelFactory } from '@dxos/model-factory';
+import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { ObjectModel } from '@dxos/object-model';
+
+import { createStorageObjects } from '../storage';
+import { ServiceContext } from './service-context';
+import { createServices } from './service-factory';
+import { ClientServiceProvider, ClientServices } from './services';
+import { HaloSigner } from './signer';
+// import { DevtoolsHostEvents } from '../devtools';
+
+// TODO(burdon): Remove (no memory defaults).
+const memorySignalManagerContext = new MemorySignalManagerContext();
+
+// TODO(burdon): Factor out.
+export const createNetworkManager = (config: Config): NetworkManager => {
+  const signalServer = config.get('runtime.services.signal.server');
+  // TODO(burdon): Remove.
+  if (!signalServer) {
+    log.warn('DEPRECATED: falling back to MemorySignalManager');
+    return new NetworkManager({
+      log: true,
+      signalManager: new MemorySignalManager(memorySignalManagerContext),
+      transportFactory: MemoryTransportFactory
+    });
+  }
+  assert(signalServer);
+
+  return new NetworkManager({
+    log: true,
+    signalManager: new WebsocketSignalManager([signalServer]),
+    transportFactory: createWebRTCTransportFactory({
+      iceServers: config.get('runtime.services.ice')
+    })
+  });
+};
+
+type ClientServiceHostParams = {
+  config: Config;
+  signer?: HaloSigner;
+  modelFactory?: ModelFactory;
+  networkManager: NetworkManager;
+};
+
+/**
+ * Remote service implementation.
+ */
+export class ClientServiceHost implements ClientServiceProvider {
+  private readonly _config: Config;
+  private readonly _signer?: HaloSigner;
+  private readonly _context: ServiceContext;
+  private readonly _services: ClientServices;
+
+  constructor({
+    config,
+    modelFactory = new ModelFactory().registerModel(ObjectModel),
+    signer,
+    networkManager
+  }: ClientServiceHostParams) {
+    this._config = config;
+    this._signer = signer;
+
+    // TODO(dmaretskyi): Remove keyStorage.
+    const { storage } = createStorageObjects(this._config.get('runtime.client.storage', {})!);
+    this._context = new ServiceContext(storage, networkManager, modelFactory);
+
+    this._services = createServices({
+      config: this._config,
+      context: this._context,
+      signer: this._signer,
+      networkManager
+    });
+  }
+
+  get services() {
+    return this._services;
+  }
+
+  // TODO(dmaretskyi): progress.
+  async open(onProgressCallback?: ((progress: any) => void) | undefined) {
+    log('opening...');
+    await this._context.open();
+    // this._devtoolsEvents.ready.emit();
+    log('opened');
+  }
+
+  async close() {
+    log('closing...');
+    await this._context.close();
+    log('closed');
+  }
+}

package/src/packlets/services/services.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { schema } from '@dxos/protocols';
+import { PartyService, ProfileService, SystemService, HaloService } from '@dxos/protocols/proto/dxos/client';
+import { DevtoolsHost, TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
+import { DataService } from '@dxos/protocols/proto/dxos/echo/service';
+import { createServiceBundle } from '@dxos/rpc';
+
+// TODO(burdon): Is there a way to mark TS (generics) so cast isn't required for result of stream?
+export type ClientServices = {
+  DataService: DataService;
+  HaloService: HaloService;
+  PartyService: PartyService;
+  ProfileService: ProfileService;
+  SystemService: SystemService;
+
+  DevtoolsHost: DevtoolsHost;
+  TracingService: TracingService;
+};
+
+// TODO(burdon): Rethink name/factory.
+export const clientServiceBundle = createServiceBundle<ClientServices>({
+  DataService: schema.getService('dxos.echo.service.DataService'),
+  HaloService: schema.getService('dxos.client.HaloService'),
+  PartyService: schema.getService('dxos.client.PartyService'),
+  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')
+});
+
+export interface ClientServiceProvider {
+  services: ClientServices;
+  open(onProgressCallback?: ((progress: any) => void) | undefined): Promise<void>;
+  close(): Promise<void>;
+}

package/src/packlets/services/signer.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { SignRequest, SignResponse } from '@dxos/protocols/proto/dxos/client';
+import { KeyRecord } from '@dxos/protocols/proto/dxos/halo/keys';
+
+/**
+ *
+ */
+export interface HaloSigner {
+  sign: (request: SignRequest, key: KeyRecord) => Promise<SignResponse>;
+}

package/src/packlets/services/testing/halo.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { MemorySignalManagerContext } from '@dxos/messaging';
+import { afterTest } from '@dxos/testutils';
+
+import { createServiceContext } from './testing';
+
+describe('services/halo', function () {
+  it('creates identity', async function () {
+    const peer = await createServiceContext();
+    await peer.open();
+    afterTest(() => peer.close());
+
+    const identity = await peer.createIdentity();
+    expect(identity).not.to.be.undefined;
+  });
+
+  it('device invitations', async function () {
+    const signalContext = new MemorySignalManagerContext();
+
+    const peer1 = await createServiceContext({ signalContext });
+    const peer2 = await createServiceContext({ signalContext });
+    await peer1.open();
+    await peer2.open();
+    afterTest(() => peer1.close());
+    afterTest(() => peer2.close());
+
+    const identity1 = await peer1.createIdentity();
+    expect(peer1.identityManager.identity).to.eq(identity1);
+    expect(peer2.identityManager.identity).to.be.undefined;
+
+    const invitation = await peer1.haloInvitations.createInvitation();
+    const identity2 = await peer2.haloInvitations.acceptInvitation(invitation);
+    expect(identity2.identityKey).to.deep.eq(identity1.identityKey);
+  });
+});