@dxos/client-services 0.4.10-main.c75170d → 0.4.10-main.c8e5c39

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

@@ -4,18 +4,20 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context, cancelWithContext } from '@dxos/context';
-import { getCredentialAssertion, type CredentialSigner } from '@dxos/credentials';
-import { type AutomergeHost, type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
+import { getCredentialAssertion, type CredentialSigner, type DelegateInvitationCredential } from '@dxos/credentials';
+import { type EchoHost } from '@dxos/echo-db';
+import { type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
 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 { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
+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 DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
@@ -23,6 +25,7 @@ import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
+import { type InvitationsManager } from '../invitations';
 
 const PRESENCE_ANNOUNCE_INTERVAL = 10_000;
 const PRESENCE_OFFLINE_TIMEOUT = 20_000;
@@ -77,7 +80,8 @@ export class DataSpaceManager {
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
     private readonly _feedStore: FeedStore<FeedMessage>,
-    private readonly _automergeHost: AutomergeHost,
+    private readonly _echoHost: EchoHost,
+    private readonly _invitationsManager: InvitationsManager,
     params?: DataSpaceManagerRuntimeParams,
   ) {
     const {
@@ -149,14 +153,10 @@ export class DataSpaceManager {
 
     log('creating space...', { spaceKey });
 
-    const automergeRoot = this._automergeHost.repo.create();
-    automergeRoot.change((doc: any) => {
-      doc.access = { spaceKey: spaceKey.toHex() };
-    });
-
+    const automergeRootUrl = await this._echoHost.createSpaceRoot(spaceKey);
     const space = await this._constructSpace(metadata);
 
-    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, automergeRoot.url);
+    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, automergeRootUrl);
     await this._metadataStore.addSpace(metadata);
 
     const memberCredential = credentials[1];
@@ -240,13 +240,16 @@ export class DataSpaceManager {
           gossip.createExtension({ remotePeerId: session.remotePeerId }),
         );
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
-        this._automergeHost.authorizeDevice(space.key, session.remotePeerId);
-        session.addExtension('dxos.mesh.teleport.automerge', this._automergeHost.createExtension());
+        this._echoHost.authorizeDevice(space.key, session.remotePeerId);
+        session.addExtension('dxos.mesh.teleport.automerge', this._echoHost.createReplicationExtension());
       },
       onAuthFailure: () => {
         log.warn('auth failure');
       },
       memberKey: this._signingContext.identityKey,
+      onDelegatedInvitationStatusChange: (invitation, isActive) => {
+        return this._handleInvitationStatusChange(dataSpace, invitation, isActive);
+      },
     });
     controlFeed && (await space.setControlFeed(controlFeed));
     dataFeed && (await space.setDataFeed(dataFeed));
@@ -259,6 +262,7 @@ export class DataSpaceManager {
       presence,
       keyring: this._keyring,
       feedStore: this._feedStore,
+      echoHost: this._echoHost,
       signingContext: this._signingContext,
       callbacks: {
         beforeReady: async () => {
@@ -267,6 +271,7 @@ export class DataSpaceManager {
         afterReady: async () => {
           log('after space ready', { space: space.key, open: this._isOpen });
           if (this._isOpen) {
+            await this._createDelegatedInvitations(dataSpace, [...space.spaceState.invitations.entries()]);
             this.updated.emit();
           }
         },
@@ -275,7 +280,6 @@ export class DataSpaceManager {
         },
       },
       cache: metadata.cache,
-      automergeHost: this._automergeHost,
     });
 
     if (metadata.state !== SpaceState.INACTIVE) {
@@ -289,4 +293,43 @@ export class DataSpaceManager {
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }
+
+  private async _handleInvitationStatusChange(
+    dataSpace: DataSpace | undefined,
+    delegatedInvitation: DelegateInvitationCredential,
+    isActive: boolean,
+  ): Promise<void> {
+    if (dataSpace?.state !== SpaceState.READY) {
+      return;
+    }
+    if (isActive) {
+      await this._createDelegatedInvitations(dataSpace, [
+        [delegatedInvitation.credentialId, delegatedInvitation.invitation],
+      ]);
+    } else {
+      await this._invitationsManager.cancelInvitation(delegatedInvitation.invitation);
+    }
+  }
+
+  private async _createDelegatedInvitations(
+    space: DataSpace,
+    invitations: Array<[PublicKey, DelegateSpaceInvitation]>,
+  ): Promise<void> {
+    const tasks = invitations.map(([credentialId, invitation]) => {
+      return this._invitationsManager.createInvitation({
+        type: Invitation.Type.DELEGATED,
+        kind: Invitation.Kind.SPACE,
+        spaceKey: space.key,
+        authMethod: invitation.authMethod,
+        invitationId: invitation.invitationId,
+        swarmKey: invitation.swarmKey,
+        guestKeypair: invitation.guestKey ? { publicKey: invitation.guestKey } : undefined,
+        lifetime: invitation.expiresOn ? invitation.expiresOn.getTime() - Date.now() : undefined,
+        multiUse: invitation.multiUse,
+        delegationCredentialId: credentialId,
+        persistent: false,
+      });
+    });
+    await Promise.all(tasks);
+  }
 }

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

@@ -6,15 +6,10 @@ import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } fr
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import { TYPE_PROPERTIES } from '@dxos/echo-db';
-import {
-  type MetadataStore,
-  type Space,
-  createMappedFeedWriter,
-  type AutomergeHost,
-  type SpaceDoc,
-} from '@dxos/echo-pipeline';
+import { type EchoHost } from '@dxos/echo-db';
+import { type MetadataStore, type Space, createMappedFeedWriter, type SpaceDoc } from '@dxos/echo-pipeline';
 import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
+import { TYPE_PROPERTIES } from '@dxos/echo-schema';
 import { type FeedStore } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -66,10 +61,10 @@ export type DataSpaceParams = {
   presence: Presence;
   keyring: Keyring;
   feedStore: FeedStore<FeedMessage>;
+  echoHost: EchoHost;
   signingContext: SigningContext;
   callbacks?: DataSpaceCallbacks;
   cache?: SpaceCache;
-  automergeHost: AutomergeHost;
 };
 
 export type CreateEpochOptions = {
@@ -92,7 +87,7 @@ export class DataSpace {
   private readonly _notarizationPlugin = new NotarizationPlugin();
   private readonly _callbacks: DataSpaceCallbacks;
   private readonly _cache?: SpaceCache = undefined;
-  private readonly _automergeHost: AutomergeHost;
+  private readonly _echoHost: EchoHost;
 
   // TODO(dmaretskyi): Move into Space?
   private readonly _automergeSpaceState = new AutomergeSpaceState((rootUrl) => this._onNewAutomergeRoot(rootUrl));
@@ -120,7 +115,7 @@ export class DataSpace {
     this._metadataStore = params.metadataStore;
     this._signingContext = params.signingContext;
     this._callbacks = params.callbacks ?? {};
-    this._automergeHost = params.automergeHost;
+    this._echoHost = params.echoHost;
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () =>
@@ -363,8 +358,8 @@ export class DataSpace {
 
   private _onNewAutomergeRoot(rootUrl: string) {
     log('loading automerge root doc for space', { space: this.key, rootUrl });
-    this._automergeHost._requestedDocs.add(rootUrl as any);
-    const handle = this._automergeHost.repo.find(rootUrl as any);
+    this._echoHost.replicateDocument(rootUrl);
+    const handle = this._echoHost.automergeRepo.find(rootUrl as any);
 
     queueMicrotask(async () => {
       try {
@@ -419,7 +414,7 @@ export class DataSpace {
         break;
       case CreateEpochRequest.Migration.INIT_AUTOMERGE:
         {
-          const document = this._automergeHost.repo.create();
+          const document = this._echoHost.automergeRepo.create();
           // TODO(dmaretskyi): Unify epoch construction.
           epoch = {
             previousId: this._automergeSpaceState.lastEpoch?.id,
@@ -432,9 +427,9 @@ export class DataSpace {
       case CreateEpochRequest.Migration.PRUNE_AUTOMERGE_ROOT_HISTORY:
         {
           const currentRootUrl = this._automergeSpaceState.rootUrl;
-          const rootHandle = this._automergeHost.repo.find(currentRootUrl as any);
+          const rootHandle = this._echoHost.automergeRepo.find(currentRootUrl as any);
           await cancelWithContext(this._ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
-          const newRoot = this._automergeHost.repo.create(rootHandle.docSync());
+          const newRoot = this._echoHost.automergeRepo.create(rootHandle.docSync());
           invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
           // TODO(dmaretskyi): Unify epoch construction.
           epoch = {
@@ -450,7 +445,7 @@ export class DataSpace {
           log.info('Fragmenting');
 
           const currentRootUrl = this._automergeSpaceState.rootUrl;
-          const rootHandle = this._automergeHost.repo.find<SpaceDoc>(currentRootUrl as any);
+          const rootHandle = this._echoHost.automergeRepo.find<SpaceDoc>(currentRootUrl as any);
           await cancelWithContext(this._ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
 
           // Find properties object.
@@ -461,11 +456,11 @@ export class DataSpace {
 
           // Create a new space doc with the properties object.
           const newSpaceDoc: SpaceDoc = { ...rootHandle.docSync(), objects: Object.fromEntries([properties]) };
-          const newRoot = this._automergeHost.repo.create(newSpaceDoc);
+          const newRoot = this._echoHost.automergeRepo.create(newSpaceDoc);
           invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
 
           // Create new automerge documents for all objects.
-          const docLoader = new AutomergeDocumentLoaderImpl(this.key, this._automergeHost.repo);
+          const docLoader = new AutomergeDocumentLoaderImpl(this.key, this._echoHost.automergeRepo);
           await docLoader.loadSpaceRootDocHandle(this._ctx, { rootUrl: newRoot.url });
 
           otherObjects.forEach(([key, value]) => {

package/src/packlets/storage/level.ts

@@ -14,6 +14,7 @@ export const createLevel = async (config: Runtime.Client.Storage) => {
   const persistent = isPersistent(config);
   const storagePath = persistent ? path.join(getRootPath(config), 'level') : `/tmp/dxos-${PublicKey.random().toHex()}`;
   const level = new Level<string, string>(storagePath);
+  // TODO(dmaretskyi): This function shouldn't call open - .
   await level.open();
   return level;
 };

package/src/packlets/testing/invitation-utils.ts

@@ -60,146 +60,149 @@ export const performInvitation = ({
   const guestComplete = new Trigger<Result>();
   const authCode = new Trigger<string>();
 
-  const hostObservable = createInvitation(host, options);
-  hostObservable.subscribe(
-    async (hostInvitation: Invitation) => {
-      switch (hostInvitation.state) {
-        case Invitation.State.CONNECTING: {
-          if (hooks?.host?.onConnecting?.(hostObservable)) {
-            break;
-          }
-          const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
-          guestObservable.subscribe(
-            async (guestInvitation: Invitation) => {
-              switch (guestInvitation.state) {
-                case Invitation.State.CONNECTING: {
-                  if (hooks?.guest?.onConnecting?.(guestObservable)) {
+  void createInvitation(host, options).then((hostObservable) => {
+    hostObservable.subscribe(
+      async (hostInvitation: Invitation) => {
+        switch (hostInvitation.state) {
+          case Invitation.State.CONNECTING: {
+            if (hooks?.host?.onConnecting?.(hostObservable)) {
+              break;
+            }
+            const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
+            guestObservable.subscribe(
+              async (guestInvitation: Invitation) => {
+                switch (guestInvitation.state) {
+                  case Invitation.State.CONNECTING: {
+                    if (hooks?.guest?.onConnecting?.(guestObservable)) {
+                      break;
+                    }
+                    invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
                     break;
                   }
-                  invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
-                  break;
-                }
 
-                case Invitation.State.CONNECTED: {
-                  hooks?.guest?.onConnected?.(guestObservable);
-                  break;
-                }
+                  case Invitation.State.CONNECTED: {
+                    hooks?.guest?.onConnected?.(guestObservable);
+                    break;
+                  }
 
-                case Invitation.State.READY_FOR_AUTHENTICATION: {
-                  if (hooks?.guest?.onReady?.(guestObservable)) {
+                  case Invitation.State.READY_FOR_AUTHENTICATION: {
+                    if (hooks?.guest?.onReady?.(guestObservable)) {
+                      break;
+                    }
+                    await guestObservable.authenticate(await authCode.wait());
                     break;
                   }
-                  await guestObservable.authenticate(await authCode.wait());
-                  break;
-                }
 
-                case Invitation.State.AUTHENTICATING: {
-                  hooks?.guest?.onAuthenticating?.(guestObservable);
-                  break;
-                }
+                  case Invitation.State.AUTHENTICATING: {
+                    hooks?.guest?.onAuthenticating?.(guestObservable);
+                    break;
+                  }
 
-                case Invitation.State.SUCCESS: {
-                  if (hooks?.guest?.onSuccess?.(guestObservable)) {
+                  case Invitation.State.SUCCESS: {
+                    if (hooks?.guest?.onSuccess?.(guestObservable)) {
+                      break;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                     break;
                   }
-                  guestComplete.wake({ invitation: guestInvitation });
-                  break;
-                }
 
-                case Invitation.State.CANCELLED: {
-                  if (hooks?.guest?.onCancelled?.(guestObservable)) {
+                  case Invitation.State.CANCELLED: {
+                    if (hooks?.guest?.onCancelled?.(guestObservable)) {
+                      break;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                     break;
                   }
-                  guestComplete.wake({ invitation: guestInvitation });
-                  break;
-                }
 
-                case Invitation.State.TIMEOUT: {
-                  if (hooks?.guest?.onTimeout?.(guestObservable)) {
-                    return;
+                  case Invitation.State.TIMEOUT: {
+                    if (hooks?.guest?.onTimeout?.(guestObservable)) {
+                      return;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                   }
-                  guestComplete.wake({ invitation: guestInvitation });
                 }
-              }
-            },
-            (error: Error) => {
-              if (hooks?.guest?.onError?.(guestObservable)) {
-                return;
-              }
-              guestComplete.wake({ error });
-            },
-          );
-          break;
-        }
-
-        case Invitation.State.CONNECTED: {
-          hooks?.host?.onConnected?.(hostObservable);
-          break;
-        }
+              },
+              (error: Error) => {
+                if (hooks?.guest?.onError?.(guestObservable)) {
+                  return;
+                }
+                guestComplete.wake({ error });
+              },
+            );
+            break;
+          }
 
-        case Invitation.State.READY_FOR_AUTHENTICATION: {
-          if (hooks?.host?.onReady?.(hostObservable)) {
+          case Invitation.State.CONNECTED: {
+            hooks?.host?.onConnected?.(hostObservable);
             break;
           }
-          if (hostInvitation.authCode) {
-            authCode.wake(hostInvitation.authCode);
+
+          case Invitation.State.READY_FOR_AUTHENTICATION: {
+            if (hooks?.host?.onReady?.(hostObservable)) {
+              break;
+            }
+            if (hostInvitation.authCode) {
+              authCode.wake(hostInvitation.authCode);
+            }
+            break;
           }
-          break;
-        }
 
-        case Invitation.State.AUTHENTICATING: {
-          hooks?.host?.onAuthenticating?.(hostObservable);
-          break;
-        }
+          case Invitation.State.AUTHENTICATING: {
+            hooks?.host?.onAuthenticating?.(hostObservable);
+            break;
+          }
 
-        case Invitation.State.SUCCESS: {
-          if (hooks?.host?.onSuccess?.(hostObservable)) {
+          case Invitation.State.SUCCESS: {
+            if (hooks?.host?.onSuccess?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
-        }
 
-        case Invitation.State.CANCELLED: {
-          if (hooks?.host?.onCancelled?.(hostObservable)) {
+          case Invitation.State.CANCELLED: {
+            if (hooks?.host?.onCancelled?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
-        }
 
-        case Invitation.State.TIMEOUT: {
-          if (hooks?.host?.onTimeout?.(hostObservable)) {
+          case Invitation.State.TIMEOUT: {
+            if (hooks?.host?.onTimeout?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
         }
-      }
-    },
-    (error: Error) => {
-      if (hooks?.host?.onError?.(hostObservable)) {
-        return;
-      }
-      hostComplete.wake({ error });
-    },
-  );
+      },
+      (error: Error) => {
+        if (hooks?.host?.onError?.(hostObservable)) {
+          return;
+        }
+        hostComplete.wake({ error });
+      },
+    );
+  });
 
   return [hostComplete.wait(), guestComplete.wait()];
 };
 
-const createInvitation = (
+const createInvitation = async (
   host: ServiceContext | InvitationHost,
   options?: Partial<Invitation>,
-): CancellableInvitation => {
+): Promise<CancellableInvitation> => {
   options ??= {
     authMethod: Invitation.AuthMethod.NONE,
     ...(options ?? {}),
   };
 
   if (host instanceof ServiceContext) {
-    const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
-    return host.invitations.createInvitation(hostHandler, options);
+    return host.invitationsManager.createInvitation({
+      kind: Invitation.Kind.SPACE,
+      ...options,
+    });
   }
 
   return host.share(options);

package/src/packlets/testing/test-builder.ts

@@ -6,22 +6,18 @@ import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import {
-  AutomergeHost,
-  MetadataStore,
-  type LevelDB,
-  SnapshotStore,
-  SpaceManager,
-  valueEncoding,
-} from '@dxos/echo-pipeline';
+import { EchoHost } from '@dxos/echo-db';
+import { MetadataStore, type LevelDB, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { createTestLevel } from '@dxos/echo-pipeline/testing';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { createStorage, StorageType, type Storage } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
+import { InvitationsHandler, InvitationsManager, SpaceInvitationProtocol } from '../invitations';
 import { ClientServicesHost, ServiceContext } from '../services';
 import { DataSpaceManager, type SigningContext } from '../spaces';
 
@@ -103,7 +99,8 @@ export type TestPeerProps = {
   snapshotStore?: SnapshotStore;
   signingContext?: SigningContext;
   blobStore?: BlobStore;
-  automergeHost?: AutomergeHost;
+  echoHost?: EchoHost;
+  invitationsManager?: InvitationsManager;
 };
 
 export class TestPeer {
@@ -175,20 +172,36 @@ export class TestPeer {
     return this._props.signingContext ?? failUndefined();
   }
 
-  get automergeHost() {
-    return (this._props.automergeHost ??= new AutomergeHost({
-      db: this.level.sublevel('automerge'),
+  get echoHost() {
+    return (this._props.echoHost ??= new EchoHost({
+      kv: this.level,
+      storage: this.storage,
     }));
   }
 
-  get dataSpaceManager() {
+  get dataSpaceManager(): DataSpaceManager {
     return (this._props.dataSpaceManager ??= new DataSpaceManager(
       this.spaceManager,
       this.metadataStore,
       this.keyring,
       this.identity,
       this.feedStore,
-      this.automergeHost,
+      this.echoHost,
+      this.invitationsManager,
+    ));
+  }
+
+  get invitationsManager() {
+    return (this._props.invitationsManager ??= new InvitationsManager(
+      new InvitationsHandler(this.networkManager),
+      (invitation) => {
+        if (invitation.kind === Invitation.Kind.SPACE) {
+          return new SpaceInvitationProtocol(this.dataSpaceManager, this.identity!, this.keyring, invitation.spaceKey!);
+        } else {
+          throw new Error('not implemented');
+        }
+      },
+      this.metadataStore,
     ));
   }
 

package/src/packlets/vault/worker-runtime.ts

@@ -120,7 +120,9 @@ export class WorkerRuntime {
       this._sessions.delete(session);
       if (this._sessions.size === 0) {
         // Terminate the worker when all sessions are closed.
-        self.close();
+        if (globalThis.self) {
+          self.close();
+        }
       } else {
         this._reconnectWebrtc();
       }

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.4.10-main.c75170d";
+export const DXOS_VERSION = "0.4.10-main.c8e5c39";