@dxos/client-services 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client-services",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -15,39 +15,39 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "0.1.2",
-    "@dxos/codec-protobuf": "0.1.2",
-    "@dxos/config": "0.1.2",
-    "@dxos/credentials": "0.1.2",
-    "@dxos/crypto": "0.1.2",
-    "@dxos/debug": "0.1.2",
-    "@dxos/echo-db": "0.1.2",
-    "@dxos/feed-store": "0.1.2",
-    "@dxos/keyring": "0.1.2",
-    "@dxos/keys": "0.1.2",
-    "@dxos/log": "0.1.2",
-    "@dxos/messaging": "0.1.2",
-    "@dxos/model-factory": "0.1.2",
-    "@dxos/network-manager": "0.1.2",
-    "@dxos/object-model": "0.1.2",
-    "@dxos/protocol-plugin-rpc": "0.1.2",
-    "@dxos/protocols": "0.1.2",
-    "@dxos/random-access-storage": "0.1.2",
-    "@dxos/rpc": "0.1.2",
-    "@dxos/testutils": "0.1.2",
-    "@dxos/timeframe": "0.1.2",
-    "@dxos/util": "0.1.2",
+    "@dxos/async": "0.1.4",
+    "@dxos/codec-protobuf": "0.1.4",
+    "@dxos/config": "0.1.4",
+    "@dxos/credentials": "0.1.4",
+    "@dxos/crypto": "0.1.4",
+    "@dxos/debug": "0.1.4",
+    "@dxos/echo-db": "0.1.4",
+    "@dxos/feed-store": "0.1.4",
+    "@dxos/keyring": "0.1.4",
+    "@dxos/keys": "0.1.4",
+    "@dxos/log": "0.1.4",
+    "@dxos/messaging": "0.1.4",
+    "@dxos/model-factory": "0.1.4",
+    "@dxos/network-manager": "0.1.4",
+    "@dxos/object-model": "0.1.4",
+    "@dxos/protocol-plugin-rpc": "0.1.4",
+    "@dxos/protocols": "0.1.4",
+    "@dxos/random-access-storage": "0.1.4",
+    "@dxos/rpc": "0.1.4",
+    "@dxos/rpc-tunnel": "0.1.4",
+    "@dxos/text-model": "0.1.4",
+    "@dxos/timeframe": "0.1.4",
+    "@dxos/util": "0.1.4",
     "abstract-leveldown": "~7.0.0",
     "assert": "^2.0.0",
     "base-x": "~3.0.9",
-    "json-stable-stringify": "^1.0.1",
     "jsondown": "dxos/jsondown#main",
     "level-js": "^5.0.2",
     "memdown": "^5.1.0"
   },
   "devDependencies": {
-    "@dxos/signal": "0.1.2",
-    "@types/json-stable-stringify": "^1.0.32",
+    "@dxos/signal": "0.1.4",
+    "@dxos/testutils": "0.1.4",
     "@types/level-js": "~4.0.1",
     "@types/memdown": "^3.0.0",
     "@types/readable-stream": "^2.3.9"

package/src/index.ts

@@ -2,10 +2,12 @@
 // Copyright 2020 DXOS.org
 //
 
+export * from './errors';
+
+export * from './packlets/deprecated';
 export * from './packlets/devtools';
 export * from './packlets/identity';
 export * from './packlets/invitations';
 export * from './packlets/services';
 export * from './packlets/storage';
-
-export * from './errors';
+export * from './packlets/vault';

package/src/packlets/{services/impl → deprecated}/index.ts

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

package/src/packlets/{invitations/common.ts → deprecated/invitations.ts}

@@ -4,6 +4,10 @@
 
 import { defaultSecretProvider, defaultSecretValidator, SecretProvider, SecretValidator } from '@dxos/credentials';
 
+//
+// TODO(burdon): Deprecated pending new invitations.
+//
+
 /**
  * Defines a way for peers to authenticate each other through a side channel.
  */
@@ -18,7 +22,7 @@ export const defaultInvitationAuthenticator: Required<InvitationAuthenticator> =
 };
 
 /**
- * Additional set of callbacks and options used in the invitation process.
+ * @deprecated
  */
 export interface InvitationOptions {
   /**
@@ -32,17 +36,28 @@ export interface InvitationOptions {
   expiration?: number;
 }
 
-// TODO(burdon): Remove/move to API.
+/**
+ * @deprecated
+ */
 export type InviterInvitation = {
   invitationCode: string;
   secret: Uint8Array | undefined;
 };
 
-// TODO(burdon): Remove/move to API.
+/**
+ * @deprecated
+ */
 export type InviteeInvitation = {
   secret?: Uint8Array | undefined; // Can be undefined initially, then set after receiving secret from the inviter.
   secretTrigger?: () => void; // Is triggered after supplying the secret.
 };
 
+/**
+ * @deprecated
+ */
 export type InviterInvitations = InviterInvitation[];
+
+/**
+ * @deprecated
+ */
 export type InviteeInvitations = Map<string, InviteeInvitation>;

package/src/packlets/{services/impl → deprecated}/profile.ts

@@ -15,20 +15,20 @@ import {
   InvitationRequest,
   InvitationState,
   Profile,
-  ProfileService as ProfileServiceRpc,
+  ProfileService,
   RecoverProfileRequest,
   RedeemedInvitation,
   SubscribeProfileResponse
 } from '@dxos/protocols/proto/dxos/client';
-import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
-import { InviteeInvitation, InviteeInvitations } from '../../invitations';
-import { ServiceContext } from '../service-context';
+import { ServiceContext } from '../services';
+import { InviteeInvitation, InviteeInvitations } from './invitations';
 
 /**
  * Profile service implementation.
  */
-export class ProfileService implements ProfileServiceRpc {
+export class ProfileServiceImpl implements ProfileService {
   private inviteeInvitations: InviteeInvitations = new Map();
 
   constructor(private readonly context: ServiceContext) {}
@@ -39,7 +39,7 @@ export class ProfileService implements ProfileServiceRpc {
         next({
           profile: this.context.identityManager.identity
             ? {
-                publicKey: this.context.identityManager.identity.identityKey
+                identityKey: this.context.identityManager.identity.identityKey
               }
             : undefined
         });
@@ -51,7 +51,7 @@ export class ProfileService implements ProfileServiceRpc {
 
   async createProfile(request: CreateProfileRequest): Promise<Profile> {
     await this.context.createIdentity();
-    return { publicKey: this.context.identityManager.identity!.identityKey };
+    return { identityKey: this.context.identityManager.identity!.identityKey };
   }
 
   async recoverProfile(request: RecoverProfileRequest): Promise<Profile> {
@@ -69,7 +69,7 @@ export class ProfileService implements ProfileServiceRpc {
   createInvitation(): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       setTimeout(async () => {
-        const secret = Buffer.from(generatePasscode());
+        const authenticationCode = generatePasscode();
         // TODO(burdon): Not used.
         // const secretProvider = async () => {
         //   next({ descriptor: invitation.toProto(), state: InvitationState.CONNECTED });
@@ -82,7 +82,7 @@ export class ProfileService implements ProfileServiceRpc {
             close();
           }
         });
-        invitation.secret = secret;
+        invitation.authenticationCode = authenticationCode;
 
         next({
           state: InvitationState.WAITING_FOR_CONNECTION,
@@ -92,7 +92,7 @@ export class ProfileService implements ProfileServiceRpc {
     });
   }
 
-  acceptInvitation(invitation: InvitationDescriptor): Stream<RedeemedInvitation> {
+  acceptInvitation(invitation: Invitation): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [, secretTrigger] = latch();
@@ -110,16 +110,16 @@ export class ProfileService implements ProfileServiceRpc {
       // };
 
       // Joining process is kicked off, and will await authentication with a secret.
-      const haloPartyPromise = this.context.haloInvitations.acceptInvitation(invitation);
+      const haloSpacePromise = this.context.haloInvitations.acceptInvitation(invitation);
       this.inviteeInvitations.set(id, inviteeInvitation);
       next({ id, state: InvitationState.CONNECTED });
 
-      haloPartyPromise
+      haloSpacePromise
         .then((identity) => {
           next({
             id,
             state: InvitationState.SUCCESS,
-            partyKey: identity.identityKey
+            spaceKey: identity.identityKey
           });
         })
         .catch((err) => {

package/src/packlets/deprecated/space.ts

@@ -0,0 +1,245 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { EventSubscriptions } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { todo } from '@dxos/debug';
+import {
+  AuthenticateInvitationRequest,
+  CreateSnapshotRequest,
+  GetSpaceDetailsRequest,
+  Space,
+  SpaceDetails,
+  SpaceService,
+  SetSpaceStateRequest,
+  SubscribeMembersRequest,
+  SubscribeMembersResponse,
+  SubscribeSpacesResponse,
+  SubscribeSpaceRequest,
+  SubscribeSpaceResponse
+} from '@dxos/protocols/proto/dxos/client';
+import { SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
+import { humanize } from '@dxos/util';
+
+import { ServiceContext } from '../services';
+import { InviteeInvitations } from './invitations';
+
+/**
+ * Space service implementation.
+ * @deprecated
+ */
+export class SpaceServiceImpl implements SpaceService {
+  private inviteeInvitations: InviteeInvitations = new Map();
+
+  constructor(private readonly serviceContext: ServiceContext) {}
+
+  subscribeToSpace(request: SubscribeSpaceRequest): Stream<SubscribeSpaceResponse> {
+    return new Stream(({ next }) => {
+      next({
+        space: {
+          publicKey: request.spaceKey,
+          isOpen: true,
+          isActive: true,
+          members: []
+        }
+      });
+    });
+
+    // const update = (next: (message: SubscribeSpaceResponse) => void) => {
+    //   try {
+    //     const space = this.echo.getSpace(request.space_key);
+    //     next({
+    //       space: space && {
+    //         public_key: space.key,
+    //         is_open: space.is_open,
+    //         is_active: space.is_active,
+    //         members: space.queryMembers().value
+    //       }
+    //     });
+    //   } catch (err) {
+    //     if (err instanceof InvalidStateError) {
+    //       // Do nothing.
+    //     } else {
+    //       throw err;
+    //     }
+    //   }
+    // };
+
+    // const space = this.serviceContext.brane.getSpace(request.space_key);
+    // if (space) {
+    //   return new Stream(({ next }) => space.update.on(() => update(next)));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeSpace: () => void;
+    //     const unsubscribeSpaces = this.echo.querySpaces().subscribe((spaces) => {
+    //       const space = spaces.find((space) => space.key.equals(request.space_key));
+    //       if (space && !unsubscribeSpace) {
+    //         unsubscribeSpace = space.update.on(() => update(next));
+    //       }
+    //     });
+
+    //     update(next);
+
+    //     return () => {
+    //       unsubscribeSpaces();
+    //       unsubscribeSpace?.();
+    //     };
+    //   });
+    // }
+  }
+
+  subscribeSpaces() {
+    return new Stream<SubscribeSpacesResponse>(({ next }) => {
+      const subscriptions = new EventSubscriptions();
+
+      const onUpdate = () => {
+        next({
+          spaces: Array.from(this.serviceContext.spaceManager!.spaces.values()).map(
+            (space): Space => ({
+              publicKey: space.key,
+              isOpen: true,
+              isActive: true,
+              members: Array.from(space.spaceState.members.values()).map((member) => ({
+                identityKey: member.key,
+                profile: {
+                  identityKey: member.key,
+                  displayName: humanize(member.key)
+                }
+              }))
+            })
+          )
+        });
+      };
+
+      setTimeout(async () => {
+        if (!this.serviceContext.spaceManager) {
+          next({ spaces: [] });
+        }
+
+        await this.serviceContext.initialized.wait();
+
+        subscriptions.add(
+          this.serviceContext.spaceManager!.updated.on(() => {
+            this.serviceContext.spaceManager!.spaces.forEach((space) => {
+              subscriptions.add(space.stateUpdate.on(onUpdate));
+            });
+            onUpdate();
+          })
+        );
+
+        onUpdate();
+      });
+
+      return () => subscriptions.clear();
+    });
+  }
+
+  async getSpaceDetails(request: GetSpaceDetailsRequest): Promise<SpaceDetails> {
+    return todo();
+    // const space = this.echo.getSpace(request.space_key) ?? raise(new SpaceNotFoundError(request.space_key));
+    // return {
+    //   processedTimeframe: space.timeframe
+    // };
+  }
+
+  async createSpace(): Promise<Space> {
+    await this.serviceContext.initialized.wait();
+    const space = await this.serviceContext.spaceManager!.createSpace();
+    return {
+      publicKey: space.key,
+      isOpen: true,
+      isActive: true
+    };
+  }
+
+  async cloneSpace(snapshot: SpaceSnapshot): Promise<Space> {
+    return todo();
+    // const space = await this.echo.cloneSpace(snapshot);
+    // return {
+    //   public_key: space.key,
+    //   is_open: space.is_open,
+    //   is_active: space.is_active
+    // };
+  }
+
+  async setSpaceState(request: SetSpaceStateRequest) {
+    return todo();
+    // const space = this.echo.getSpace(request.space_key);
+    // if (!space) {
+    //   throw new Error('Space not found');
+    // }
+
+    // if (request.open === true) {
+    //   await space.open();
+    // } else if (request.open === false) {
+    //   await space.close();
+    // } // Undefined preserves previous state.
+
+    // if (request.active_global === true) {
+    //   await space.activate({ global: true });
+    // } else if (request.active_global === false) {
+    //   await space.deactivate({ global: true });
+    // } // Undefined preserves previous state.
+
+    // if (request.active_device === true) {
+    //   await space.activate({ device: true });
+    // } else if (request.active_device === false) {
+    //   await space.deactivate({ device: true });
+    // } // Undefined preserves previous state.
+    // return {
+    //   public_key: space.key,
+    //   is_open: space.is_open,
+    //   is_active: space.is_active
+    // };
+  }
+
+  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 space = this.echo.getSpace(request.space_key);
+    // if (space) {
+    //   return resultSetToStream(space.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
+    // } else {
+    //   return new Stream(({ next }) => {
+    //     let unsubscribeMembers: () => void;
+    //     const unsubscribeSpaces = this.echo.querySpaces().subscribe((spaces) => {
+    //       const space = spaces.find((space) => space.key.equals(request.space_key));
+    //       if (!unsubscribeMembers && space) {
+    //         const resultSet = space.queryMembers();
+    //         next({ members: resultSet.value });
+    //         unsubscribeMembers = resultSet.update.on(() => next({ members: resultSet.value }));
+    //       }
+    //     });
+
+    //     return () => {
+    //       unsubscribeSpaces();
+    //       unsubscribeMembers();
+    //     };
+    //   });
+    // }
+  }
+
+  async createSnapshot(request: CreateSnapshotRequest): Promise<SpaceSnapshot> {
+    return todo();
+    // assert(request.space_key);
+    // const space = this.echo.getSpace(request.space_key) ?? raise(new SpaceNotFoundError(request.space_key));
+    // return space.createSnapshot();
+  }
+}

package/src/packlets/{services/impl → deprecated}/system.ts

@@ -4,9 +4,9 @@
 
 import { Config } from '@dxos/config';
 import { todo } from '@dxos/debug';
-import { SystemService as SystemServiceRpc } from '@dxos/protocols/proto/dxos/client';
+import { SystemService } from '@dxos/protocols/proto/dxos/client';
 
-export class SystemService implements SystemServiceRpc {
+export class SystemServiceImpl implements SystemService {
   constructor(private readonly _config: Config) {}
 
   async getConfig(request: void) {

package/src/packlets/{services/impl → deprecated}/tracing.ts

@@ -3,12 +3,12 @@
 //
 
 import { Config } from '@dxos/config';
-import { TracingService as TracingServiceRpc } from '@dxos/protocols/proto/dxos/devtools/host';
+import { TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
 
 /**
  *
  */
-export class TracingService implements TracingServiceRpc {
+export class TracingServiceImpl implements TracingService {
   constructor(private readonly _config: Config) {}
 
   async setTracingOptions() {

package/src/packlets/{services/impl → devtools}/devtools.ts

@@ -2,23 +2,23 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Event as AsyncEvent } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { Config } from '@dxos/config';
-import { todo } from '@dxos/debug';
 import {
   ClearSnapshotsRequest,
-  DevtoolsHost,
+  DevtoolsHost, // TODO(burdon): Rename DevtoolsService
   EnableDebugLoggingRequest,
   EnableDebugLoggingResponse,
   Event,
   GetConfigResponse,
   GetNetworkPeersRequest,
   GetNetworkPeersResponse,
-  GetPartySnapshotRequest,
-  GetPartySnapshotResponse,
+  GetSpaceSnapshotRequest,
+  GetSpaceSnapshotResponse,
   ResetStorageRequest,
-  SavePartySnapshotRequest,
-  SavePartySnapshotResponse,
+  SaveSpaceSnapshotRequest,
+  SaveSpaceSnapshotResponse,
   SubscribeToCredentialMessagesRequest,
   SubscribeToCredentialMessagesResponse,
   SubscribeToFeedBlocksRequest,
@@ -30,23 +30,22 @@ import {
   SubscribeToKeyringKeysRequest,
   SubscribeToKeyringKeysResponse,
   SubscribeToNetworkTopicsResponse,
-  SubscribeToPartiesRequest,
-  SubscribeToPartiesResponse,
+  SubscribeToSpacesRequest,
+  SubscribeToSpacesResponse,
   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';
+import { ServiceContext } from '../services';
+import { subscribeToFeedBlocks, subscribeToFeeds } from './feeds';
+import { subscribeToNetworkStatus, subscribeToSignalTrace, subscribeToSwarmInfo } from './network';
+import { subscribeToSpaces } from './spaces';
+
+// TODO(burdon): Remove?
+export class DevtoolsHostEvents {
+  readonly ready = new AsyncEvent();
+}
 
 export type DevtoolsServiceParams = {
   events: DevtoolsHostEvents;
@@ -54,7 +53,7 @@ export type DevtoolsServiceParams = {
   context: ServiceContext;
 };
 
-export class DevtoolsService implements DevtoolsHost {
+export class DevtoolsServiceImpl implements DevtoolsHost {
   constructor(private readonly params: DevtoolsServiceParams) {}
 
   events(request: void): Stream<Event> {
@@ -66,37 +65,37 @@ export class DevtoolsService implements DevtoolsHost {
   }
 
   getConfig(request: void): Promise<GetConfigResponse> {
-    todo();
+    throw new Error();
   }
 
   resetStorage(request: ResetStorageRequest): Promise<void> {
-    todo();
+    throw new Error();
   }
 
   enableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    todo();
+    throw new Error();
   }
 
   disableDebugLogging(request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToKeyringKeys(request: SubscribeToKeyringKeysRequest): Stream<SubscribeToKeyringKeysResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToCredentialMessages(
     request: SubscribeToCredentialMessagesRequest
   ): Stream<SubscribeToCredentialMessagesResponse> {
-    todo();
+    throw new Error();
   }
 
-  subscribeToParties(request: SubscribeToPartiesRequest): Stream<SubscribeToPartiesResponse> {
+  subscribeToSpaces(request: SubscribeToSpacesRequest): Stream<SubscribeToSpacesResponse> {
     return subscribeToSpaces(this.params.context, request);
   }
 
   subscribeToItems(request: SubscribeToItemsRequest): Stream<SubscribeToItemsResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToFeeds(request: SubscribeToFeedsRequest): Stream<SubscribeToFeedsResponse> {
@@ -107,24 +106,24 @@ export class DevtoolsService implements DevtoolsHost {
     return subscribeToFeedBlocks({ feedStore: this.params.context.feedStore }, request);
   }
 
-  getPartySnapshot(request: GetPartySnapshotRequest): Promise<GetPartySnapshotResponse> {
-    todo();
+  getSpaceSnapshot(request: GetSpaceSnapshotRequest): Promise<GetSpaceSnapshotResponse> {
+    throw new Error();
   }
 
-  savePartySnapshot(request: SavePartySnapshotRequest): Promise<SavePartySnapshotResponse> {
-    todo();
+  saveSpaceSnapshot(request: SaveSpaceSnapshotRequest): Promise<SaveSpaceSnapshotResponse> {
+    throw new Error();
   }
 
   clearSnapshots(request: ClearSnapshotsRequest): Promise<void> {
-    todo();
+    throw new Error();
   }
 
   getNetworkPeers(request: GetNetworkPeersRequest): Promise<GetNetworkPeersResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToNetworkTopics(request: void): Stream<SubscribeToNetworkTopicsResponse> {
-    todo();
+    throw new Error();
   }
 
   subscribeToSignalStatus(request: void): Stream<SubscribeToSignalStatusResponse> {