@dxos/client-services 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

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

@@ -28,6 +28,7 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 
 import { type InvitationProtocol } from './invitation-protocol';
+import { computeExpirationTime } from './utils';
 import { type DataSpaceManager, type SigningContext } from '../spaces';
 
 export class SpaceInvitationProtocol implements InvitationProtocol {
@@ -113,9 +114,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
         authMethod: invitation.authMethod,
         swarmKey: invitation.swarmKey,
         role: invitation.role ?? SpaceMember.Role.ADMIN,
-        expiresOn: invitation.lifetime
-          ? new Date((invitation.created?.getTime() ?? Date.now()) + invitation.lifetime)
-          : undefined,
+        expiresOn: computeExpirationTime(invitation),
         multiUse: invitation.multiUse ?? false,
         guestKey:
           invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY

package/src/packlets/invitations/utils.ts

@@ -10,6 +10,13 @@ export const stateToString = (state: Invitation.State): string => {
   return Object.entries(Invitation.State).find(([key, val]) => val === state)?.[0] ?? 'unknown';
 };
 
+export const computeExpirationTime = (invitation: Partial<Invitation>): Date | undefined => {
+  if (!invitation.lifetime) {
+    return;
+  }
+  return new Date((invitation.created?.getTime() ?? Date.now()) + invitation.lifetime * 1000);
+};
+
 export const tryAcquireBeforeContextDisposed = async (ctx: Context, mutex: Mutex): Promise<MutexGuard> => {
   let guard: MutexGuard | undefined;
   return cancelWithContext(

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

@@ -3,7 +3,7 @@
 //
 
 import { Event } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf';
+import { Stream } from '@dxos/codec-protobuf/stream';
 import { PublicKey } from '@dxos/keys';
 import {
   type LogLevel,

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();

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

@@ -503,7 +503,7 @@ export class DataSpaceManager extends Resource {
     });
     dataSpace.postOpen.append(async () => {
       const setting = dataSpace.getEdgeReplicationSetting();
-      if (setting === EdgeReplicationSetting.ENABLED) {
+      if (!setting || setting === EdgeReplicationSetting.ENABLED) {
         await this._echoEdgeReplicator?.connectToSpace(dataSpace.id);
       } else if (this._echoEdgeReplicator) {
         log('not connecting EchoEdgeReplicator because of EdgeReplicationSetting', { spaceId: dataSpace.id });
@@ -511,7 +511,7 @@ export class DataSpaceManager extends Resource {
     });
     dataSpace.preClose.append(async () => {
       const setting = dataSpace.getEdgeReplicationSetting();
-      if (setting === EdgeReplicationSetting.ENABLED) {
+      if (!setting || setting === EdgeReplicationSetting.ENABLED) {
         await this._echoEdgeReplicator?.disconnectFromSpace(dataSpace.id);
       }
     });
@@ -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/data-space.ts

@@ -14,7 +14,7 @@ import {
   type MetadataStore,
   type Space,
 } from '@dxos/echo-pipeline';
-import { SpaceDocVersion } from '@dxos/echo-protocol';
+import { SpaceDocVersion, type SpaceDoc } from '@dxos/echo-protocol';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { failedInvariant } from '@dxos/invariant';
@@ -446,7 +446,7 @@ export class DataSpace {
   private _onNewAutomergeRoot(rootUrl: string) {
     log('loading automerge root doc for space', { space: this.key, rootUrl });
 
-    const handle = this._echoHost.automergeRepo.find(rootUrl as any);
+    const handle = this._echoHost.automergeRepo.find<SpaceDoc>(rootUrl as any);
 
     // TODO(dmaretskyi): Make this single-threaded (but doc loading should still be parallel to not block epoch processing).
     queueMicrotask(async () => {

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,12 +143,12 @@ 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;
     }
 
     if (message.type === 'data') {
-      log.info('sending blocks', {
+      log('sending blocks', {
         feedKey: message.feedKey,
         blocks: message.blocks.map((b) => b.index),
       });
@@ -191,7 +191,7 @@ export class EdgeFeedReplicator extends Resource {
 
           const logMeta = { localLength: feed.length, remoteLength: message.length, feedKey };
           if (message.length > feed.length) {
-            log.info('requesting missing blocks', logMeta);
+            log('requesting missing blocks', logMeta);
 
             await this._sendMessage({
               type: 'request',
@@ -199,7 +199,7 @@ export class EdgeFeedReplicator extends Resource {
               range: { from: feed.length, to: message.length },
             });
           } else if (message.length < feed.length) {
-            log.info('pushing blocks to remote', logMeta);
+            log('pushing blocks to remote', logMeta);
 
             await this._pushBlocks(feed, message.length, feed.length);
           }
@@ -208,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);
@@ -229,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) => {
@@ -255,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 +1 @@
-export const DXOS_VERSION = "0.7.5-main.9d26e3a";
+export const DXOS_VERSION = "0.7.5-main.b19bfc8";