@dxos/client-services 0.1.41 → 0.1.45-next.45667d4

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

@@ -5,15 +5,7 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
-import {
-  AuthenticatingInvitationObservable,
-  CancellableInvitationObservable,
-  Client,
-  EchoProxy,
-  HaloProxy,
-  InvitationsProxy,
-  SpaceProxy
-} from '@dxos/client';
+import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from '@dxos/client-protocol';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
 import { ServiceContext } from '../services';
@@ -29,10 +21,18 @@ export const sanitizeInvitation = (invitation: Invitation): Invitation => {
     authMethod: invitation.authMethod,
     swarmKey: invitation.swarmKey,
     state: invitation.state,
-    timeout: invitation.timeout
+    timeout: invitation.timeout,
   };
 };
 
+export type InvitationHost = {
+  createInvitation(options?: Partial<Invitation>): CancellableInvitationObservable;
+};
+
+export type InvitationGuest = {
+  acceptInvitation(invitation: Invitation): AuthenticatingInvitationObservable;
+};
+
 export type PerformInvitationCallbacks<T> = {
   onConnecting?: (value: T) => boolean | void;
   onConnected?: (value: T) => boolean | void;
@@ -45,8 +45,8 @@ export type PerformInvitationCallbacks<T> = {
 };
 
 export type PerformInvitationParams = {
-  host: ServiceContext | InvitationsProxy | HaloProxy | SpaceProxy;
-  guest: ServiceContext | InvitationsProxy | HaloProxy | EchoProxy | Client;
+  host: ServiceContext | InvitationHost;
+  guest: ServiceContext | InvitationGuest;
   options?: Partial<Invitation>;
   hooks?: {
     host?: PerformInvitationCallbacks<CancellableInvitationObservable>;
@@ -60,7 +60,7 @@ export const performInvitation = ({
   host,
   guest,
   options,
-  hooks
+  hooks,
 }: PerformInvitationParams): [Promise<Result>, Promise<Result>] => {
   const hostComplete = new Trigger<Result>();
   const guestComplete = new Trigger<Result>();
@@ -133,7 +133,7 @@ export const performInvitation = ({
                 return;
               }
               guestComplete.wake({ error });
-            }
+            },
           );
           break;
         }
@@ -188,44 +188,39 @@ export const performInvitation = ({
         return;
       }
       hostComplete.wake({ error });
-    }
+    },
   );
 
   return [hostComplete.wait(), guestComplete.wait()];
 };
 
 const createInvitation = (
-  host: ServiceContext | InvitationsProxy | HaloProxy | SpaceProxy,
-  options?: Partial<Invitation>
+  host: ServiceContext | InvitationHost,
+  options?: Partial<Invitation>,
 ): CancellableInvitationObservable => {
   options ??= {
     authMethod: Invitation.AuthMethod.NONE,
-    ...(options ?? {})
+    ...(options ?? {}),
   };
 
-  if (host instanceof InvitationsProxy || host instanceof HaloProxy || host instanceof SpaceProxy) {
-    return host.createInvitation(options);
+  if (host instanceof ServiceContext) {
+    const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
+    return host.invitations.createInvitation(hostHandler, options);
   }
 
-  const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
-  return host.invitations.createInvitation(hostHandler, options);
+  return host.createInvitation(options);
 };
 
 const acceptInvitation = (
-  guest: ServiceContext | InvitationsProxy | HaloProxy | EchoProxy | Client,
-  invitation: Invitation
+  guest: ServiceContext | InvitationGuest,
+  invitation: Invitation,
 ): AuthenticatingInvitationObservable => {
   invitation = sanitizeInvitation(invitation);
 
-  if (
-    guest instanceof InvitationsProxy ||
-    guest instanceof HaloProxy ||
-    guest instanceof EchoProxy ||
-    guest instanceof Client
-  ) {
-    return guest.acceptInvitation(invitation);
+  if (guest instanceof ServiceContext) {
+    const guestHandler = guest.getInvitationHandler({ kind: invitation.kind });
+    return guest.invitations.acceptInvitation(guestHandler, invitation);
   }
 
-  const guestHandler = guest.getInvitationHandler({ kind: invitation.kind });
-  return guest.invitations.acceptInvitation(guestHandler, invitation);
+  return guest.acceptInvitation(invitation);
 };

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

@@ -1,193 +1,157 @@
 //
-// Copyright 2020 DXOS.org
+// Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
-
-import { asyncTimeout, Trigger } from '@dxos/async';
-import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory, Invitation } from '@dxos/client';
+import { createDefaultModelFactory } from '@dxos/client-protocol';
 import { Config } from '@dxos/config';
-import { raise } from '@dxos/debug';
-import { DocumentModel } from '@dxos/document-model';
-import { DatabaseProxy, genesisMutation } from '@dxos/echo-db';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
-import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { Storage } from '@dxos/random-access-storage';
-import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
-
-import { ClientServicesHost, LocalClientServices } from '../services';
-
-export const testConfigWithLocalSignal = new Config({
-  version: 1,
-  runtime: {
-    services: {
-      signaling: [
-        {
-          // TODO(burdon): Port numbers and global consts?
-          server: 'ws://localhost:4000/.well-known/dx/signal'
-        }
-      ]
-    }
-  }
-});
+import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
+import { SnapshotStore, DataPipeline, MetadataStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
+import { testLocalDatabase } 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 { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
+
+import { ClientServicesHost, ServiceContext } from '../services';
+import { SigningContext } from '../spaces';
 
-/**
- * Client builder supports different configurations, incl. signaling, transports, storage.
- */
-export class TestBuilder {
-  private readonly _config: Config;
+//
+// TODO(burdon): Replace with test builder.
+//
 
-  public storage?: Storage;
+export const createServiceHost = (config: Config, signalManagerContext: MemorySignalManagerContext) => {
+  return new ClientServicesHost({
+    config,
+    signalManager: new MemorySignalManager(signalManagerContext),
+    transportFactory: MemoryTransportFactory,
+  });
+};
 
-  // prettier-ignore
-  constructor (
-    config?: Config,
-    private readonly _modelFactory = createDefaultModelFactory(),
-    private readonly _signalManagerContext = new MemorySignalManagerContext()
-  ) {
-    this._config = config ?? new Config();
-  }
+export const createServiceContext = ({
+  signalContext = new MemorySignalManagerContext(),
+  storage = createStorage({ type: StorageType.RAM }),
+}: {
+  signalContext?: MemorySignalManagerContext;
+  storage?: Storage;
+} = {}) => {
+  const signalManager = new MemorySignalManager(signalContext);
+  const networkManager = new NetworkManager({
+    signalManager,
+    transportFactory: MemoryTransportFactory,
+  });
+
+  const modelFactory = createDefaultModelFactory();
+  return new ServiceContext(storage, networkManager, signalManager, modelFactory);
+};
 
-  get config(): Config {
-    return this._config;
-  }
+export const createPeers = async (numPeers: number) => {
+  const signalContext = new MemorySignalManagerContext();
 
-  /**
-   * Get network manager using local shared memory or remote signal manager.
-   */
-  get networkManager() {
-    const signals = this._config.get('runtime.services.signaling');
-    if (signals) {
-      return new NetworkManager({
-        log: true,
-        signalManager: new WebsocketSignalManager(signals),
-        transportFactory: createWebRTCTransportFactory({
-          iceServers: this._config.get('runtime.services.ice')
-        })
-      });
-    }
-
-    // Memory transport with shared context.
-    return new NetworkManager({
-      log: true,
-      signalManager: new MemorySignalManager(this._signalManagerContext),
-      transportFactory: MemoryTransportFactory
-    });
-  }
+  return await Promise.all(
+    Array.from(Array(numPeers)).map(async () => {
+      const peer = createServiceContext({ signalContext });
+      await peer.open();
+      return peer;
+    }),
+  );
+};
 
-  /**
-   * Create backend service handlers.
-   */
-  createClientServicesHost() {
-    return new ClientServicesHost({
-      config: this._config,
-      modelFactory: this._modelFactory,
-      networkManager: this.networkManager,
-      storage: this.storage
-    });
-  }
+export const createIdentity = async (peer: ServiceContext) => {
+  await peer.createIdentity();
+  return peer;
+};
 
-  /**
-   * Create local services host.
-   */
-  createLocal() {
-    return new LocalClientServices({
-      config: this._config,
-      modelFactory: this._modelFactory,
-      networkManager: this.networkManager,
-      storage: this.storage
-    });
-  }
+// TODO(burdon): Remove @dxos/client-testing.
+// TODO(burdon): Create builder and make configurable.
+export const syncItemsLocal = async (db1: DataPipeline, db2: DataPipeline) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
+};
 
-  /**
-   * Create client/server.
-   */
-  createClientServer(host: ClientServicesHost = this.createClientServicesHost()): [Client, ProtoRpcPeer<{}>] {
-    const [proxyPort, hostPort] = createLinkedPorts();
-    const server = createProtoRpcPeer({
-      exposed: host.descriptors,
-      handlers: host.services as ClientServices,
-      port: hostPort
-    });
-    // TODO(dmaretskyi): Refactor.
-
-    const client = new Client({ services: new ClientServicesProxy(proxyPort) });
-    return [client, server];
+export class TestBuilder {
+  public readonly signalContext = new MemorySignalManagerContext();
+
+  createPeer(): TestPeer {
+    return new TestPeer(this.signalContext);
   }
 }
 
-export const testSpace = async (create: DatabaseProxy, check: DatabaseProxy = create) => {
-  const objectId = PublicKey.random().toHex();
+export type TestPeerProps = {
+  storage?: Storage;
+  feedStore?: FeedStore<any>;
+  metadataStore?: MetadataStore;
+  keyring?: Keyring;
+  networkManager?: NetworkManager;
+  spaceManager?: SpaceManager;
+  snapshotStore?: SnapshotStore;
+};
 
-  const result = create.mutate(genesisMutation(objectId, DocumentModel.meta.type));
+export class TestPeer {
+  private _props: TestPeerProps = {};
 
-  await result.batch.getReceipt();
-  // TODO(dmaretskiy): await result.waitToBeProcessed()
-  assert(create._itemManager.entities.has(result.objectsUpdated[0].id));
+  constructor(private readonly signalContext: MemorySignalManagerContext) {}
 
-  await asyncTimeout(
-    check.itemUpdate.waitForCondition(() => check._itemManager.entities.has(objectId)),
-    1000
-  );
+  get storage() {
+    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
+  }
 
-  return result;
-};
+  get keyring() {
+    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
+  }
 
-export const syncItems = async (db1: DatabaseProxy, db2: DatabaseProxy) => {
-  // Check item replicated from 1 => 2.
-  await testSpace(db1, db2);
+  get feedStore() {
+    return (this._props.feedStore ??= new FeedStore({
+      factory: new FeedFactory({
+        root: this.storage.createDirectory('feeds'),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding,
+        },
+      }),
+    }));
+  }
 
-  // Check item replicated from 2 => 1.
-  await testSpace(db2, db1);
-};
+  get metadataStore() {
+    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  }
 
-export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKey?: PublicKey): Promise<PublicKey> => {
-  const rootSpace = spaceKey ? initialPeer.getSpace(spaceKey) : await initialPeer.createSpace();
-  assert(rootSpace, 'Space not found.');
-
-  await Promise.all(
-    peers.map(async (peer) => {
-      const hostDone = new Trigger<Invitation>();
-      const guestDone = new Trigger<Invitation>();
-
-      const hostObservable = rootSpace.createInvitation({ authMethod: Invitation.AuthMethod.NONE });
-      log('invitation created');
-      hostObservable.subscribe(
-        (hostInvitation) => {
-          switch (hostInvitation.state) {
-            case Invitation.State.CONNECTING: {
-              const guestObservable = peer.acceptInvitation(hostInvitation);
-              log('invitation accepted');
-
-              guestObservable.subscribe(
-                (guestInvitation) => {
-                  switch (guestInvitation.state) {
-                    case Invitation.State.SUCCESS: {
-                      guestDone.wake(guestInvitation);
-                      log('invitation guestDone');
-                      break;
-                    }
-                  }
-                },
-                (err) => raise(err)
-              );
-              break;
-            }
-
-            case Invitation.State.SUCCESS: {
-              hostDone.wake(hostInvitation);
-              log('invitation hostDone');
-            }
-          }
-        },
-        (err) => raise(err)
-      );
+  get snapshotStore() {
+    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  }
 
-      await Promise.all([hostDone.wait(), guestDone.wait()]);
-    })
-  );
+  get networkManager() {
+    return (this._props.networkManager ??= new NetworkManager({
+      signalManager: new MemorySignalManager(this.signalContext),
+      transportFactory: MemoryTransportFactory,
+    }));
+  }
+
+  get spaceManager() {
+    return (this._props.spaceManager ??= new SpaceManager({
+      feedStore: this.feedStore,
+      networkManager: this.networkManager,
+      metadataStore: this.metadataStore,
+      modelFactory: createDefaultModelFactory(),
+      snapshotStore: this.snapshotStore,
+    }));
+  }
+}
 
-  return rootSpace.key;
+export const createSigningContext = async (keyring: Keyring): Promise<SigningContext> => {
+  const identityKey = await keyring.createKey();
+  const deviceKey = await keyring.createKey();
+
+  return {
+    identityKey,
+    deviceKey,
+    credentialSigner: createCredentialSignerWithChain(
+      keyring,
+      {
+        credential: await new CredentialGenerator(keyring, identityKey, deviceKey).createDeviceAuthorization(deviceKey),
+      },
+      deviceKey,
+    ),
+    recordCredential: async () => {}, // No-op.
+  };
 };

package/src/packlets/vault/iframe-host-runtime.ts

@@ -6,7 +6,7 @@ import { Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
 import { log, logInfo } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
-import { createWebRTCTransportFactory, NetworkManager, TransportFactory } from '@dxos/network-manager';
+import { createWebRTCTransportFactory, TransportFactory } from '@dxos/network-manager';
 import { RpcPort } from '@dxos/rpc';
 import { getAsyncValue, MaybePromise, Provider } from '@dxos/util';
 
@@ -70,19 +70,16 @@ export class IFrameHostRuntime {
     try {
       this._config = await getAsyncValue(this._configProvider);
       this._transportFactory = createWebRTCTransportFactory({
-        iceServers: this._config.get('runtime.services.ice')
+        iceServers: this._config.get('runtime.services.ice'),
       });
       const signals = this._config.get('runtime.services.signaling');
       this._clientServices = new LocalClientServices({
         lockKey: LOCK_KEY,
         config: this._config,
-        networkManager: new NetworkManager({
-          log: true,
-          signalManager: signals
-            ? new WebsocketSignalManager(signals)
-            : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
-          transportFactory: this._transportFactory
-        })
+        signalManager: signals
+          ? new WebsocketSignalManager(signals)
+          : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
+        transportFactory: this._transportFactory,
       });
 
       const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
@@ -101,13 +98,13 @@ export class IFrameHostRuntime {
           }
 
           return handler(method, params);
-        }
+        },
       };
 
       this._clientRpc = new ClientRpcServer({
         serviceRegistry: this._clientServices.host.serviceRegistry,
         port: this._appPort,
-        ...middleware
+        ...middleware,
       });
 
       await Promise.all([this._clientServices.open(), this._clientRpc.open(), this._shellRuntime?.open()]);

package/src/packlets/vault/iframe-proxy-runtime.ts

@@ -2,7 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Config, iframeServiceBundle, workerServiceBundle, WorkerServiceBundle } from '@dxos/client';
+import { Trigger } from '@dxos/async';
+import { iframeServiceBundle, workerServiceBundle, WorkerServiceBundle } from '@dxos/client-protocol';
+import { Config } from '@dxos/config';
 import { RemoteServiceConnectionError } from '@dxos/errors';
 import { log } from '@dxos/log';
 import { WebRTCTransportService } from '@dxos/network-manager';
@@ -23,9 +25,11 @@ export type IFrameProxyRuntimeParams = {
  * Manages the client connection to the shared worker.
  */
 export class IFrameProxyRuntime {
+  private readonly _id = String(Math.floor(Math.random() * 1000000));
   private readonly _configProvider: IFrameProxyRuntimeParams['config'];
   private readonly _systemPort: RpcPort;
   private readonly _shellPort?: RpcPort;
+  private _release = new Trigger();
   private _config!: Config;
   private _transportService!: BridgeService;
   private _systemRpc!: ProtoRpcPeer<WorkerServiceBundle>;
@@ -49,7 +53,7 @@ export class IFrameProxyRuntime {
     this._config = await getAsyncValue(this._configProvider);
 
     this._transportService = new WebRTCTransportService({
-      iceServers: this._config.get('runtime.services.ice')
+      iceServers: this._config.get('runtime.services.ice'),
     });
 
     this._systemRpc = createProtoRpcPeer({
@@ -57,19 +61,26 @@ export class IFrameProxyRuntime {
       exposed: iframeServiceBundle,
       handlers: {
         BridgeService: this._transportService,
-        IframeService: {
-          async heartbeat() {
-            // Ok.
-          }
-        }
       },
       port: this._systemPort,
-      timeout: 200
+      timeout: 200,
     });
 
+    let lockKey: string | undefined;
+    if (typeof navigator !== 'undefined') {
+      lockKey = this._lockKey(origin);
+      this._release = new Trigger();
+      const ready = new Trigger();
+      void navigator.locks.request(lockKey, async () => {
+        ready.wake();
+        await this._release.wait();
+      });
+      await ready.wait();
+    }
+
     try {
       await this._systemRpc.open();
-      await this._systemRpc.rpc.WorkerService.start({ origin });
+      await this._systemRpc.rpc.WorkerService.start({ origin, lockKey });
     } catch (err) {
       log.catch(err);
       throw new RemoteServiceConnectionError('Failed to connect to worker');
@@ -78,8 +89,13 @@ export class IFrameProxyRuntime {
   }
 
   async close() {
+    this._release.wake();
     await this._shellRuntime?.close();
     await this._systemRpc.rpc.WorkerService.stop();
     await this._systemRpc.close();
   }
+
+  private _lockKey(origin: string) {
+    return `${origin}-${this._id}`;
+  }
 }

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

@@ -5,7 +5,7 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
-import { appServiceBundle, AppServiceBundle, shellServiceBundle } from '@dxos/client';
+import { appServiceBundle, AppServiceBundle, shellServiceBundle } from '@dxos/client-protocol';
 import { PublicKey } from '@dxos/keys';
 import { AppContextRequest, LayoutRequest, ShellLayout } from '@dxos/protocols/proto/dxos/iframe';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
@@ -67,10 +67,10 @@ export class ShellRuntimeImpl implements ShellRuntime {
             this._invitationCode = request.invitationCode;
             this._spaceKey = request.spaceKey;
             this.layoutUpdate.emit(request);
-          }
-        }
+          },
+        },
       },
-      port: this._port
+      port: this._port,
     });
 
     await this._appRpc.open();

package/src/packlets/vault/vault-resource-lock.ts

@@ -7,7 +7,7 @@ import { log, logInfo } from '@dxos/log';
 import { MaybePromise } from '@dxos/util';
 
 enum Message {
-  ACQUIRING = 'acquiring'
+  ACQUIRING = 'acquiring',
 }
 
 export type VaultResourceLockOptions = {
@@ -37,7 +37,7 @@ export class VaultResourceLock {
 
   async acquire() {
     this._broadcastChannel.postMessage({
-      message: Message.ACQUIRING
+      message: Message.ACQUIRING,
     });
 
     try {

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

@@ -6,7 +6,7 @@ import { Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
 import { log } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
-import { NetworkManager, WebRTCTransportProxyFactory } from '@dxos/network-manager';
+import { WebRTCTransportProxyFactory } from '@dxos/network-manager';
 import { RpcPort } from '@dxos/rpc';
 import { MaybePromise } from '@dxos/util';
 
@@ -51,13 +51,10 @@ export class WorkerRuntime {
       const signals = this._config.get('runtime.services.signaling');
       this._clientServices.initialize({
         config: this._config,
-        networkManager: new NetworkManager({
-          log: true,
-          signalManager: signals
-            ? new WebsocketSignalManager(signals)
-            : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
-          transportFactory: this._transportFactory
-        })
+        signalManager: signals
+          ? new WebsocketSignalManager(signals)
+          : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
+        transportFactory: this._transportFactory,
       });
 
       await this._clientServices.open();
@@ -83,7 +80,7 @@ export class WorkerRuntime {
       appPort,
       systemPort,
       shellPort,
-      readySignal: this._ready
+      readySignal: this._ready,
     });
 
     // When tab is closed.
@@ -102,6 +99,7 @@ export class WorkerRuntime {
    * Selects one of the existing session fro WebRTC networking.
    */
   private _reconnectWebrtc() {
+    log('reconnecting webrtc...');
     // Check if current session is already closed.
     if (this._sessionForNetworking) {
       if (!this.sessions.has(this._sessionForNetworking)) {