@dxos/client-services 0.5.3-main.f752aaa → 0.5.3-main.fffc127

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

@@ -3,26 +3,43 @@
 //
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
-import { Context, cancelWithContext } from '@dxos/context';
-import { getCredentialAssertion, type CredentialSigner, type DelegateInvitationCredential } from '@dxos/credentials';
+import { type Doc } from '@dxos/automerge/automerge';
+import { type AutomergeUrl } from '@dxos/automerge/automerge-repo';
+import { cancelWithContext, Context } from '@dxos/context';
+import {
+  type CredentialSigner,
+  type DelegateInvitationCredential,
+  getCredentialAssertion,
+  type MemberInfo,
+} from '@dxos/credentials';
 import { type EchoHost } from '@dxos/echo-db';
-import { type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
+import {
+  AuthStatus,
+  type MetadataStore,
+  type Space,
+  type SpaceManager,
+  type SpaceProtocol,
+  type SpaceProtocolSession,
+} from '@dxos/echo-pipeline';
+import { type SpaceDoc } from '@dxos/echo-protocol';
 import { type FeedStore } 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 } from '@dxos/protocols';
+import { trace as Trace } 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 } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Credential, type ProfileDocument, SpaceMember } 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 { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 
-import { DataSpace } from './data-space';
+import { DataSpace, findPropertiesObject } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
 import { type InvitationsManager } from '../invitations';
@@ -90,6 +107,31 @@ export class DataSpaceManager {
     } = params ?? {};
     this._spaceMemberPresenceAnnounceInterval = spaceMemberPresenceAnnounceInterval;
     this._spaceMemberPresenceOfflineTimeout = spaceMemberPresenceOfflineTimeout;
+
+    trace.diagnostic({
+      id: 'spaces',
+      name: 'Spaces',
+      fetch: async () => {
+        return Array.from(this._spaces.values()).map((space) => {
+          const rootUrl = space.automergeSpaceState.rootUrl;
+          const rootHandle = rootUrl ? this._echoHost.automergeRepo.find(rootUrl as AutomergeUrl) : undefined;
+          const rootDoc = rootHandle?.docSync() as Doc<SpaceDoc> | undefined;
+
+          const properties = rootDoc && findPropertiesObject(rootDoc);
+
+          return {
+            key: space.key.toHex(),
+            state: SpaceState[space.state],
+            name: properties?.[1].data.name ?? null,
+            inlineObjects: rootDoc ? Object.keys(rootDoc.objects ?? {}).length : null,
+            linkedObjects: rootDoc ? Object.keys(rootDoc.links ?? {}).length : null,
+            credentials: space.inner.spaceState.credentials.length,
+            members: space.inner.spaceState.members.size,
+            rootUrl,
+          };
+        });
+      },
+    });
   }
 
   // TODO(burdon): Remove.
@@ -100,7 +142,7 @@ export class DataSpaceManager {
   @synchronized
   async open() {
     log('open');
-    log.trace('dxos.echo.data-space-manager.open', trace.begin({ id: this._instanceId }));
+    log.trace('dxos.echo.data-space-manager.open', Trace.begin({ id: this._instanceId }));
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
 
     await forEachAsync(this._metadataStore.spaces, async (spaceMetadata) => {
@@ -121,7 +163,7 @@ export class DataSpaceManager {
       }
     }
 
-    log.trace('dxos.echo.data-space-manager.open', trace.end({ id: this._instanceId }));
+    log.trace('dxos.echo.data-space-manager.open', Trace.end({ id: this._instanceId }));
   }
 
   @synchronized
@@ -153,10 +195,10 @@ export class DataSpaceManager {
 
     log('creating space...', { spaceKey });
 
-    const automergeRootUrl = await this._echoHost.createSpaceRoot(spaceKey);
+    const root = await this._echoHost.createSpaceRoot(spaceKey);
     const space = await this._constructSpace(metadata);
 
-    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, automergeRootUrl);
+    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, root.url);
     await this._metadataStore.addSpace(metadata);
 
     const memberCredential = credentials[1];
@@ -246,6 +288,11 @@ export class DataSpaceManager {
       onAuthFailure: () => {
         log.warn('auth failure');
       },
+      onMemberRolesChanged: async (members: MemberInfo[]) => {
+        if (dataSpace?.state === SpaceState.READY) {
+          this._handleMemberRoleChanges(presence, space.protocol, members);
+        }
+      },
       memberKey: this._signingContext.identityKey,
       onDelegatedInvitationStatusChange: (invitation, isActive) => {
         return this._handleInvitationStatusChange(dataSpace, invitation, isActive);
@@ -272,6 +319,7 @@ export class DataSpaceManager {
           log('after space ready', { space: space.key, open: this._isOpen });
           if (this._isOpen) {
             await this._createDelegatedInvitations(dataSpace, [...space.spaceState.invitations.entries()]);
+            this._handleMemberRoleChanges(presence, space.protocol, [...space.spaceState.members.values()]);
             this.updated.emit();
           }
         },
@@ -282,6 +330,12 @@ export class DataSpaceManager {
       cache: metadata.cache,
     });
 
+    presence.newPeer.on((peerState) => {
+      if (dataSpace.state === SpaceState.READY) {
+        this._handleNewPeerConnected(space, peerState);
+      }
+    });
+
     if (metadata.state !== SpaceState.INACTIVE) {
       await dataSpace.open();
     }
@@ -294,6 +348,42 @@ export class DataSpaceManager {
     return dataSpace;
   }
 
+  private _handleMemberRoleChanges(presence: Presence, spaceProtocol: SpaceProtocol, memberInfo: MemberInfo[]): void {
+    let closedSessions = 0;
+    for (const member of memberInfo) {
+      if (member.key.equals(presence.getLocalState().identityKey)) {
+        continue;
+      }
+      const peers = presence.getPeersByIdentityKey(member.key);
+      const sessions = peers.map((p) => p.peerId && spaceProtocol.sessions.get(p.peerId));
+      const sessionsToClose = sessions.filter((s): s is SpaceProtocolSession => {
+        return (s && (member.role === SpaceMember.Role.REMOVED) !== (s.authStatus === AuthStatus.FAILURE)) ?? false;
+      });
+      sessionsToClose.forEach((session) => {
+        void session.close().catch(log.error);
+      });
+      closedSessions += sessionsToClose.length;
+    }
+    log('processed member role changes', {
+      roleChangeCount: memberInfo.length,
+      peersOnline: presence.getPeersOnline().length,
+      closedSessions,
+    });
+    // Handle the case when there was a removed peer online, we can now establish a connection with them
+    spaceProtocol.updateTopology();
+  }
+
+  private _handleNewPeerConnected(space: Space, peerState: PeerState): void {
+    const role = space.spaceState.getMemberRole(peerState.identityKey);
+    if (role === SpaceMember.Role.REMOVED) {
+      const session = peerState.peerId && space.protocol.sessions.get(peerState.peerId);
+      if (session != null) {
+        log('closing a session with a removed peer', { peerId: peerState.peerId });
+        void session.close().catch(log.error);
+      }
+    }
+  }
+
   private async _handleInvitationStatusChange(
     dataSpace: DataSpace | undefined,
     delegatedInvitation: DelegateInvitationCredential,

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

@@ -4,12 +4,16 @@
 
 import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
-import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
+import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import { timed, warnAfterTimeout } from '@dxos/debug';
 import { type EchoHost } from '@dxos/echo-db';
-import { type MetadataStore, type Space, createMappedFeedWriter } from '@dxos/echo-pipeline';
-import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
-import { type SpaceDoc } from '@dxos/echo-protocol';
+import {
+  AutomergeDocumentLoaderImpl,
+  createMappedFeedWriter,
+  type MetadataStore,
+  type Space,
+} from '@dxos/echo-pipeline';
+import { type ObjectStructure, type SpaceDoc } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES } from '@dxos/echo-schema';
 import { type FeedStore } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
@@ -17,15 +21,15 @@ import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { CancelledError, SystemError } from '@dxos/protocols';
-import { SpaceState, type Space as SpaceProto, CreateEpochRequest } from '@dxos/protocols/proto/dxos/client/services';
+import { CreateEpochRequest, SpaceState, type Space as SpaceProto } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceCache } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   AdmittedFeed,
-  type ProfileDocument,
+  SpaceMember,
   type Credential,
   type Epoch,
+  type ProfileDocument,
 } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { type Gossip, type Presence } from '@dxos/teleport-extension-gossip';
@@ -360,6 +364,8 @@ export class DataSpace {
 
   private _onNewAutomergeRoot(rootUrl: string) {
     log('loading automerge root doc for space', { space: this.key, rootUrl });
+    // Override share policy = true for the root document.
+    // Workaround for https://github.com/automerge/automerge-repo/pull/292
     this._echoHost.replicateDocument(rootUrl);
     const handle = this._echoHost.automergeRepo.find(rootUrl as any);
 
@@ -378,6 +384,14 @@ export class DataSpace {
             doc.access = { spaceKey: this.key.toHex() };
           });
         }
+
+        // TODO(dmaretskyi): Close roots.
+        // TODO(dmaretskyi): How do we handle changing to the next EPOCH?
+        if (!this._echoHost.roots.has(handle.documentId)) {
+          await this._echoHost.openSpaceRoot(handle.url);
+        } else {
+          log.warn('echo database root already exists', { space: this.key, rootUrl });
+        }
       } catch (err) {
         if (err instanceof ContextDisposedError) {
           return;
@@ -452,7 +466,7 @@ export class DataSpace {
 
           // Find properties object.
           const objects = Object.entries((rootHandle.docSync() as SpaceDoc).objects!);
-          const properties = objects.find(([_, value]) => value.system.type?.itemId === TYPE_PROPERTIES);
+          const properties = findPropertiesObject(rootHandle.docSync() as SpaceDoc);
           const otherObjects = objects.filter(([key]) => key !== properties?.[0]);
           invariant(properties, 'Properties not found');
 
@@ -529,3 +543,16 @@ export class DataSpace {
     this.stateUpdate.emit();
   }
 }
+
+/**
+ * Assumes properties are at root.
+ */
+export const findPropertiesObject = (spaceDoc: SpaceDoc): [string, ObjectStructure] | undefined => {
+  for (const id in spaceDoc.objects ?? {}) {
+    const obj = spaceDoc.objects![id];
+    if (obj.system.type?.itemId === TYPE_PROPERTIES) {
+      return [id, obj];
+    }
+  }
+  return undefined;
+};

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

@@ -4,12 +4,19 @@
 
 import { EventSubscriptions, UpdateScheduler, scheduleTask } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
-import { type CredentialProcessor } from '@dxos/credentials';
+import { createAdmissionCredentials, type CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
 import { raise } from '@dxos/debug';
 import { type SpaceManager } from '@dxos/echo-pipeline';
+import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { ApiError, SpaceNotFoundError, encodeError } from '@dxos/protocols';
+import {
+  ApiError,
+  SpaceNotFoundError,
+  encodeError,
+  IdentityNotInitializedError,
+  AuthorizationError,
+} from '@dxos/protocols';
 import {
   SpaceMember,
   SpaceState,
@@ -24,7 +31,7 @@ import {
   type WriteCredentialsRequest,
   type UpdateMemberRoleRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
-import { type Credential, SpaceMember as HaloSpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { type Provider } from '@dxos/util';
 
@@ -40,10 +47,7 @@ export class SpacesServiceImpl implements SpacesService {
   ) {}
 
   async createSpace(): Promise<Space> {
-    if (!this._identityManager.identity) {
-      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo');
-    }
-
+    this._requireIdentity();
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = await dataSpaceManager.createSpace();
     return this._serializeSpace(space);
@@ -68,8 +72,30 @@ export class SpacesServiceImpl implements SpacesService {
     }
   }
 
-  async updateMemberRole(_: UpdateMemberRoleRequest): Promise<void> {
-    throw new Error('not implemented');
+  async updateMemberRole(request: UpdateMemberRoleRequest): Promise<void> {
+    const identity = this._requireIdentity();
+    const space = this._spaceManager.spaces.get(request.spaceKey);
+    if (space == null) {
+      throw new SpaceNotFoundError(request.spaceKey);
+    }
+    if (!space.spaceState.hasMembershipManagementPermission(identity.identityKey)) {
+      throw new AuthorizationError('No member management permission.', {
+        spaceKey: space.key,
+        role: space.spaceState.getMemberRole(identity.identityKey),
+      });
+    }
+    const credentials = await createAdmissionCredentials(
+      identity.getIdentityCredentialSigner(),
+      request.memberKey,
+      space.key,
+      space.genesisFeedKey,
+      request.newRole,
+      space.spaceState.membershipChainHeads,
+    );
+    invariant(credentials[0].credential);
+    const spaceMemberCredential = credentials[0].credential.credential;
+    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await writeMessages(space.controlPipeline.writer, credentials);
   }
 
   querySpaces(): Stream<QuerySpacesResponse> {
@@ -218,12 +244,8 @@ export class SpacesServiceImpl implements SpacesService {
             identityKey: member.key,
             profile: member.profile ?? {},
           },
-          presence:
-            member.role === HaloSpaceMember.Role.REMOVED
-              ? SpaceMember.PresenceState.REMOVED
-              : isMe || peers.length > 0
-                ? SpaceMember.PresenceState.ONLINE
-                : SpaceMember.PresenceState.OFFLINE,
+          role: member.role,
+          presence: peers.length > 0 ? SpaceMember.PresenceState.ONLINE : SpaceMember.PresenceState.OFFLINE,
           peerStates: peers,
         };
       }),
@@ -232,6 +254,15 @@ export class SpacesServiceImpl implements SpacesService {
       metrics: space.metrics,
     };
   }
+
+  private _requireIdentity() {
+    if (!this._identityManager.identity) {
+      throw new IdentityNotInitializedError(
+        'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
+      );
+    }
+    return this._identityManager.identity;
+  }
 }
 
 // Add `user-channel` prefix to the channel name, so that it doesn't collide with the internal channels.

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.5.3-main.f752aaa";
+export const DXOS_VERSION = "0.5.3-main.fffc127";