@dxos/client-services 0.1.0

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

@@ -0,0 +1,141 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Stream } from '@dxos/codec-protobuf';
+import { Config } from '@dxos/config';
+import { todo } from '@dxos/debug';
+import {
+  ClearSnapshotsRequest,
+  DevtoolsHost,
+  EnableDebugLoggingRequest,
+  EnableDebugLoggingResponse,
+  Event,
+  GetConfigResponse,
+  GetNetworkPeersRequest,
+  GetNetworkPeersResponse,
+  GetPartySnapshotRequest,
+  GetPartySnapshotResponse,
+  ResetStorageRequest,
+  SavePartySnapshotRequest,
+  SavePartySnapshotResponse,
+  SubscribeToCredentialMessagesRequest,
+  SubscribeToCredentialMessagesResponse,
+  SubscribeToFeedBlocksRequest,
+  SubscribeToFeedBlocksResponse,
+  SubscribeToFeedsRequest,
+  SubscribeToFeedsResponse,
+  SubscribeToItemsRequest,
+  SubscribeToItemsResponse,
+  SubscribeToKeyringKeysRequest,
+  SubscribeToKeyringKeysResponse,
+  SubscribeToNetworkTopicsResponse,
+  SubscribeToPartiesRequest,
+  SubscribeToPartiesResponse,
+  SubscribeToSignalStatusResponse,
+  SubscribeToSignalTraceResponse,
+  SubscribeToSwarmInfoResponse
+} from '@dxos/protocols/proto/dxos/devtools/host';
+
+import {
+  DevtoolsHostEvents,
+  subscribeToNetworkStatus,
+  subscribeToSignalTrace,
+  subscribeToSwarmInfo,
+  subscribeToSpaces,
+  subscribeToFeedBlocks,
+  subscribeToFeeds
+} from '../../devtools';
+import { ServiceContext } from '../service-context';
+
+export type DevtoolsServiceParams = {
+  events: DevtoolsHostEvents;
+  config: Config;
+  context: ServiceContext;
+};
+
+export class DevtoolsService implements DevtoolsHost {
+  constructor(private readonly params: DevtoolsServiceParams) {}
+
+  events(request: void): Stream<Event> {
+    return new Stream<Event>(({ next }) => {
+      this.params.events.ready.on(() => {
+        next({ ready: {} });
+      });
+    });
+  }
+
+  getConfig(request: void): Promise<GetConfigResponse> {
+    todo();
+  }
+
+  resetStorage(request: ResetStorageRequest): Promise<void> {
+    todo();
+  }
+
+  enableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
+    todo();
+  }
+
+  disableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
+    todo();
+  }
+
+  subscribeToKeyringKeys(request: SubscribeToKeyringKeysRequest): Stream<SubscribeToKeyringKeysResponse> {
+    todo();
+  }
+
+  subscribeToCredentialMessages(
+    request: SubscribeToCredentialMessagesRequest
+  ): Stream<SubscribeToCredentialMessagesResponse> {
+    todo();
+  }
+
+  subscribeToParties(request: SubscribeToPartiesRequest): Stream<SubscribeToPartiesResponse> {
+    return subscribeToSpaces(this.params.context, request);
+  }
+
+  subscribeToItems(request: SubscribeToItemsRequest): Stream<SubscribeToItemsResponse> {
+    todo();
+  }
+
+  subscribeToFeeds(request: SubscribeToFeedsRequest): Stream<SubscribeToFeedsResponse> {
+    return subscribeToFeeds({ feedStore: this.params.context.feedStore }, request);
+  }
+
+  subscribeToFeedBlocks(request: SubscribeToFeedBlocksRequest): Stream<SubscribeToFeedBlocksResponse> {
+    return subscribeToFeedBlocks({ feedStore: this.params.context.feedStore }, request);
+  }
+
+  getPartySnapshot(request: GetPartySnapshotRequest): Promise<GetPartySnapshotResponse> {
+    todo();
+  }
+
+  savePartySnapshot(request: SavePartySnapshotRequest): Promise<SavePartySnapshotResponse> {
+    todo();
+  }
+
+  clearSnapshots(request: ClearSnapshotsRequest): Promise<void> {
+    todo();
+  }
+
+  getNetworkPeers(request: GetNetworkPeersRequest): Promise<GetNetworkPeersResponse> {
+    todo();
+  }
+
+  subscribeToNetworkTopics(request: void): Stream<SubscribeToNetworkTopicsResponse> {
+    todo();
+  }
+
+  subscribeToSignalStatus(request: void): Stream<SubscribeToSignalStatusResponse> {
+    return subscribeToNetworkStatus({ networkManager: this.params.context.networkManager });
+  }
+
+  subscribeToSignalTrace(): Stream<SubscribeToSignalTraceResponse> {
+    return subscribeToSignalTrace({ networkManager: this.params.context.networkManager });
+  }
+
+  subscribeToSwarmInfo(): Stream<SubscribeToSwarmInfoResponse> {
+    return subscribeToSwarmInfo({ networkManager: this.params.context.networkManager });
+  }
+}

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

@@ -0,0 +1,107 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { EventSubscriptions } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { ObjectModel } from '@dxos/object-model';
+import {
+  AddKeyRecordRequest,
+  Contacts,
+  HaloService as HaloServiceRpc,
+  SignRequest,
+  SignResponse,
+  SetPreferenceRequest,
+  GetPreferenceRequest,
+  GetPreferenceResponse
+} from '@dxos/protocols/proto/dxos/client';
+
+import { HaloSigner } from '../signer';
+
+/**
+ * HALO service implementation.
+ */
+export class HaloService implements HaloServiceRpc {
+  constructor(
+    private readonly echo: any, // TODO(burdon): Remove.
+    private readonly signer?: HaloSigner
+  ) {}
+
+  // TODO(burdon): Rename signMessage? (in interface).
+  // TODO(burdon): Why is this part of the interface? (Can it be factored out completely?)
+  async sign(request: SignRequest): Promise<SignResponse> {
+    assert(this.signer, 'Signer not set.');
+    assert(request.publicKey, 'Provide a public_key of the key that should be used for signing.');
+    const key = await this.echo.halo.keyring.getFullKey(request.publicKey);
+    assert(key, `Key not found: ${request.publicKey.toHex()}`);
+    return this.signer.sign(request, key);
+  }
+
+  async addKeyRecord(request: AddKeyRecordRequest): Promise<void> {
+    assert(request.keyRecord && request.keyRecord.publicKey, 'Missing key record.');
+    await this.echo.halo.keyring.addKeyRecord(request.keyRecord);
+    assert(await this.echo.halo.keyring.getKey(request.keyRecord.publicKey), 'Key not inserted correctly.');
+  }
+
+  // TODO(burdon): subscribeToContacts or just query/contacts with subscription object.
+  //  ResultSet vs Stream?
+  subscribeContacts(): Stream<Contacts> {
+    return new Stream(({ next }) => {
+      next({ contacts: [] });
+    });
+    if (this.echo.halo.identity) {
+      // return resultSetToStream(this.echo.halo.queryContacts(), (contacts): Contacts => ({ contacts }));
+    }
+
+    // TODO(burdon): Explain non-initialized path.
+    return new Stream(({ next }) => {
+      // If profile does not exist, send an empty array.
+      if (!this.echo.halo.identity) {
+        next({ contacts: [] });
+      }
+
+      const subscriptions = new EventSubscriptions();
+      setTimeout(async () => {
+        await this.echo.halo.identityReady.waitForCondition(() => !!this.echo.halo.identity);
+
+        const resultSet = this.echo.halo.queryContacts();
+        next({ contacts: resultSet.value });
+        subscriptions.add(resultSet.update.on(() => next({ contacts: resultSet.value })));
+      });
+
+      return () => subscriptions.clear();
+    });
+  }
+
+  async setGlobalPreference(request: SetPreferenceRequest): Promise<void> {
+    assert(request.key, 'Missing key of property.');
+    const preferences: ObjectModel | undefined = this.echo.halo.identity?.preferences?.getGlobalPreferences()?.model;
+    assert(preferences, 'Preferences failed to load.');
+    await preferences.setProperty(request.key, request.value);
+  }
+
+  async getGlobalPreference(request: GetPreferenceRequest): Promise<GetPreferenceResponse> {
+    assert(request.key, 'Missing key of property.');
+    const preferences: ObjectModel | undefined = this.echo.halo.identity?.preferences?.getGlobalPreferences()?.model;
+    return {
+      value: preferences?.getProperty(request.key)
+    };
+  }
+
+  async setDevicePreference(request: SetPreferenceRequest): Promise<void> {
+    assert(request.key, 'Missing key of property.');
+    const preferences: ObjectModel | undefined = this.echo.halo.identity?.preferences?.getDevicePreferences()?.model;
+    assert(preferences, 'Preferences failed to load.');
+    await preferences.setProperty(request.key, request.value);
+  }
+
+  async getDevicePreference(request: GetPreferenceRequest): Promise<GetPreferenceResponse> {
+    assert(request.key, 'Missing key of property.');
+    const preferences: ObjectModel | undefined = this.echo.halo.identity?.preferences?.getDevicePreferences()?.model;
+    return {
+      value: preferences?.getProperty(request.key)
+    };
+  }
+}

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

@@ -0,0 +1,11 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// TODO(burdon): Add data service here.
+
+export * from './halo';
+export * from './party';
+export * from './profile';
+export * from './system';
+export * from './tracing';

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

@@ -0,0 +1,305 @@
+//
+// 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 { todo } from '@dxos/debug';
+import {
+  AuthenticateInvitationRequest,
+  CreateInvitationRequest,
+  CreateSnapshotRequest,
+  GetPartyDetailsRequest,
+  InvitationRequest,
+  InvitationState,
+  Party,
+  PartyDetails,
+  PartyService as PartyServiceRpc,
+  RedeemedInvitation,
+  SetPartyStateRequest,
+  SubscribeMembersRequest,
+  SubscribeMembersResponse,
+  SubscribePartiesResponse,
+  SubscribePartyRequest,
+  SubscribePartyResponse
+} from '@dxos/protocols/proto/dxos/client';
+import { PartySnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
+import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+
+import { InvitationWrapper, InviteeInvitation, InviteeInvitations } from '../../invitations';
+import { ServiceContext } from '../service-context';
+
+/**
+ * Party service implementation.
+ */
+// TODO(burdon): Rename Space.
+export class PartyService implements PartyServiceRpc {
+  private inviteeInvitations: InviteeInvitations = new Map();
+
+  constructor(private readonly serviceContext: ServiceContext) {}
+
+  subscribeToParty(request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
+    return new Stream(({ next }) => {
+      next({
+        party: {
+          publicKey: request.partyKey,
+          isOpen: true,
+          isActive: true,
+          members: []
+        }
+      });
+    });
+    // const update = (next: (message: SubscribePartyResponse) => void) => {
+    //   try {
+    //     const party = this.echo.getParty(request.party_key);
+    //     next({
+    //       party: party && {
+    //         public_key: party.key,
+    //         is_open: party.is_open,
+    //         is_active: party.is_active,
+    //         members: party.queryMembers().value
+    //       }
+    //     });
+    //   } catch (err) {
+    //     if (err instanceof InvalidStateError) {
+    //       // Do nothing.
+    //     } else {
+    //       throw err;
+    //     }
+    //   }
+    // };
+
+    // const party = this.serviceContext.brane.getParty(request.party_key);
+    // if (party) {
+    //   return new Stream(({ next }) => party.update.on(() => update(next)));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeParty: () => void;
+    //     const unsubscribeParties = this.echo.queryParties().subscribe((parties) => {
+    //       const party = parties.find((party) => party.key.equals(request.party_key));
+    //       if (party && !unsubscribeParty) {
+    //         unsubscribeParty = party.update.on(() => update(next));
+    //       }
+    //     });
+
+    //     update(next);
+
+    //     return () => {
+    //       unsubscribeParties();
+    //       unsubscribeParty?.();
+    //     };
+    //   });
+    // }
+  }
+
+  subscribeParties() {
+    return new Stream<SubscribePartiesResponse>(({ next }) => {
+      const update = () => {
+        next({
+          parties: Array.from(this.serviceContext.spaceManager!.spaces.values()).map((space) => ({
+            publicKey: space.key,
+            isOpen: true,
+            isActive: true
+          }))
+        });
+      };
+
+      setTimeout(async () => {
+        if (!this.serviceContext.spaceManager) {
+          next({ parties: [] });
+        }
+
+        await this.serviceContext.initialized.wait();
+
+        update();
+        return this.serviceContext.spaceManager!.update.on(update);
+      });
+    });
+  }
+
+  async getPartyDetails(request: GetPartyDetailsRequest): Promise<PartyDetails> {
+    return todo();
+    // const party = this.echo.getParty(request.party_key) ?? raise(new SpaceNotFoundError(request.party_key));
+    // return {
+    //   processedTimeframe: party.timeframe
+    // };
+  }
+
+  async createParty(): Promise<Party> {
+    await this.serviceContext.initialized.wait();
+    const space = await this.serviceContext.spaceManager!.createSpace();
+    return {
+      publicKey: space.key,
+      isOpen: true,
+      isActive: true
+    };
+  }
+
+  async cloneParty(snapshot: PartySnapshot): Promise<Party> {
+    return todo();
+    // const party = await this.echo.cloneParty(snapshot);
+    // return {
+    //   public_key: party.key,
+    //   is_open: party.is_open,
+    //   is_active: party.is_active
+    // };
+  }
+
+  async setPartyState(request: SetPartyStateRequest) {
+    return todo();
+    // const party = this.echo.getParty(request.party_key);
+    // if (!party) {
+    //   throw new Error('Party not found');
+    // }
+
+    // if (request.open === true) {
+    //   await party.open();
+    // } else if (request.open === false) {
+    //   await party.close();
+    // } // Undefined preserves previous state.
+
+    // if (request.active_global === true) {
+    //   await party.activate({ global: true });
+    // } else if (request.active_global === false) {
+    //   await party.deactivate({ global: true });
+    // } // Undefined preserves previous state.
+
+    // if (request.active_device === true) {
+    //   await party.activate({ device: true });
+    // } else if (request.active_device === false) {
+    //   await party.deactivate({ device: true });
+    // } // Undefined preserves previous state.
+    // return {
+    //   public_key: party.key,
+    //   is_open: party.is_open,
+    //   is_active: party.is_active
+    // };
+  }
+
+  createInvitation(request: CreateInvitationRequest): Stream<InvitationRequest> {
+    return new Stream(({ next, close }) => {
+      setTimeout(async () => {
+        try {
+          let invitation: InvitationWrapper;
+          if (!request.inviteeKey) {
+            // const secret = Buffer.from(generatePasscode());
+            // const secretProvider = async () => {
+            //   next({ state: InvitationState.CONNECTED });
+            //   return Buffer.from(secret);
+            // };
+            invitation = await this.serviceContext.createInvitation(request.partyKey, () => {
+              next({ state: InvitationState.SUCCESS });
+              close();
+            });
+
+            assert(invitation.type === InvitationDescriptor.Type.INTERACTIVE);
+            // invitation.secret = Buffer.from(secret);
+          } else {
+            todo();
+            // invitation = await party.invitationManager.createOfflineInvitation(request.invitee_key);
+          }
+
+          // TODO(burdon): Change stream type.
+          next({
+            state: InvitationState.WAITING_FOR_CONNECTION,
+            descriptor: invitation!.toProto()
+          });
+
+          // if (invitation.type === InvitationDescriptor.Type.OFFLINE) {
+          //   close();
+          // }
+        } catch (err: any) {
+          next({ state: InvitationState.ERROR, error: err.message });
+          close();
+        }
+      });
+    });
+  }
+
+  acceptInvitation(request: 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 partyPromise = this.serviceContext.acceptInvitation(InvitationWrapper.fromProto(request));
+      this.inviteeInvitations.set(id, inviteeInvitation);
+      next({ id, state: InvitationState.CONNECTED });
+
+      partyPromise
+        .then((party) => {
+          next({ id, state: InvitationState.SUCCESS, partyKey: party.key });
+        })
+        .catch((err) => {
+          console.error(err);
+          next({ id, state: InvitationState.ERROR, error: String(err) });
+        })
+        .finally(() => {
+          close();
+        });
+    });
+  }
+
+  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?.();
+  }
+
+  subscribeMembers(request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
+    return new Stream(({ next }) => {
+      next({
+        members: []
+      });
+    });
+    // const party = this.echo.getParty(request.party_key);
+    // if (party) {
+    //   return resultSetToStream(party.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeMembers: () => void;
+    //     const unsubscribeParties = this.echo.queryParties().subscribe((parties) => {
+    //       const party = parties.find((party) => party.key.equals(request.party_key));
+    //       if (!unsubscribeMembers && party) {
+    //         const resultSet = party.queryMembers();
+    //         next({ members: resultSet.value });
+    //         unsubscribeMembers = resultSet.update.on(() => next({ members: resultSet.value }));
+    //       }
+    //     });
+
+    //     return () => {
+    //       unsubscribeParties();
+    //       unsubscribeMembers();
+    //     };
+    //   });
+    // }
+  }
+
+  async createSnapshot(request: CreateSnapshotRequest): Promise<PartySnapshot> {
+    return todo();
+    // assert(request.party_key);
+    // const party = this.echo.getParty(request.party_key) ?? raise(new SpaceNotFoundError(request.party_key));
+    // return party.createSnapshot();
+  }
+}