@dxos/client-services 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@dxos/client-services",
-  "version": "0.1.4",
+  "version": "0.1.6",
+  "description": "DXOS client services implementation",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -15,29 +16,28 @@
     "src"
   ],
   "dependencies": {
-    "@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",
+    "@dxos/async": "0.1.6",
+    "@dxos/codec-protobuf": "0.1.6",
+    "@dxos/config": "0.1.6",
+    "@dxos/credentials": "0.1.6",
+    "@dxos/crypto": "0.1.6",
+    "@dxos/debug": "0.1.6",
+    "@dxos/echo-db": "0.1.6",
+    "@dxos/feed-store": "0.1.6",
+    "@dxos/keyring": "0.1.6",
+    "@dxos/keys": "0.1.6",
+    "@dxos/log": "0.1.6",
+    "@dxos/messaging": "0.1.6",
+    "@dxos/model-factory": "0.1.6",
+    "@dxos/network-manager": "0.1.6",
+    "@dxos/object-model": "0.1.6",
+    "@dxos/protocol-plugin-rpc": "0.1.6",
+    "@dxos/protocols": "0.1.6",
+    "@dxos/random-access-storage": "0.1.6",
+    "@dxos/rpc": "0.1.6",
+    "@dxos/text-model": "0.1.6",
+    "@dxos/timeframe": "0.1.6",
+    "@dxos/util": "0.1.6",
     "abstract-leveldown": "~7.0.0",
     "assert": "^2.0.0",
     "base-x": "~3.0.9",
@@ -46,8 +46,8 @@
     "memdown": "^5.1.0"
   },
   "devDependencies": {
-    "@dxos/signal": "0.1.4",
-    "@dxos/testutils": "0.1.4",
+    "@dxos/signal": "0.1.6",
+    "@dxos/testutils": "0.1.6",
     "@types/level-js": "~4.0.1",
     "@types/memdown": "^3.0.0",
     "@types/readable-stream": "^2.3.9"

package/src/packlets/deprecated/profile.ts

@@ -2,31 +2,22 @@
 // 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,
   RecoverProfileRequest,
-  RedeemedInvitation,
   SubscribeProfileResponse
 } from '@dxos/protocols/proto/dxos/client';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
 import { ServiceContext } from '../services';
-import { InviteeInvitation, InviteeInvitations } from './invitations';
+import { InviteeInvitations } from './invitations';
 
 /**
  * Profile service implementation.
+ * @deprecated
  */
 export class ProfileServiceImpl implements ProfileService {
   private inviteeInvitations: InviteeInvitations = new Map();
@@ -65,77 +56,4 @@ export class ProfileServiceImpl implements ProfileService {
     // assert(profile, 'Recovering profile failed.');
     // return profile;
   }
-
-  createInvitation(): Stream<InvitationRequest> {
-    return new Stream(({ next, close }) => {
-      setTimeout(async () => {
-        const authenticationCode = 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.authenticationCode = authenticationCode;
-
-        next({
-          state: InvitationState.WAITING_FOR_CONNECTION,
-          descriptor: invitation
-        });
-      });
-    });
-  }
-
-  acceptInvitation(invitation: Invitation): 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 haloSpacePromise = this.context.haloInvitations.acceptInvitation(invitation);
-      this.inviteeInvitations.set(id, inviteeInvitation);
-      next({ id, state: InvitationState.CONNECTED });
-
-      haloSpacePromise
-        .then((identity) => {
-          next({
-            id,
-            state: InvitationState.SUCCESS,
-            spaceKey: 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/deprecated/system.ts

@@ -6,9 +6,16 @@ import { Config } from '@dxos/config';
 import { todo } from '@dxos/debug';
 import { SystemService } from '@dxos/protocols/proto/dxos/client';
 
+/**
+ * @deprecated
+ */
 export class SystemServiceImpl implements SystemService {
   constructor(private readonly _config: Config) {}
 
+  async initSession() {
+    // Ok.
+  }
+
   async getConfig(request: void) {
     return this._config.values;
   }

package/src/packlets/deprecated/tracing.ts

@@ -6,7 +6,7 @@ import { Config } from '@dxos/config';
 import { TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
 
 /**
- *
+ * @deprecated
  */
 export class TracingServiceImpl implements TracingService {
   constructor(private readonly _config: Config) {}

package/src/packlets/devtools/devtools.ts

@@ -42,7 +42,6 @@ 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();
 }
@@ -53,6 +52,9 @@ export type DevtoolsServiceParams = {
   context: ServiceContext;
 };
 
+/**
+ * @deprecated
+ */
 export class DevtoolsServiceImpl implements DevtoolsHost {
   constructor(private readonly params: DevtoolsServiceParams) {}
 

package/src/packlets/identity/devices-service-impl.ts

@@ -31,7 +31,6 @@ export class DevicesServiceImpl implements DevicesService {
       };
 
       const dispose = new EventSubscriptions();
-
       dispose.add(
         this._identityManager.stateUpdate.on(() => {
           update();

package/src/packlets/identity/identity-manager.ts

@@ -74,54 +74,6 @@ export class IdentityManager {
     await this._identity?.close();
   }
 
-  private async _constructIdentity(identityRecord: IdentityRecord) {
-    assert(!this._identity);
-    log('constructing identity', { identityRecord });
-
-    const space = await this._constructSpace({
-      spaceRecord: identityRecord.haloSpace,
-      swarmIdentity: {
-        peerKey: identityRecord.deviceKey,
-        credentialProvider: MOCK_AUTH_PROVIDER,
-        credentialAuthenticator: MOCK_AUTH_VERIFIER
-      }
-    });
-
-    log('done', { identityKey: identityRecord.identityKey });
-    return new Identity({
-      space,
-      signer: this._keyring,
-      identityKey: identityRecord.identityKey,
-      deviceKey: identityRecord.deviceKey
-    });
-  }
-
-  private async _constructSpace({ spaceRecord, swarmIdentity }: ConstructSpaceParams) {
-    const controlFeed = await this._feedStore.openFeed(spaceRecord.writeControlFeedKey, { writable: true });
-    const dataFeed = await this._feedStore.openFeed(spaceRecord.writeDataFeedKey, { writable: true });
-
-    // The genesis feed will be the same as the control feed if the space was created by the local agent.
-    // NOTE: Must be initialized after writable feeds so that it is in a writable state.
-    const genesisFeed = await this._feedStore.openFeed(spaceRecord.genesisFeedKey);
-
-    const protocol = new SpaceProtocol({
-      topic: spaceRecord.spaceKey,
-      identity: swarmIdentity,
-      networkManager: this._networkManager
-    });
-
-    return new Space({
-      spaceKey: spaceRecord.spaceKey,
-      protocol,
-      genesisFeed,
-      controlFeed,
-      dataFeed,
-      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey),
-      databaseFactory: async ({ databaseBackend }) =>
-        new Database(this._modelFactory, databaseBackend, swarmIdentity.peerKey)
-    });
-  }
-
   async createIdentity() {
     assert(!this._identity, 'Identity already exists.');
     log('creating identity...');
@@ -169,6 +121,7 @@ export class IdentityManager {
       }
     }
 
+    // TODO(burdon): ???
     // await this._keyring.deleteKey(identityRecord.identity_key);
     // await this._keyring.deleteKey(identityRecord.halo_space.space_key);
 
@@ -177,7 +130,7 @@ export class IdentityManager {
     await this._identity.ready();
     this.stateUpdate.emit();
 
-    log('created identity', { identityKey: identity.identityKey });
+    log('created identity', { identityKey: identity.identityKey, deviceKey: identity.deviceKey });
     return identity;
   }
 
@@ -204,4 +157,52 @@ export class IdentityManager {
     this.stateUpdate.emit();
     return identity;
   }
+
+  private async _constructIdentity(identityRecord: IdentityRecord) {
+    assert(!this._identity);
+    log('constructing identity', { identityRecord });
+
+    const space = await this._constructSpace({
+      spaceRecord: identityRecord.haloSpace,
+      swarmIdentity: {
+        peerKey: identityRecord.deviceKey,
+        credentialProvider: MOCK_AUTH_PROVIDER,
+        credentialAuthenticator: MOCK_AUTH_VERIFIER
+      }
+    });
+
+    log('done', { identityKey: identityRecord.identityKey });
+    return new Identity({
+      space,
+      signer: this._keyring,
+      identityKey: identityRecord.identityKey,
+      deviceKey: identityRecord.deviceKey
+    });
+  }
+
+  private async _constructSpace({ spaceRecord, swarmIdentity }: ConstructSpaceParams) {
+    const controlFeed = await this._feedStore.openFeed(spaceRecord.writeControlFeedKey, { writable: true });
+    const dataFeed = await this._feedStore.openFeed(spaceRecord.writeDataFeedKey, { writable: true });
+
+    // The genesis feed will be the same as the control feed if the space was created by the local agent.
+    // NOTE: Must be initialized after writable feeds so that it is in a writable state.
+    const genesisFeed = await this._feedStore.openFeed(spaceRecord.genesisFeedKey);
+
+    const protocol = new SpaceProtocol({
+      topic: spaceRecord.spaceKey,
+      identity: swarmIdentity,
+      networkManager: this._networkManager
+    });
+
+    return new Space({
+      spaceKey: spaceRecord.spaceKey,
+      protocol,
+      genesisFeed,
+      controlFeed,
+      dataFeed,
+      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey),
+      databaseFactory: async ({ databaseBackend }) =>
+        new Database(this._modelFactory, databaseBackend, swarmIdentity.peerKey)
+    });
+  }
 }

package/src/packlets/identity/identity.ts

@@ -14,7 +14,12 @@ import {
 import { Signer } from '@dxos/crypto';
 import { failUndefined } from '@dxos/debug';
 import { Database, Space } from '@dxos/echo-db';
+import { writeMessages } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { TypedMessage } from '@dxos/protocols';
+import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { HaloAdmissionCredentials } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { ComplexSet } from '@dxos/util';
 
 export type IdentityParams = {
@@ -46,7 +51,7 @@ export class Identity {
 
     this._deviceStateMachine = new DeviceStateMachine(this.identityKey, this.deviceKey);
 
-    // Save device key chain credential when processed by the space state machine.
+    // Save device keychain credential when processed by the space state machine.
     this._space.onCredentialProcessed.set(async (credential) => {
       await this._deviceStateMachine.process(credential);
       this.stateUpdate.emit();
@@ -91,6 +96,14 @@ export class Identity {
     return this._space.database ?? failUndefined();
   }
 
+  getAdmissionCredentials(): HaloAdmissionCredentials {
+    return {
+      deviceKey: this.deviceKey,
+      controlFeedKey: this._space.controlFeedKey,
+      dataFeedKey: this._space.dataFeedKey
+    };
+  }
+
   /**
    * Issues credentials as identity.
    * Requires identity to be ready.
@@ -110,4 +123,48 @@ export class Identity {
   getDeviceCredentialSigner(): CredentialSigner {
     return createCredentialSignerWithKey(this._signer, this.deviceKey);
   }
+
+  async admitDevice({ deviceKey, controlFeedKey, dataFeedKey }: HaloAdmissionCredentials) {
+    log('Admitting device:', {
+      identityKey: this.identityKey,
+      hostDevice: this.deviceKey,
+      deviceKey,
+      controlFeedKey,
+      dataFeedKey
+    });
+    const signer = this.getIdentityCredentialSigner();
+    await writeMessages(
+      this.controlPipeline.writer,
+      [
+        await signer.createCredential({
+          subject: deviceKey,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AuthorizedDevice',
+            identityKey: this.identityKey,
+            deviceKey
+          }
+        }),
+        await signer.createCredential({
+          subject: controlFeedKey,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.haloSpaceKey,
+            deviceKey,
+            identityKey: this.identityKey,
+            designation: AdmittedFeed.Designation.CONTROL
+          }
+        }),
+        await signer.createCredential({
+          subject: dataFeedKey,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.haloSpaceKey,
+            deviceKey,
+            identityKey: this.identityKey,
+            designation: AdmittedFeed.Designation.DATA
+          }
+        })
+      ].map((credential): TypedMessage => ({ '@type': 'dxos.echo.feed.CredentialsMessage', credential }))
+    );
+  }
 }

package/src/packlets/invitations/halo-invitations-handler.test.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+import { expect } from 'chai';
+
+import { asyncChain, Trigger } from '@dxos/async';
+import { raise } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { afterTest } from '@dxos/testutils';
+
+import { ServiceContext } from '../services';
+import { createPeers, createServiceContext } from '../testing';
+
+const closeAfterTest = async (peer: ServiceContext) => {
+  afterTest(() => peer.close());
+  return peer;
+};
+
+describe('services/halo', function () {
+  it('creates identity', async function () {
+    const peer = createServiceContext();
+    await peer.open();
+    afterTest(() => peer.close());
+
+    const identity = await peer.createIdentity();
+    expect(identity).not.to.be.undefined;
+  });
+
+  it('creates and accepts invitation', async function () {
+    const [host, guest] = await asyncChain<ServiceContext>([closeAfterTest])(createPeers(2));
+
+    const identity1 = await host.createIdentity();
+    expect(host.identityManager.identity).to.eq(identity1);
+
+    const observable1 = await host.haloInvitations.createInvitation();
+
+    const complete1 = new Trigger<PublicKey>();
+    const complete2 = new Trigger<PublicKey>();
+
+    const authenticationCode = new Trigger<string>();
+
+    observable1.subscribe({
+      onConnecting: async (invitation1: Invitation) => {
+        const observable2 = guest.haloInvitations!.acceptInvitation(invitation1);
+        observable2.subscribe({
+          onConnecting: async () => {},
+          onConnected: async (invitation2: Invitation) => {
+            expect(invitation1.swarmKey).to.eq(invitation2.swarmKey);
+          },
+          onAuthenticating: async () => {
+            await observable2.authenticate(await authenticationCode.wait());
+          },
+          onSuccess: (invitation: Invitation) => {
+            complete2.wake(invitation.identityKey!);
+          },
+          onCancelled: () => raise(new Error()),
+          onTimeout: (err: Error) => raise(new Error(err.message)),
+          onError: (err: Error) => raise(new Error(err.message))
+        });
+      },
+      onConnected: (invitation: Invitation) => {
+        assert(invitation.authenticationCode);
+        authenticationCode.wake(invitation.authenticationCode);
+      },
+      onSuccess: (invitation: Invitation) => {
+        complete1.wake(host.identityManager.identity!.identityKey);
+      },
+      onCancelled: () => raise(new Error()),
+      onTimeout: (err: Error) => raise(new Error(err.message)),
+      onError: (err: Error) => raise(new Error(err.message))
+    });
+
+    const [identityKey1, identityKey2] = await Promise.all([complete1.wait(), complete2.wait()]);
+    expect(identityKey1).to.deep.eq(identityKey2);
+  });
+});