@dxos/client-services 0.7.4 → 0.7.5-labs.071a3e2

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

@@ -2,14 +2,17 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Stream } from '@dxos/codec-protobuf';
+import { Stream } from '@dxos/codec-protobuf/stream';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
+  type SubscribeSwarmStateRequest,
   type NetworkService,
   type NetworkStatus,
   type UpdateConfigRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
+import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
+import { type LeaveRequest, type JoinRequest, type Message } from '@dxos/protocols/proto/dxos/edge/signal';
 
 export class NetworkServiceImpl implements NetworkService {
   constructor(
@@ -41,4 +44,39 @@ export class NetworkServiceImpl implements NetworkService {
   async updateConfig(request: UpdateConfigRequest) {
     await this.networkManager.setConnectionState(request.swarm);
   }
+
+  async joinSwarm(request: JoinRequest): Promise<void> {
+    return this.signalManager.join(request);
+  }
+
+  async leaveSwarm(request: LeaveRequest): Promise<void> {
+    return this.signalManager.leave(request);
+  }
+
+  subscribeSwarmState(request: SubscribeSwarmStateRequest): Stream<SwarmResponse> {
+    return new Stream<SwarmResponse>(({ next }) => {
+      const unsubscribe = this.signalManager.swarmState?.on((state) => {
+        if (request.topic.equals(state.swarmKey)) {
+          next(state);
+        }
+      });
+      return unsubscribe;
+    });
+  }
+
+  async sendMessage(message: Message): Promise<void> {
+    return this.signalManager.sendMessage(message);
+  }
+
+  subscribeMessages(peer: Peer): Stream<Message> {
+    return new Stream<Message>(({ next }) => {
+      const unsubscribe = this.signalManager.onMessage.on((message) => {
+        if (message.recipient.peerKey === peer.peerKey) {
+          next(message);
+        }
+      });
+
+      return unsubscribe;
+    });
+  }
 }

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

@@ -154,6 +154,7 @@ export class ServiceContext extends Resource {
     this.echoHost = new EchoHost({
       kv: this.level,
       peerIdProvider: () => this.identityManager.identity?.deviceKey?.toHex(),
+      getSpaceKeyByRootDocumentId: (documentId) => this.spaceManager.findSpaceByRootDocumentId(documentId)?.key,
     });
 
     this._meshReplicator = new MeshEchoReplicator();
@@ -380,10 +381,11 @@ export class ServiceContext extends Resource {
     let edgeIdentity: EdgeIdentity;
     const identity = this.identityManager.identity;
     if (identity) {
-      log.info('Setting identity on edge connection', {
+      log('setting identity on edge connection', {
         identity: identity.identityKey.toHex(),
         swarms: this.networkManager.topics,
       });
+
       if (params?.deviceCredential) {
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,

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

@@ -609,7 +609,7 @@ export class DataSpaceManager extends Resource {
         invitationId: invitation.invitationId,
         swarmKey: invitation.swarmKey,
         guestKeypair: invitation.guestKey ? { publicKey: invitation.guestKey } : undefined,
-        lifetime: invitation.expiresOn ? invitation.expiresOn.getTime() - Date.now() : undefined,
+        lifetime: invitation.expiresOn ? (invitation.expiresOn.getTime() - Date.now()) / 1000 : undefined,
         multiUse: invitation.multiUse,
         delegationCredentialId: credentialId,
         persistent: false,

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -117,7 +117,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   async addFeed(feed: FeedWrapper<any>) {
-    log.info('addFeed', { key: feed.key, connected: this._connected, hasConnectionCtx: !!this._connectionCtx });
+    log('addFeed', { key: feed.key, connected: this._connected, hasConnectionCtx: !!this._connectionCtx });
     this._feeds.set(feed.key, feed);
 
     if (this._connected && this._connectionCtx) {
@@ -143,13 +143,16 @@ export class EdgeFeedReplicator extends Resource {
 
   private async _sendMessage(message: ProtocolMessage) {
     if (!this._connectionCtx) {
-      log.info('message dropped because connection was disposed');
+      log('message dropped because connection was disposed');
       return;
     }
 
-    const logPayload =
-      message.type === 'data' ? { feedKey: message.feedKey, blocks: message.blocks.map((b) => b.index) } : { message };
-    log.info('sending message', logPayload);
+    if (message.type === 'data') {
+      log('sending blocks', {
+        feedKey: message.feedKey,
+        blocks: message.blocks.map((b) => b.index),
+      });
+    }
 
     invariant(message.feedKey);
     const payloadValue = bufferToArray(encodeCbor(message));
@@ -175,8 +178,6 @@ export class EdgeFeedReplicator extends Resource {
     scheduleMicroTask(this._connectionCtx, async () => {
       switch (message.type) {
         case 'metadata': {
-          log.info('received metadata', { message });
-
           const feedKey = PublicKey.fromHex(message.feedKey);
           const feed = this._feeds.get(feedKey);
           if (!feed) {
@@ -188,13 +189,18 @@ export class EdgeFeedReplicator extends Resource {
 
           this._remoteLength.set(feedKey, message.length);
 
+          const logMeta = { localLength: feed.length, remoteLength: message.length, feedKey };
           if (message.length > feed.length) {
+            log('requesting missing blocks', logMeta);
+
             await this._sendMessage({
               type: 'request',
               feedKey: feedKey.toHex(),
               range: { from: feed.length, to: message.length },
             });
           } else if (message.length < feed.length) {
+            log('pushing blocks to remote', logMeta);
+
             await this._pushBlocks(feed, message.length, feed.length);
           }
 
@@ -202,7 +208,7 @@ export class EdgeFeedReplicator extends Resource {
         }
 
         case 'data': {
-          log.info('received data', { feed: message.feedKey, blocks: message.blocks.map((b) => b.index) });
+          log('received data', { feed: message.feedKey, blocks: message.blocks.map((b) => b.index) });
 
           const feedKey = PublicKey.fromHex(message.feedKey);
           const feed = this._feeds.get(feedKey);
@@ -223,7 +229,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   private async _pushBlocks(feed: FeedWrapper<any>, from: number, to: number) {
-    log.info('pushing blocks', { feed: feed.key.toHex(), from, to });
+    log('pushing blocks', { feed: feed.key.toHex(), from, to });
 
     const blocks: FeedBlock[] = await Promise.all(
       rangeFromTo(from, to).map(async (index) => {
@@ -249,7 +255,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   private async _integrateBlocks(feed: FeedWrapper<any>, blocks: FeedBlock[]) {
-    log.info('integrating blocks', { feed: feed.key.toHex(), blocks: blocks.length });
+    log('integrating blocks', { feed: feed.key.toHex(), blocks: blocks.length });
 
     for (const block of blocks) {
       if (feed.has(block.index)) {

package/src/packlets/spaces/notarization-plugin.ts

@@ -90,6 +90,7 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
 
   private _activeEdgePollingIntervalHandle: any | undefined = undefined;
   private readonly _activeEdgePollingInterval: number;
+  private _activeEdgePollingEnabled = false;
 
   @logInfo
   private readonly _spaceId: SpaceId;
@@ -106,18 +107,15 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   }
 
   setActiveEdgePollingEnabled(enabled: boolean) {
-    invariant(this.isOpen);
     const client = this._edgeClient;
     invariant(client);
-    if (enabled && !this._activeEdgePollingIntervalHandle) {
-      this._activeEdgePollingIntervalHandle = setInterval(() => {
-        if (this._writer) {
-          this._notarizePendingEdgeCredentials(client, this._writer);
-        }
-      }, this._activeEdgePollingInterval);
-    } else if (!enabled && this._activeEdgePollingIntervalHandle) {
-      clearInterval(this._activeEdgePollingIntervalHandle);
-      this._activeEdgePollingIntervalHandle = undefined;
+    this._activeEdgePollingEnabled = enabled;
+    if (this.isOpen) {
+      if (enabled && !this._activeEdgePollingIntervalHandle) {
+        this._startPeriodicEdgePolling(client);
+      } else if (!enabled && this._activeEdgePollingIntervalHandle) {
+        this._stopPeriodicEdgePolling();
+      }
     }
   }
 
@@ -126,16 +124,18 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   }
 
   protected override async _open() {
-    if (this._edgeClient && this._writer) {
-      this._notarizePendingEdgeCredentials(this._edgeClient, this._writer);
+    if (this._edgeClient) {
+      if (this._activeEdgePollingEnabled) {
+        this._startPeriodicEdgePolling(this._edgeClient);
+      }
+      if (this._writer) {
+        this._notarizePendingEdgeCredentials(this._edgeClient, this._writer);
+      }
     }
   }
 
   protected override async _close() {
-    if (this._activeEdgePollingIntervalHandle) {
-      clearInterval(this._activeEdgePollingIntervalHandle);
-      this._activeEdgePollingIntervalHandle = undefined;
-    }
+    this._stopPeriodicEdgePolling();
     await this._ctx.dispose();
   }
 
@@ -273,11 +273,26 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   setWriter(writer: FeedWriter<Credential>) {
     invariant(!this._writer, 'Writer already set.');
     this._writer = writer;
-    if (this._edgeClient) {
+    if (this._edgeClient && this.isOpen) {
       this._notarizePendingEdgeCredentials(this._edgeClient, writer);
     }
   }
 
+  private _startPeriodicEdgePolling(client: EdgeHttpClient) {
+    this._activeEdgePollingIntervalHandle = setInterval(() => {
+      if (this._writer) {
+        this._notarizePendingEdgeCredentials(client, this._writer);
+      }
+    }, this._activeEdgePollingInterval);
+  }
+
+  private _stopPeriodicEdgePolling() {
+    if (this._activeEdgePollingIntervalHandle) {
+      clearInterval(this._activeEdgePollingIntervalHandle);
+      this._activeEdgePollingIntervalHandle = undefined;
+    }
+  }
+
   /**
    * The method is used only for adding agent feeds to spaces.
    * When an agent is created we can admit them into all the existing spaces. In case the operation fails

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

@@ -3,8 +3,13 @@
 //
 
 import { EventSubscriptions, UpdateScheduler, scheduleTask } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf';
-import { createAdmissionCredentials, type CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
+import { Stream } from '@dxos/codec-protobuf/stream';
+import {
+  createAdmissionCredentials,
+  createDidFromIdentityKey,
+  type CredentialProcessor,
+  getCredentialAssertion,
+} from '@dxos/credentials';
 import { raise } from '@dxos/debug';
 import { type SpaceManager } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
@@ -115,7 +120,9 @@ export class SpacesServiceImpl implements SpacesService {
         ctx,
         async () => {
           const dataSpaceManager = await this._getDataSpaceManager();
-          const spaces = Array.from(dataSpaceManager.spaces.values()).map((space) => this._serializeSpace(space));
+          const spaces = await Promise.all(
+            Array.from(dataSpaceManager.spaces.values()).map((space) => this._serializeSpace(space)),
+          );
           log('update', () => ({ ids: spaces.map((space) => space.id) }));
           await this._updateMetrics();
           next({ spaces });
@@ -265,10 +272,10 @@ export class SpacesServiceImpl implements SpacesService {
       await myIdentity.controlPipeline.writer.write({ credential: { credential } });
     }
 
-    return { space: this._serializeSpace(dataSpace) };
+    return { space: await this._serializeSpace(dataSpace) };
   }
 
-  private _serializeSpace(space: DataSpace): Space {
+  private async _serializeSpace(space: DataSpace): Promise<Space> {
     return {
       id: space.id,
       spaceKey: space.key,
@@ -291,24 +298,27 @@ export class SpacesServiceImpl implements SpacesService {
 
         spaceRootUrl: space.databaseRoot?.url,
       },
-      members: Array.from(space.inner.spaceState.members.values()).map((member) => {
-        const peers = space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key));
-        const isMe = this._identityManager.identity?.identityKey.equals(member.key);
+      members: await Promise.all(
+        Array.from(space.inner.spaceState.members.values()).map(async (member) => {
+          const peers = space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key));
+          const isMe = this._identityManager.identity?.identityKey.equals(member.key);
 
-        if (isMe) {
-          peers.push(space.presence.getLocalState());
-        }
+          if (isMe) {
+            peers.push(space.presence.getLocalState());
+          }
 
-        return {
-          identity: {
-            identityKey: member.key,
-            profile: member.profile ?? {},
-          },
-          role: member.role,
-          presence: peers.length > 0 ? SpaceMember.PresenceState.ONLINE : SpaceMember.PresenceState.OFFLINE,
-          peerStates: peers,
-        };
-      }),
+          return {
+            identity: {
+              did: await createDidFromIdentityKey(member.key),
+              identityKey: member.key,
+              profile: member.profile ?? {},
+            },
+            role: member.role,
+            presence: peers.length > 0 ? SpaceMember.PresenceState.ONLINE : SpaceMember.PresenceState.OFFLINE,
+            peerStates: peers,
+          };
+        }),
+      ),
       creator: space.inner.spaceState.creator?.key,
       cache: space.cache,
       metrics: space.metrics,

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

@@ -3,7 +3,7 @@
 //
 
 import { type Event } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf';
+import { Stream } from '@dxos/codec-protobuf/stream';
 import { type Config } from '@dxos/config';
 import {
   GetDiagnosticsRequest,

package/src/version.ts

@@ -1,5 +1 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export const DXOS_VERSION = '0.7.4'; // {x-release-please-version}
+export const DXOS_VERSION = "0.7.5-labs.071a3e2";