@dxos/client-services 0.6.12-staging.e11e696 → 0.6.13-main.548ca8d

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

@@ -0,0 +1,184 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type MutexGuard, scheduleMicroTask, scheduleTask } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { ed25519Signature } from '@dxos/crypto';
+import { type EdgeHttpClient } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import {
+  EdgeAuthChallengeError,
+  EdgeCallFailedError,
+  type JoinSpaceRequest,
+  type JoinSpaceResponseBody,
+} from '@dxos/protocols';
+import { schema } from '@dxos/protocols/proto';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import {
+  type AdmissionResponse,
+  type AdmissionRequest,
+  type SpaceAdmissionRequest,
+} from '@dxos/protocols/proto/dxos/halo/invitations';
+
+import { type InvitationProtocol } from './invitation-protocol';
+import { type FlowLockHolder, type GuardedInvitationState } from './invitation-state';
+import { tryAcquireBeforeContextDisposed } from './utils';
+
+export interface EdgeInvitationHandlerCallbacks {
+  onInvitationSuccess(response: AdmissionResponse, request: AdmissionRequest): Promise<void>;
+}
+
+export const DEFAULT_REQUEST_RETRY_INTERVAL_MS = 3000;
+export const DEFAULT_REQUEST_RETRY_JITTER_MS = 500;
+
+export type EdgeInvitationConfig = {
+  retryInterval?: number;
+  retryJitter?: number;
+};
+
+export class EdgeInvitationHandler implements FlowLockHolder {
+  private _flowLock: MutexGuard | undefined;
+
+  private readonly _retryInterval: number;
+  private readonly _retryJitter: number;
+
+  constructor(
+    config: EdgeInvitationConfig | undefined,
+    private readonly _client: EdgeHttpClient | undefined,
+    private readonly _callbacks: EdgeInvitationHandlerCallbacks,
+  ) {
+    this._retryInterval = config?.retryInterval ?? DEFAULT_REQUEST_RETRY_INTERVAL_MS;
+    this._retryJitter = config?.retryJitter ?? DEFAULT_REQUEST_RETRY_JITTER_MS;
+  }
+
+  public handle(
+    ctx: Context,
+    guardedState: GuardedInvitationState,
+    protocol: InvitationProtocol,
+    deviceProfile?: DeviceProfileDocument,
+  ) {
+    if (!this._client) {
+      log('edge disabled');
+      return;
+    }
+
+    const invitation = guardedState.current;
+    const spaceId = invitation.spaceId;
+    const canBeHandledByEdge =
+      invitation.authMethod !== Invitation.AuthMethod.SHARED_SECRET &&
+      invitation.type === Invitation.Type.DELEGATED &&
+      invitation.kind === Invitation.Kind.SPACE &&
+      spaceId != null &&
+      SpaceId.isValid(spaceId);
+
+    if (!canBeHandledByEdge) {
+      log('invitation could not be handled by edge', { invitation });
+      return;
+    }
+
+    ctx.onDispose(() => {
+      this._flowLock?.release();
+      this._flowLock = undefined;
+    });
+
+    const tryHandleInvitation = async () => {
+      const admissionRequest = await protocol.createAdmissionRequest(deviceProfile);
+      if (admissionRequest.space) {
+        try {
+          await this._handleSpaceInvitationFlow(ctx, guardedState, admissionRequest.space, spaceId);
+        } catch (error) {
+          if (error instanceof EdgeCallFailedError) {
+            log.info('join space with edge unsuccessful', {
+              reason: error.message,
+              retryable: error.isRetryable,
+              after: error.retryAfterMs ?? this._calculateNextRetryMs(),
+            });
+            if (error.isRetryable) {
+              scheduleTask(ctx, tryHandleInvitation, error.retryAfterMs ?? this._calculateNextRetryMs());
+            }
+          } else {
+            log.info('failed to handle invitation with edge', { error });
+            scheduleTask(ctx, tryHandleInvitation, this._calculateNextRetryMs());
+          }
+        }
+      }
+    };
+    scheduleMicroTask(ctx, tryHandleInvitation);
+  }
+
+  private async _handleSpaceInvitationFlow(
+    ctx: Context,
+    guardedState: GuardedInvitationState,
+    admissionRequest: SpaceAdmissionRequest,
+    spaceId: SpaceId,
+  ) {
+    try {
+      log('edge invitation flow');
+      this._flowLock = await tryAcquireBeforeContextDisposed(ctx, guardedState.mutex);
+      log('edge invitation flow acquired the lock');
+
+      guardedState.set(this, Invitation.State.CONNECTING);
+
+      const response = await this._joinSpaceByInvitation(guardedState, spaceId, {
+        identityKey: admissionRequest.identityKey.toHex(),
+        invitationId: guardedState.current.invitationId,
+      });
+
+      const admissionResponse = await this._mapToAdmissionResponse(response);
+      await this._callbacks.onInvitationSuccess(admissionResponse, { space: admissionRequest });
+    } catch (error) {
+      guardedState.set(this, Invitation.State.ERROR);
+      throw error;
+    } finally {
+      this._flowLock?.release();
+      this._flowLock = undefined;
+    }
+  }
+
+  private async _mapToAdmissionResponse(edgeResponse: JoinSpaceResponseBody): Promise<AdmissionResponse> {
+    const credentialBytes = Buffer.from(edgeResponse.spaceMemberCredential, 'base64');
+    const codec = schema.getCodecForType('dxos.halo.credentials.Credential');
+    return {
+      space: {
+        credential: codec.decode(credentialBytes),
+      },
+    };
+  }
+
+  private async _joinSpaceByInvitation(
+    guardedState: GuardedInvitationState,
+    spaceId: SpaceId,
+    request: JoinSpaceRequest,
+  ): Promise<JoinSpaceResponseBody> {
+    invariant(this._client);
+    try {
+      return await this._client.joinSpaceByInvitation(spaceId, request);
+    } catch (error: any) {
+      if (error instanceof EdgeAuthChallengeError) {
+        guardedState.set(this, Invitation.State.AUTHENTICATING);
+        const publicKey = guardedState.current.guestKeypair?.publicKey;
+        const privateKey = guardedState.current.guestKeypair?.privateKey;
+        if (!privateKey || !publicKey) {
+          throw error;
+        }
+        const signature = await ed25519Signature(privateKey, Buffer.from(error.challenge, 'base64'));
+        request.signature = Buffer.from(signature).toString('base64');
+        return this._client.joinSpaceByInvitation(spaceId, request);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  public hasFlowLock(): boolean {
+    return this._flowLock != null;
+  }
+
+  private _calculateNextRetryMs() {
+    return this._retryInterval + Math.random() * this._retryJitter;
+  }
+}

package/src/packlets/invitations/invitation-guest-extenstion.ts

@@ -12,6 +12,7 @@ import { type Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type InvitationHostService, InvitationOptions } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
+import { type FlowLockHolder } from './invitation-state';
 import { tryAcquireBeforeContextDisposed } from './utils';
 
 const OPTIONS_TIMEOUT = 10_000;
@@ -27,10 +28,13 @@ type InvitationGuestExtensionCallbacks = {
 /**
  * Guest's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationGuestExtension extends RpcExtension<
-  { InvitationHostService: InvitationHostService },
-  { InvitationHostService: InvitationHostService }
-> {
+export class InvitationGuestExtension
+  extends RpcExtension<
+    { InvitationHostService: InvitationHostService },
+    { InvitationHostService: InvitationHostService }
+  >
+  implements FlowLockHolder
+{
   private _ctx = new Context();
   private _remoteOptions?: InvitationOptions;
   private _remoteOptionsTrigger = new Trigger();

package/src/packlets/invitations/invitation-host-extension.ts

@@ -21,6 +21,7 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
+import type { FlowLockHolder } from './invitation-state';
 import { stateToString, tryAcquireBeforeContextDisposed } from './utils';
 
 /// Timeout for the options exchange.
@@ -43,10 +44,13 @@ type InvitationHostExtensionCallbacks = {
 /**
  * Host's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationHostExtension extends RpcExtension<
-  { InvitationHostService: InvitationHostService },
-  { InvitationHostService: InvitationHostService }
-> {
+export class InvitationHostExtension
+  extends RpcExtension<
+    { InvitationHostService: InvitationHostService },
+    { InvitationHostService: InvitationHostService }
+  >
+  implements FlowLockHolder
+{
   /**
    * @internal
    */

package/src/packlets/invitations/invitation-state.ts

@@ -0,0 +1,111 @@
+/**
+ * A utility object for serializing invitation state changes by multiple concurrent
+ * invitation flow connections.
+ */
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Mutex, type PushStream } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+import { stateToString } from './utils';
+
+export interface FlowLockHolder {
+  hasFlowLock(): boolean;
+}
+
+export interface GuardedInvitationState {
+  mutex: Mutex;
+  current: Invitation;
+
+  complete(newState: Partial<Invitation>): void;
+  set(lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean;
+  error(lockHolder: FlowLockHolder | null, error: any): boolean;
+}
+
+export const createGuardedInvitationState = (
+  ctx: Context,
+  invitation: Invitation,
+  stream: PushStream<Invitation>,
+): GuardedInvitationState => {
+  // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
+  // deadlocks seem very unlikely because hosts don't initiate multiple connections
+  // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
+  //  A has lock for flow with 1, B has lock for flow with 2
+  //  1 has lock for flow with B, 2 has lock for flow with A
+  // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
+  const mutex = new Mutex();
+  let lastActiveLockHolder: FlowLockHolder | null = null;
+  let currentInvitation = { ...invitation };
+  const isStateChangeAllowed = (lockHolder: FlowLockHolder | null) => {
+    if (ctx.disposed || (lockHolder !== null && mutex.isLocked() && !lockHolder.hasFlowLock())) {
+      return false;
+    }
+    // don't allow transitions from a terminal state unless a new extension acquired mutex
+    // handles a case when error occurs (e.g. connection is closed) after we completed the flow
+    // successfully or already reported another error
+    return lockHolder == null || lastActiveLockHolder !== lockHolder || isNonTerminalState(currentInvitation.state);
+  };
+  return {
+    mutex,
+    get current() {
+      return currentInvitation;
+    },
+    // disposing context prevents any further state updates
+    complete: (newState: Partial<Invitation>) => {
+      currentInvitation = { ...currentInvitation, ...newState };
+      stream.next(currentInvitation);
+      return ctx.dispose();
+    },
+    set: (lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean => {
+      if (isStateChangeAllowed(lockHolder)) {
+        logStateUpdate(currentInvitation, lockHolder, newState);
+        currentInvitation = { ...currentInvitation, state: newState };
+        stream.next(currentInvitation);
+        lastActiveLockHolder = lockHolder;
+        return true;
+      }
+      return false;
+    },
+    error: (lockHolder: FlowLockHolder | null, error: any): boolean => {
+      if (isStateChangeAllowed(lockHolder)) {
+        logStateUpdate(currentInvitation, lockHolder, Invitation.State.ERROR);
+        currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
+        stream.next(currentInvitation);
+        stream.error(error);
+        lastActiveLockHolder = lockHolder;
+        return true;
+      }
+      return false;
+    },
+  };
+};
+
+const logStateUpdate = (invitation: Invitation, actor: any, newState: Invitation.State) => {
+  if (isNonTerminalState(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),
+    });
+  }
+};
+
+const isNonTerminalState = (currentState: Invitation.State): boolean => {
+  return ![
+    Invitation.State.SUCCESS,
+    Invitation.State.ERROR,
+    Invitation.State.CANCELLED,
+    Invitation.State.TIMEOUT,
+    Invitation.State.EXPIRED,
+  ].includes(currentState);
+};

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

@@ -257,8 +257,8 @@ describe('InvitationHandler', () => {
       const space = await peer.dataSpaceManager.createSpace();
       spaceKey = space.key;
     }
-    const invitationHandler = new InvitationsHandler(peer.networkManager, {
-      controlHeartbeatInterval: 250, // faster peer failure detection
+    const invitationHandler = new InvitationsHandler(peer.networkManager, undefined, {
+      teleport: { controlHeartbeatInterval: 250 }, // faster peer failure detection
     });
     const protocol = new SpaceInvitationProtocol(peer.dataSpaceManager, peer.identity, peer.keyring, spaceKey);
     const ctx = new Context();

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

@@ -2,10 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Mutex, type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
+import { type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
 import { INVITATION_TIMEOUT } from '@dxos/client-protocol';
 import { type Context, ContextDisposedError } from '@dxos/context';
 import { createKeyPair, sign } from '@dxos/crypto';
+import { type EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -19,17 +20,21 @@ import { type ExtensionContext, type TeleportExtension, type TeleportParams } fr
 import { trace as _trace } from '@dxos/tracing';
 import { ComplexSet } from '@dxos/util';
 
+import { type EdgeInvitationConfig, EdgeInvitationHandler } from './edge-invitation-handler';
 import { InvitationGuestExtension } from './invitation-guest-extenstion';
 import { InvitationHostExtension, isAuthenticationRequired, MAX_OTP_ATTEMPTS } from './invitation-host-extension';
 import { type InvitationProtocol } from './invitation-protocol';
+import { createGuardedInvitationState } from './invitation-state';
 import { InvitationTopology } from './invitation-topology';
-import { stateToString } from './utils';
 
 const metrics = _trace.metrics;
 
 const MAX_DELEGATED_INVITATION_HOST_TRIES = 3;
 
-type InvitationExtension = InvitationHostExtension | InvitationGuestExtension;
+export type InvitationConnectionParams = {
+  teleport: Partial<TeleportParams>;
+  edgeInvitations?: EdgeInvitationConfig;
+};
 
 /**
  * Generic handler for Halo and Space invitations.
@@ -65,7 +70,8 @@ export class InvitationsHandler {
    */
   constructor(
     private readonly _networkManager: SwarmNetworkManager,
-    private readonly _defaultTeleportParams?: Partial<TeleportParams>,
+    private readonly _edgeClient?: EdgeHttpClient,
+    private readonly _connectionParams?: InvitationConnectionParams,
   ) {}
 
   handleInvitationFlow(
@@ -75,7 +81,7 @@ export class InvitationsHandler {
     invitation: Invitation,
   ): void {
     metrics.increment('dxos.invitation.created');
-    const guardedState = this._createGuardedState(ctx, invitation, stream);
+    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
       const extension = new InvitationHostExtension(guardedState.mutex, {
@@ -208,7 +214,7 @@ export class InvitationsHandler {
     }
 
     const triedPeersIds = new ComplexSet(PublicKey.hash);
-    const guardedState = this._createGuardedState(ctx, invitation, stream);
+    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
 
     const shouldCancelInvitationFlow = (extension: InvitationGuestExtension) => {
       const isLockedByAnotherConnection = guardedState.mutex.isLocked() && !extension.hasFlowLock();
@@ -310,7 +316,7 @@ export class InvitationsHandler {
 
               // 5. Success.
               log('admitted by host', { ...protocol.toJSON() });
-              await guardedState.complete({
+              guardedState.complete({
                 ...guardedState.current,
                 ...result,
                 state: Invitation.State.SUCCESS,
@@ -346,6 +352,15 @@ export class InvitationsHandler {
       return extension;
     };
 
+    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
+      onInvitationSuccess: async (admissionResponse, admissionRequest) => {
+        const result = await protocol.accept(admissionResponse, admissionRequest);
+        log('admitted by edge', { ...protocol.toJSON() });
+        guardedState.complete({ ...guardedState.current, ...result, state: Invitation.State.SUCCESS });
+      },
+    });
+    edgeInvitationHandler.handle(ctx, guardedState, protocol, deviceProfile);
+
     scheduleTask(ctx, async () => {
       const error = protocol.checkInvitation(invitation);
       if (error) {
@@ -389,7 +404,7 @@ export class InvitationsHandler {
       topic: invitation.swarmKey,
       protocolProvider: createTeleportProtocolFactory(async (teleport) => {
         teleport.addExtension('dxos.halo.invitations', extensionFactory());
-      }, this._defaultTeleportParams),
+      }, this._connectionParams?.teleport),
       topology: new InvitationTopology(role),
       label,
     });
@@ -397,90 +412,6 @@ export class InvitationsHandler {
     return swarmConnection;
   }
 
-  /**
-   * A utility object for serializing invitation state changes by multiple concurrent
-   * invitation flow connections.
-   */
-  private _createGuardedState(ctx: Context, invitation: Invitation, stream: PushStream<Invitation>) {
-    // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
-    // deadlocks seem very unlikely because hosts don't initiate multiple connections
-    // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
-    //  A has lock for flow with 1, B has lock for flow with 2
-    //  1 has lock for flow with B, 2 has lock for flow with A
-    // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
-    const mutex = new Mutex();
-    let lastActiveExtension: any = null;
-    let currentInvitation = { ...invitation };
-    const isStateChangeAllowed = (extension: InvitationExtension | null) => {
-      if (ctx.disposed || (extension !== null && mutex.isLocked() && !extension.hasFlowLock())) {
-        return false;
-      }
-      // don't allow transitions from a terminal state unless a new extension acquired mutex
-      // handles a case when error occurs (e.g. connection is closed) after we completed the flow
-      // successfully or already reported another error
-      return extension == null || lastActiveExtension !== extension || this._isNotTerminal(currentInvitation.state);
-    };
-    return {
-      mutex,
-      get current() {
-        return currentInvitation;
-      },
-      // disposing context prevents any further state updates
-      complete: (newState: Partial<Invitation>) => {
-        currentInvitation = { ...currentInvitation, ...newState };
-        stream.next(currentInvitation);
-        return ctx.dispose();
-      },
-      set: (extension: InvitationExtension | null, newState: Invitation.State): boolean => {
-        if (isStateChangeAllowed(extension)) {
-          this._logStateUpdate(currentInvitation, extension, newState);
-          currentInvitation = { ...currentInvitation, state: newState };
-          stream.next(currentInvitation);
-          lastActiveExtension = extension;
-          return true;
-        }
-        return false;
-      },
-      error: (extension: InvitationExtension | null, error: any): boolean => {
-        if (isStateChangeAllowed(extension)) {
-          this._logStateUpdate(currentInvitation, extension, Invitation.State.ERROR);
-          currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
-          stream.next(currentInvitation);
-          stream.error(error);
-          lastActiveExtension = extension;
-          return true;
-        }
-        return false;
-      },
-    };
-  }
-
-  private _logStateUpdate(invitation: Invitation, actor: any, newState: Invitation.State) {
-    if (this._isNotTerminal(newState)) {
-      log('invitation state update', {
-        actor: actor?.constructor.name,
-        newState: stateToString(newState),
-        oldState: stateToString(invitation.state),
-      });
-    } else {
-      log('invitation state update', {
-        actor: actor?.constructor.name,
-        newState: stateToString(newState),
-        oldState: stateToString(invitation.state),
-      });
-    }
-  }
-
-  private _isNotTerminal(currentState: Invitation.State): boolean {
-    return ![
-      Invitation.State.SUCCESS,
-      Invitation.State.ERROR,
-      Invitation.State.CANCELLED,
-      Invitation.State.TIMEOUT,
-      Invitation.State.EXPIRED,
-    ].includes(currentState);
-  }
-
   private async _handleGuestOtpAuth(
     extension: InvitationGuestExtension,
     setState: (newState: Invitation.State) => void,

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

@@ -60,9 +60,13 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
   }
 
   getInvitationContext(): Partial<Invitation> & Pick<Invitation, 'kind'> {
+    invariant(this._spaceKey);
+    const space = this._spaceManager.spaces.get(this._spaceKey);
+    invariant(space);
     return {
       kind: Invitation.Kind.SPACE,
       spaceKey: this._spaceKey,
+      spaceId: space.id,
     };
   }
 

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

@@ -30,7 +30,6 @@ import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type Storage } from '@dxos/random-access-storage';
-import type { TeleportParams } from '@dxos/teleport';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 import { trace as Trace } from '@dxos/tracing';
 import { safeInstanceof } from '@dxos/util';
@@ -47,6 +46,7 @@ import {
   InvitationsManager,
   SpaceInvitationProtocol,
   type InvitationProtocol,
+  type InvitationConnectionParams,
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
@@ -55,7 +55,7 @@ export type ServiceContextRuntimeParams = Pick<
   'devicePresenceOfflineTimeout' | 'devicePresenceAnnounceInterval'
 > &
   DataSpaceManagerRuntimeParams & {
-    invitationConnectionDefaultParams?: Partial<TeleportParams>;
+    invitationConnectionDefaultParams?: InvitationConnectionParams;
     disableP2pReplication?: boolean;
   };
 /**
@@ -179,7 +179,8 @@ export class ServiceContext extends Resource {
     this._meshReplicator = new MeshEchoReplicator();
 
     this.invitations = new InvitationsHandler(
-      this.networkManager, //
+      this.networkManager,
+      this._edgeHttpClient,
       _runtimeParams?.invitationConnectionDefaultParams,
     );
     this.invitationsManager = new InvitationsManager(

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

@@ -46,7 +46,7 @@ import { AlreadyJoinedError, trace as Trace } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { type SpaceMetadata, EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 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';
@@ -394,6 +394,26 @@ export class DataSpaceManager extends Resource {
     });
   }
 
+  async setSpaceEdgeReplicationSetting(spaceKey: PublicKey, setting: EdgeReplicationSetting) {
+    const space = this._spaces.get(spaceKey);
+    invariant(space, 'Space not found.');
+
+    await this._metadataStore.setSpaceEdgeReplicationSetting(spaceKey, setting);
+
+    if (space.isOpen) {
+      switch (setting) {
+        case EdgeReplicationSetting.DISABLED:
+          await this._echoEdgeReplicator?.disconnectFromSpace(space.id);
+          break;
+        case EdgeReplicationSetting.ENABLED:
+          await this._echoEdgeReplicator?.connectToSpace(space.id);
+          break;
+      }
+    }
+
+    space.stateUpdate.emit();
+  }
+
   private async _constructSpace(metadata: SpaceMetadata) {
     log('construct space', { metadata });
     const gossip = new Gossip({
@@ -489,10 +509,18 @@ export class DataSpaceManager extends Resource {
       edgeFeatures: this._edgeFeatures,
     });
     dataSpace.postOpen.append(async () => {
-      await this._echoEdgeReplicator?.connectToSpace(dataSpace.id);
+      const setting = dataSpace.getEdgeReplicationSetting();
+      if (setting === EdgeReplicationSetting.ENABLED) {
+        await this._echoEdgeReplicator?.connectToSpace(dataSpace.id);
+      } else if (this._echoEdgeReplicator) {
+        log('not connecting EchoEdgeReplicator because of EdgeReplicationSetting', { spaceId: dataSpace.id });
+      }
     });
     dataSpace.preClose.append(async () => {
-      await this._echoEdgeReplicator?.disconnectFromSpace(dataSpace.id);
+      const setting = dataSpace.getEdgeReplicationSetting();
+      if (setting === EdgeReplicationSetting.ENABLED) {
+        await this._echoEdgeReplicator?.disconnectFromSpace(dataSpace.id);
+      }
     });
 
     presence.newPeer.on((peerState) => {

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

@@ -570,6 +570,10 @@ export class DataSpace {
     this.stateUpdate.emit();
   }
 
+  getEdgeReplicationSetting() {
+    return this._metadataStore.getSpaceEdgeReplicationSetting(this.key);
+  }
+
   private _onFeedAdded = async (feed: FeedWrapper<any>) => {
     await this._edgeFeedReplicator!.addFeed(feed);
   };

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

@@ -116,9 +116,11 @@ describe('EdgeFeedReplicator', () => {
     admitConnection.wake();
 
     await expect.poll(() => sendSpy.mock.calls.length).toEqual(2);
+    sendSpy.mockRestore();
     expect(messageSink.length).toEqual(0);
     await updateIdentity(messenger);
 
+    await messenger.reconnect.waitForCount(1);
     await expect.poll(() => messageSink.find((msg) => msg.type === 'data')).toBeDefined();
   });