@dxos/client-services 0.5.9-main.a2de4fa → 0.5.9-main.aa46ff0

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

@@ -28,6 +28,7 @@ import {
   createDiagnostics,
 } from '../diagnostics';
 import { IdentityServiceImpl, type CreateIdentityOptions } from '../identity';
+import { ContactsServiceImpl } from '../identity/contacts-service';
 import { InvitationsServiceImpl } from '../invitations';
 import { Lock, type ResourceLock } from '../locks';
 import { LoggingServiceImpl } from '../logging';
@@ -251,6 +252,11 @@ export class ClientServicesHost {
       this._runtimeParams,
     );
 
+    const dataSpaceManagerProvider = async () => {
+      await this._serviceContext.initialized.wait();
+      return this._serviceContext.dataSpaceManager!;
+    };
+
     const identityService = new IdentityServiceImpl(
       this._serviceContext.identityManager,
       this._serviceContext.keyring,
@@ -262,6 +268,11 @@ export class ClientServicesHost {
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
       IdentityService: identityService,
+      ContactsService: new ContactsServiceImpl(
+        this._serviceContext.identityManager,
+        this._serviceContext.spaceManager,
+        dataSpaceManagerProvider,
+      ),
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
@@ -270,10 +281,7 @@ export class ClientServicesHost {
       SpacesService: new SpacesServiceImpl(
         this._serviceContext.identityManager,
         this._serviceContext.spaceManager,
-        async () => {
-          await this._serviceContext.initialized.wait();
-          return this._serviceContext.dataSpaceManager!;
-        },
+        dataSpaceManagerProvider,
       ),
 
       DataService: this._serviceContext.echoHost.dataService,

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

@@ -11,6 +11,7 @@ import {
   getCredentialAssertion,
   type CredentialSigner,
   type DelegateInvitationCredential,
+  createAdmissionCredentials,
   type MemberInfo,
 } from '@dxos/credentials';
 import { convertLegacyReferences, findInlineObjectOfType, type EchoHost } from '@dxos/echo-db';
@@ -22,6 +23,7 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
+import { CredentialServerExtension } from '@dxos/echo-pipeline';
 import {
   LEGACY_TYPE_PROPERTIES,
   SpaceDocVersion,
@@ -30,12 +32,12 @@ import {
   type SpaceDoc,
 } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
-import { type FeedStore } from '@dxos/feed-store';
+import { type FeedStore, writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { trace as Trace } from '@dxos/protocols';
+import { trace as Trace, AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
@@ -84,6 +86,14 @@ export type AcceptSpaceOptions = {
   dataTimeframe?: Timeframe;
 };
 
+export type AdmitMemberOptions = {
+  spaceKey: PublicKey;
+  identityKey: PublicKey;
+  role: SpaceMember.Role;
+  profile?: ProfileDocument;
+  delegationCredentialId?: PublicKey;
+};
+
 export type DataSpaceManagerRuntimeParams = {
   spaceMemberPresenceAnnounceInterval?: number;
   spaceMemberPresenceOfflineTimeout?: number;
@@ -287,6 +297,35 @@ export class DataSpaceManager {
     return space;
   }
 
+  async admitMember(options: AdmitMemberOptions): Promise<Credential> {
+    const space = this._spaceManager.spaces.get(options.spaceKey);
+    invariant(space);
+
+    if (space.spaceState.getMemberRole(options.identityKey) !== SpaceMember.Role.REMOVED) {
+      throw new AlreadyJoinedError();
+    }
+
+    // TODO(burdon): Check if already admitted.
+    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
+      this._signingContext.credentialSigner,
+      options.identityKey,
+      space.key,
+      space.genesisFeedKey,
+      options.role,
+      space.spaceState.membershipChainHeads,
+      options.profile,
+      options.delegationCredentialId,
+    );
+
+    // TODO(dmaretskyi): Refactor.
+    invariant(credentials[0].credential);
+    const spaceMemberCredential = credentials[0].credential.credential;
+    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await writeMessages(space.controlPipeline.writer, credentials);
+
+    return spaceMemberCredential;
+  }
+
   /**
    * Wait until the space data pipeline is fully initialized.
    * Used by invitation handler.
@@ -302,6 +341,19 @@ export class DataSpaceManager {
     );
   }
 
+  public async requestSpaceAdmissionCredential(spaceKey: PublicKey): Promise<Credential> {
+    return this._spaceManager.requestSpaceAdmissionCredential({
+      spaceKey,
+      identityKey: this._signingContext.identityKey,
+      timeout: 15_000,
+      swarmIdentity: {
+        peerKey: this._signingContext.deviceKey,
+        credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
+        credentialAuthenticator: async () => true,
+      },
+    });
+  }
+
   private async _constructSpace(metadata: SpaceMetadata) {
     log('construct space', { metadata });
     const gossip = new Gossip({
@@ -331,6 +383,7 @@ export class DataSpaceManager {
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
       onAuthorizedConnection: (session) => {
+        session.addExtension('dxos.mesh.teleport.admission-discovery', new CredentialServerExtension(space));
         session.addExtension(
           'dxos.mesh.teleport.gossip',
           gossip.createExtension({ remotePeerId: session.remotePeerId }),

package/src/packlets/spaces/spaces-service.ts

@@ -30,6 +30,10 @@ import {
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
   type UpdateMemberRoleRequest,
+  type AdmitContactRequest,
+  type ContactAdmission,
+  type JoinSpaceResponse,
+  type JoinBySpaceKeyRequest,
   type CreateEpochResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -226,6 +230,40 @@ export class SpacesServiceImpl implements SpacesService {
     return { epochCredential: credential ?? undefined };
   }
 
+  async admitContact(request: AdmitContactRequest): Promise<void> {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    await dataSpaceManager.admitMember({
+      spaceKey: request.spaceKey,
+      identityKey: request.contact.identityKey,
+      role: request.role,
+    });
+  }
+
+  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest): Promise<JoinSpaceResponse> {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(spaceKey);
+    return this._joinByAdmission({ credential });
+  }
+
+  private async _joinByAdmission({ credential }: ContactAdmission): Promise<JoinSpaceResponse> {
+    const assertion = getCredentialAssertion(credential);
+    invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
+    const myIdentity = this._identityManager.identity;
+    invariant(myIdentity && credential.subject.id.equals(myIdentity.identityKey));
+
+    const dataSpaceManager = await this._getDataSpaceManager();
+    let dataSpace = dataSpaceManager.spaces.get(assertion.spaceKey);
+    if (!dataSpace) {
+      dataSpace = await dataSpaceManager.acceptSpace({
+        spaceKey: assertion.spaceKey,
+        genesisFeedKey: assertion.genesisFeedKey,
+      });
+      await myIdentity.controlPipeline.writer.write({ credential: { credential } });
+    }
+
+    return { space: this._serializeSpace(dataSpace) };
+  }
+
   private _serializeSpace(space: DataSpace): Space {
     return {
       id: space.id,

package/src/packlets/storage/index.ts

@@ -4,3 +4,4 @@
 
 export * from './storage';
 export * from './level';
+export * from './profile-archive';

package/src/packlets/storage/profile-archive.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { cbor } from '@dxos/automerge/automerge-repo';
+import { invariant } from '@dxos/invariant';
+import type { LevelDB } from '@dxos/kv-store';
+import { log } from '@dxos/log';
+import { ProfileArchiveEntryType, type ProfileArchive } from '@dxos/protocols';
+import type { Storage } from '@dxos/random-access-storage';
+import { arrayToBuffer } from '@dxos/util';
+
+export const encodeProfileArchive = (profile: ProfileArchive): Uint8Array => cbor.encode(profile);
+
+export const decodeProfileArchive = (data: Uint8Array): ProfileArchive => cbor.decode(data);
+
+export const exportProfileData = async ({
+  storage,
+  level,
+}: {
+  storage: Storage;
+  level: LevelDB;
+}): Promise<ProfileArchive> => {
+  const archive: ProfileArchive = { storage: [], meta: { timestamp: new Date().toISOString() } };
+
+  {
+    const directory = await storage.createDirectory();
+    const files = await directory.list();
+
+    log.info('begin exporting files', { count: files.length });
+    for (const filename of files) {
+      const file = await directory.getOrCreateFile(filename);
+      const { size } = await file.stat();
+      const data = await file.read(0, size);
+      archive.storage.push({
+        type: ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data,
+      });
+    }
+    log.info('done exporting files', { count: files.length });
+  }
+
+  {
+    log.info('begin exporting kv pairs');
+    const iter = await level.iterator<Uint8Array, Uint8Array>({ keyEncoding: 'binary', valueEncoding: 'binary' });
+    let count = 0;
+    for await (const [key, value] of iter) {
+      archive.storage.push({
+        type: ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value,
+      });
+      count++;
+    }
+    log.info('done exporting kv pairs', { count });
+  }
+
+  return archive;
+};
+
+export const importProfileData = async (
+  {
+    storage,
+    level,
+  }: {
+    storage: Storage;
+    level: LevelDB;
+  },
+  archive: ProfileArchive,
+): Promise<void> => {
+  const batch = level.batch();
+
+  for (const entry of archive.storage) {
+    switch (entry.type) {
+      case ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        invariant(typeof entry.key === 'string', 'Invalid key type');
+        const file = await directory.getOrCreateFile(entry.key);
+        invariant(entry.value instanceof Uint8Array, 'Invalid value type');
+        await file.write(0, arrayToBuffer(entry.value));
+        await file.close();
+        break;
+      }
+      case ProfileArchiveEntryType.KEY_VALUE: {
+        invariant(entry.key instanceof Uint8Array, 'Invalid key type');
+        invariant(entry.value instanceof Uint8Array, 'Invalid value type');
+        batch.put(entry.key, entry.value, { keyEncoding: 'binary', valueEncoding: 'binary' });
+        break;
+      }
+      default:
+        throw new Error(`Invalid entry type: ${entry.type}`);
+    }
+  }
+
+  await batch.write();
+};

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.5.9-main.a2de4fa";
+export const DXOS_VERSION = "0.5.9-main.aa46ff0";