@dxos/client-services 0.5.9-main.bf0ae3e → 0.5.9-main.bf3bb8f

package/src/packlets/identity/contacts-service.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { EventSubscriptions, scheduleTask, UpdateScheduler } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { type MemberInfo } from '@dxos/credentials';
+import type { SpaceManager } from '@dxos/echo-pipeline';
+import { PublicKey } from '@dxos/keys';
+import { type Contact, type ContactBook, type ContactsService } from '@dxos/protocols/proto/dxos/client/services';
+import { ComplexMap, ComplexSet } from '@dxos/util';
+
+import { type IdentityManager } from './identity-manager';
+import { type DataSpaceManager } from '../spaces';
+
+export class ContactsServiceImpl implements ContactsService {
+  constructor(
+    private readonly _identityManager: IdentityManager,
+    private readonly _spaceManager: SpaceManager,
+    private readonly _dataSpaceManagerProvider: () => Promise<DataSpaceManager>,
+  ) {}
+
+  async getContacts(): Promise<ContactBook> {
+    const identity = this._identityManager.identity;
+    if (identity == null) {
+      return { contacts: [] };
+    }
+    const contacts = [...this._spaceManager.spaces.values()]
+      .flatMap((s) => [...s.spaceState.members.values()].map((m) => [s.key, m]))
+      .reduce((acc, v) => {
+        const [spaceKey, memberInfo] = v as [PublicKey, MemberInfo];
+        if (memberInfo.key.equals(identity.identityKey)) {
+          return acc;
+        }
+        const existing = acc.get(memberInfo.key);
+        if (existing != null) {
+          existing.profile ??= memberInfo.profile;
+          existing.commonSpaces?.push(spaceKey);
+        } else {
+          acc.set(memberInfo.key, {
+            identityKey: memberInfo.key,
+            profile: memberInfo.profile,
+            commonSpaces: [spaceKey],
+          });
+        }
+        return acc;
+      }, new ComplexMap<PublicKey, Contact>(PublicKey.hash));
+    return {
+      contacts: [...contacts.values()],
+    };
+  }
+
+  queryContacts(): Stream<ContactBook> {
+    const subscribedSpaceKeySet = new ComplexSet(PublicKey.hash);
+    return new Stream<ContactBook>(({ next, ctx }) => {
+      const pushUpdateTask = new UpdateScheduler(
+        ctx,
+        async () => {
+          const contacts = await this.getContacts();
+          next(contacts);
+        },
+        { maxFrequency: 2 },
+      );
+      scheduleTask(ctx, async () => {
+        const subscriptions = new EventSubscriptions();
+        ctx.onDispose(() => subscriptions.clear());
+        const subscribeToSpaceAndUpdate = () => {
+          const oldSetSize = subscribedSpaceKeySet.size;
+          for (const space of this._spaceManager.spaces.values()) {
+            if (!subscribedSpaceKeySet.has(space.key)) {
+              subscriptions.add(space.stateUpdate.on(ctx, () => pushUpdateTask.trigger()));
+              subscribedSpaceKeySet.add(space.key);
+            }
+          }
+          if (oldSetSize !== subscribedSpaceKeySet.size) {
+            pushUpdateTask.trigger();
+          }
+        };
+        const unsubscribe = (await this._dataSpaceManagerProvider()).updated.on(ctx, subscribeToSpaceAndUpdate);
+        ctx.onDispose(unsubscribe);
+        subscribeToSpaceAndUpdate();
+      });
+    });
+  }
+}

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

@@ -2,12 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Trigger, sleep } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { Resource } from '@dxos/context';
 import { signPresentation } from '@dxos/credentials';
 import { todo } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
+import { log } from '@dxos/log';
 import {
   type CreateIdentityRequest,
   type Identity as IdentityProto,
@@ -18,11 +20,14 @@ import {
   SpaceState,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Presentation, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { safeAwaitAll } from '@dxos/util';
 
 import { type Identity } from './identity';
 import { type CreateIdentityOptions, type IdentityManager } from './identity-manager';
 import { type DataSpaceManager } from '../spaces';
 
+const DEFAULT_SPACE_SEARCH_TIMEOUT = 10_000;
+
 export class IdentityServiceImpl extends Resource implements IdentityService {
   constructor(
     private readonly _identityManager: IdentityManager,
@@ -100,20 +105,47 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
   }
 
   private async _fixIdentityWithoutDefaultSpace(identity: Identity) {
-    let hasDefaultSpace = false;
+    let recodedDefaultSpace = false;
+    let foundDefaultSpace = false;
     const dataSpaceManager = this._dataSpaceManagerProvider();
-    for (const space of dataSpaceManager.spaces.values()) {
-      if (space.state === SpaceState.CLOSED) {
-        await space.open();
-        await space.initializeDataPipeline();
-      }
-      if (await dataSpaceManager.isDefaultSpace(space)) {
-        await identity.updateDefaultSpace(space.id);
-        hasDefaultSpace = true;
-        break;
-      }
-    }
-    if (!hasDefaultSpace) {
+
+    const recordedDefaultSpaceTrigger = new Trigger();
+
+    const allProcessed = safeAwaitAll(
+      dataSpaceManager.spaces.values(),
+      async (space) => {
+        if (space.state === SpaceState.CLOSED) {
+          await space.open();
+
+          // Wait until the space is either READY or REQUIRES_MIGRATION.
+          // NOTE: Space could potentially never initialize if the space data is corrupted.
+          const requiresMigration = space.stateUpdate.waitForCondition(
+            () => space.state === SpaceState.REQUIRES_MIGRATION,
+          );
+          await Promise.race([space.initializeDataPipeline(), requiresMigration]);
+        }
+        if (await dataSpaceManager.isDefaultSpace(space)) {
+          if (foundDefaultSpace) {
+            log.warn('Multiple default spaces found. Using the first one.', { duplicate: space.id });
+            return;
+          }
+
+          foundDefaultSpace = true;
+          await identity.updateDefaultSpace(space.id);
+          recodedDefaultSpace = true;
+          recordedDefaultSpaceTrigger.wake();
+        }
+      },
+      (err) => {
+        log.catch(err);
+      },
+    );
+
+    // Wait for all spaces to be processed or until the default space is recorded.
+    // If the timeout is reached, create a new default space.
+    await Promise.race([allProcessed, recordedDefaultSpaceTrigger.wait(), sleep(DEFAULT_SPACE_SEARCH_TIMEOUT)]);
+
+    if (!recodedDefaultSpace) {
       await this._createDefaultSpace(dataSpaceManager);
     }
   }

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

@@ -435,11 +435,19 @@ export class InvitationsHandler {
   }
 
   private _logStateUpdate(invitation: Invitation, actor: any, newState: Invitation.State) {
-    log('invitation state update', {
-      actor: actor?.constructor.name,
-      newState: stateToString(newState),
-      oldState: stateToString(invitation.state),
-    });
+    if (this._isNotTerminal(newState)) {
+      log('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    } else {
+      log.info('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    }
   }
 
   private _isNotTerminal(currentState: Invitation.State): boolean {

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -3,7 +3,6 @@
 //
 
 import {
-  createAdmissionCredentials,
   createCancelDelegatedSpaceInvitationCredential,
   createDelegatedSpaceInvitationCredential,
   getCredentialAssertion,
@@ -21,7 +20,6 @@ import {
   SpaceNotFoundError,
 } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
@@ -73,41 +71,22 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     request: AdmissionRequest,
     guestProfile?: ProfileDocument | undefined,
   ): Promise<AdmissionResponse> {
-    invariant(this._spaceKey);
-    const space = this._spaceManager.spaces.get(this._spaceKey);
-    invariant(space);
-
-    invariant(request.space);
-    const { identityKey, deviceKey } = request.space;
+    invariant(this._spaceKey && request.space);
+    log('writing guest credentials', { host: this._signingContext.deviceKey, guest: request.space.deviceKey });
 
-    if (space.inner.spaceState.getMemberRole(identityKey) !== SpaceMember.Role.REMOVED) {
-      throw new AlreadyJoinedError();
-    }
-
-    log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
-    // TODO(burdon): Check if already admitted.
-    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
-      this._signingContext.credentialSigner,
-      identityKey,
-      space.key,
-      space.inner.genesisFeedKey,
-      invitation.role ?? SpaceMember.Role.ADMIN,
-      space.inner.spaceState.membershipChainHeads,
-      guestProfile,
-      invitation.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.inner.controlPipeline.writer, credentials);
+    const spaceMemberCredential = await this._spaceManager.admitMember({
+      spaceKey: this._spaceKey,
+      identityKey: request.space.identityKey,
+      role: invitation.role ?? SpaceMember.Role.ADMIN,
+      profile: guestProfile,
+      delegationCredentialId: invitation.delegationCredentialId,
+    });
 
+    const space = this._spaceManager.spaces.get(this._spaceKey);
     return {
       space: {
         credential: spaceMemberCredential,
-        controlTimeframe: space.inner.controlPipeline.state.timeframe,
+        controlTimeframe: space?.inner.controlPipeline.state.timeframe,
       },
     };
   }

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/automerge-space-state.ts

@@ -3,10 +3,11 @@
 //
 
 import { Event } from '@dxos/async';
+import { Resource, type Context } from '@dxos/context';
 import { type CredentialProcessor, type SpecificCredential, checkCredentialType } from '@dxos/credentials';
 import { type Credential, type Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
 
-export class AutomergeSpaceState implements CredentialProcessor {
+export class AutomergeSpaceState extends Resource implements CredentialProcessor {
   public rootUrl: string | undefined = undefined;
   public lastEpoch: SpecificCredential<Epoch> | undefined = undefined;
 
@@ -14,7 +15,15 @@ export class AutomergeSpaceState implements CredentialProcessor {
 
   private _isProcessingRootDocs = false;
 
-  constructor(private readonly _onNewRoot: (rootUrl: string) => void) {}
+  constructor(private readonly _onNewRoot: (rootUrl: string) => void) {
+    super();
+  }
+
+  protected override async _open(ctx: Context): Promise<void> {}
+
+  protected override async _close(ctx: Context): Promise<void> {
+    this._isProcessingRootDocs = false;
+  }
 
   async processCredential(credential: Credential) {
     if (!checkCredentialType(credential, 'dxos.halo.credentials.Epoch')) {

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

@@ -4,16 +4,17 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { type Doc } from '@dxos/automerge/automerge';
-import { type DocHandle, type AutomergeUrl } from '@dxos/automerge/automerge-repo';
+import { type AutomergeUrl, type DocHandle } from '@dxos/automerge/automerge-repo';
 import { PropertiesType } from '@dxos/client-protocol';
-import { cancelWithContext, Context } from '@dxos/context';
+import { Context, cancelWithContext } from '@dxos/context';
 import {
+  getCredentialAssertion,
   type CredentialSigner,
   type DelegateInvitationCredential,
-  getCredentialAssertion,
+  createAdmissionCredentials,
   type MemberInfo,
 } from '@dxos/credentials';
-import { type EchoHost } from '@dxos/echo-db';
+import { convertLegacyReferences, findInlineObjectOfType, type EchoHost } from '@dxos/echo-db';
 import {
   AuthStatus,
   type MetadataStore,
@@ -22,26 +23,33 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
-import { encodeReference, type ObjectStructure, type SpaceDoc } from '@dxos/echo-protocol';
-import { getTypeReference } from '@dxos/echo-schema';
-import { type FeedStore } from '@dxos/feed-store';
+import { CredentialServerExtension } from '@dxos/echo-pipeline';
+import {
+  LEGACY_TYPE_PROPERTIES,
+  SpaceDocVersion,
+  encodeReference,
+  type ObjectStructure,
+  type SpaceDoc,
+} from '@dxos/echo-protocol';
+import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
+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';
-import { type Credential, type ProfileDocument, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { SpaceMember, type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type PeerState } from '@dxos/protocols/proto/dxos/mesh/presence';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { assignDeep, ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
+import { ComplexMap, assignDeep, deferFunction, forEachAsync } from '@dxos/util';
 
-import { DataSpace, findPropertiesObject } from './data-space';
+import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
 import { type InvitationsManager } from '../invitations';
@@ -78,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;
@@ -113,7 +129,7 @@ export class DataSpaceManager {
           const rootHandle = rootUrl ? this._echoHost.automergeRepo.find(rootUrl as AutomergeUrl) : undefined;
           const rootDoc = rootHandle?.docSync() as Doc<SpaceDoc> | undefined;
 
-          const properties = rootDoc && findPropertiesObject(rootDoc);
+          const properties = rootDoc && findInlineObjectOfType(rootDoc, TYPE_PROPERTIES);
 
           return {
             key: space.key.toHex(),
@@ -204,9 +220,24 @@ export class DataSpaceManager {
   }
 
   async isDefaultSpace(space: DataSpace): Promise<boolean> {
-    const rootDoc = await this._getSpaceRootDocument(space);
-    const [_, properties] = findPropertiesObject(rootDoc.docSync()) ?? [];
-    return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
+    if (!space.databaseRoot) {
+      return false;
+    }
+    switch (space.databaseRoot.getVersion()) {
+      case SpaceDocVersion.CURRENT: {
+        const [_, properties] = findInlineObjectOfType(space.databaseRoot.docSync()!, TYPE_PROPERTIES) ?? [];
+        return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
+      }
+      case SpaceDocVersion.LEGACY: {
+        const convertedDoc = await convertLegacyReferences(space.databaseRoot.docSync()!);
+        const [_, properties] = findInlineObjectOfType(convertedDoc, LEGACY_TYPE_PROPERTIES) ?? [];
+        return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
+      }
+
+      default:
+        log.warn('unknown space version', { version: space.databaseRoot.getVersion(), spaceId: space.id });
+        return false;
+    }
   }
 
   async createDefaultSpace() {
@@ -226,7 +257,7 @@ export class DataSpaceManager {
       },
     };
 
-    const propertiesId = PublicKey.random().toHex();
+    const propertiesId = generateEchoId();
     document.change((doc: SpaceDoc) => {
       assignDeep(doc, ['objects', propertiesId], properties);
     });
@@ -266,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.
@@ -281,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({
@@ -310,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 }),