@dxos/client-services 0.1.23 → 0.1.24-next.6b1f434

package/src/packlets/testing/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './credential-utils';
 export * from './test-builder';
+export * from './invitation-utils';

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

@@ -0,0 +1,44 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Trigger } from '@dxos/async';
+import { raise } from '@dxos/debug';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+import { InvitationsHandler } from '../invitations';
+
+export const performInvitation = async <T>(host: InvitationsHandler<T>, guest: InvitationsHandler<T>, context: T) => {
+  const done1 = new Trigger<Invitation>(); // peer 1 connected.
+  const done2 = new Trigger<Invitation>(); // peer 2 connected.
+  const observable1 = await host.createInvitation(context, { type: Invitation.Type.INTERACTIVE_TESTING });
+  observable1.subscribe({
+    onConnecting: async (invitation1: Invitation) => {
+      const observable2 = await guest.acceptInvitation(invitation1, { type: Invitation.Type.INTERACTIVE_TESTING });
+      observable2.subscribe({
+        onConnecting: async (invitation2: Invitation) => {
+          assert(invitation1.swarmKey!.equals(invitation2.swarmKey!));
+        },
+        onConnected: async (invitation2: Invitation) => {},
+        onSuccess: (invitation) => {
+          done2.wake(invitation);
+        },
+        onCancelled: () => raise(new Error()),
+        onTimeout: (err: Error) => raise(err),
+        onError: (err: Error) => raise(err)
+      });
+    },
+    onConnected: async (invitation1: Invitation) => {},
+    onCancelled: () => raise(new Error('cancelled')),
+    onSuccess: (invitation) => {
+      done1.wake(invitation);
+    },
+    onTimeout: (err: Error) => raise(err),
+    onError: (err: Error) => raise(err)
+  });
+
+  await done1.wait();
+  await done2.wait();
+};

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

@@ -2,11 +2,17 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
-
 import { Config } from '@dxos/config';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
-import { ISpace, MetadataStore, SigningContext, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-db';
+import {
+  SnapshotStore,
+  DataPipelineControllerImpl,
+  MetadataStore,
+  SigningContext,
+  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';
@@ -66,20 +72,9 @@ export const createIdentity = async (peer: ServiceContext) => {
 
 // TODO(burdon): Remove @dxos/client-testing.
 // TODO(burdon): Create builder and make configurable.
-export const syncItems = async (space1: ISpace, space2: ISpace) => {
-  {
-    // Check item replicated from 1 => 2.
-    const item1 = await space1.database!.createItem({ type: 'type-1' });
-    const item2 = await space2.database!.waitForItem({ type: 'type-1' });
-    expect(item1.id).to.eq(item2.id);
-  }
-
-  {
-    // Check item replicated from 2 => 1.
-    const item1 = await space2.database!.createItem({ type: 'type-2' });
-    const item2 = await space1.database!.waitForItem({ type: 'type-2' });
-    expect(item1.id).to.eq(item2.id);
-  }
+export const syncItems = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
 };
 
 export class TestBuilder {
@@ -161,6 +156,7 @@ export const createSigningContext = async (keyring: Keyring): Promise<SigningCon
         credential: await new CredentialGenerator(keyring, identityKey, deviceKey).createDeviceAuthorization(deviceKey)
       },
       deviceKey
-    )
+    ),
+    recordCredential: async () => {} // No-op.
   };
 };

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

@@ -0,0 +1,131 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+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 } from '@dxos/network-manager';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+import { getAsyncValue, Provider } from '@dxos/util';
+
+import { clientServiceBundle, ClientServices, ClientServicesHost } from '../services';
+import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
+
+const LOCK_KEY = 'DXOS_RESOURCE_LOCK';
+
+export type IFrameHostRuntimeParams = {
+  configProvider: Config | Provider<Promise<Config>>;
+  appPort: RpcPort;
+  shellPort?: RpcPort;
+};
+
+/**
+ * Runs the client services in the main thread.
+ *
+ * Holds a lock over the client services such that only one instance can run at a time.
+ * This should only be used when SharedWorker is not available.
+ */
+export class IFrameHostRuntime {
+  private readonly _configProvider: Config | Provider<Promise<Config>>;
+  private readonly _transportFactory = createWebRTCTransportFactory();
+  private readonly _ready = new Trigger<Error | undefined>();
+  private readonly _getService: <Service>(
+    find: (services: Partial<ClientServices>) => Service | undefined
+  ) => Promise<Service>;
+
+  private readonly _appPort: RpcPort;
+  private readonly _shellPort?: RpcPort;
+  private _config!: Config;
+  private _clientServices!: ClientServicesHost;
+  private _clientRpc!: ProtoRpcPeer<ClientServices>;
+  private _shellRuntime?: ShellRuntimeImpl;
+
+  @logInfo
+  public origin?: string;
+
+  constructor({ configProvider, appPort, shellPort }: IFrameHostRuntimeParams) {
+    this._configProvider = configProvider;
+    this._appPort = appPort;
+    this._shellPort = shellPort;
+
+    this._getService = async (find) => {
+      const error = await this._ready.wait();
+      if (error) {
+        throw error;
+      }
+
+      const service = await find(this._clientServices.services);
+      if (!service) {
+        throw new Error('Service not found');
+      }
+
+      return service;
+    };
+
+    if (this._shellPort) {
+      this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
+    }
+  }
+
+  get services() {
+    return this._clientServices;
+  }
+
+  get shell(): ShellRuntime | undefined {
+    return this._shellRuntime;
+  }
+
+  async start() {
+    log('starting...');
+    try {
+      this._config = await getAsyncValue(this._configProvider);
+      const signalServer = this._config.get('runtime.services.signal.server');
+      this._clientServices = new ClientServicesHost({
+        lockKey: LOCK_KEY,
+        config: this._config,
+        networkManager: new NetworkManager({
+          log: true,
+          signalManager: signalServer
+            ? new WebsocketSignalManager([signalServer])
+            : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
+          transportFactory: this._transportFactory
+        })
+      });
+
+      this._clientRpc = createProtoRpcPeer({
+        exposed: clientServiceBundle,
+        handlers: {
+          DataService: async () => await this._getService((services) => services.DataService),
+          DevicesService: async () => await this._getService((services) => services.DevicesService),
+          DevtoolsHost: async () => await this._getService((services) => services.DevtoolsHost),
+          HaloInvitationsService: async () => await this._getService((services) => services.HaloInvitationsService),
+          NetworkService: async () => await this._getService((services) => services.NetworkService),
+          ProfileService: async () => await this._getService((services) => services.ProfileService),
+          SpaceInvitationsService: async () => await this._getService((services) => services.SpaceInvitationsService),
+          SpaceService: async () => await this._getService((services) => services.SpaceService),
+          SpacesService: async () => await this._getService((services) => services.SpacesService),
+          SystemService: async () => await this._getService((services) => services.SystemService),
+          TracingService: async () => await this._getService((services) => services.TracingService)
+        },
+        port: this._appPort
+      });
+
+      await Promise.all([this._clientServices.open(), this._clientRpc.open(), this._shellRuntime?.open()]);
+      this._ready.wake(undefined);
+      log('started');
+    } catch (err: any) {
+      this._ready.wake(err);
+      log.catch(err);
+    }
+  }
+
+  async stop() {
+    log('stopping...');
+    await this._clientRpc.close();
+    await this._clientServices.close();
+    await this._shellRuntime?.close();
+    log('stopped');
+  }
+}

package/src/packlets/vault/{iframe-runtime.ts → iframe-proxy-runtime.ts}

@@ -7,28 +7,33 @@ import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 
 import { iframeServiceBundle, WorkerServiceBundle, workerServiceBundle } from './services';
+import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
 
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.
-export type IframeRuntimeParams = {
+export type IFrameProxyRuntimeParams = {
   systemPort: RpcPort;
   workerAppPort: RpcPort;
   windowAppPort: RpcPort;
+  shellPort?: RpcPort;
 };
 
 /**
  * Manages the client connection to the shared worker.
  */
-export class IFrameRuntime {
+export class IFrameProxyRuntime {
   private readonly _systemPort: RpcPort;
   private readonly _windowAppPort: RpcPort;
   private readonly _workerAppPort: RpcPort;
+  private readonly _shellPort?: RpcPort;
   private readonly _systemRpc: ProtoRpcPeer<WorkerServiceBundle>;
+  private readonly _shellRuntime?: ShellRuntimeImpl;
   private readonly _transportService = new WebRTCTransportService();
 
-  constructor({ systemPort, workerAppPort, windowAppPort }: IframeRuntimeParams) {
+  constructor({ systemPort, workerAppPort, windowAppPort, shellPort }: IFrameProxyRuntimeParams) {
     this._systemPort = systemPort;
     this._windowAppPort = windowAppPort;
     this._workerAppPort = workerAppPort;
+    this._shellPort = shellPort;
 
     this._systemRpc = createProtoRpcPeer({
       requested: workerServiceBundle,
@@ -47,14 +52,24 @@ export class IFrameRuntime {
 
     this._workerAppPort.subscribe((msg) => this._windowAppPort.send(msg));
     this._windowAppPort.subscribe((msg) => this._workerAppPort.send(msg));
+
+    if (this._shellPort) {
+      this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
+    }
+  }
+
+  get shell(): ShellRuntime | undefined {
+    return this._shellRuntime;
   }
 
   async open(origin: string) {
     await this._systemRpc.open();
     await this._systemRpc.rpc.WorkerService.start({ origin });
+    await this._shellRuntime?.open();
   }
 
   async close() {
+    await this._shellRuntime?.close();
     await this._systemRpc.rpc.WorkerService.stop();
     await this._systemRpc.close();
   }

package/src/packlets/vault/index.ts

@@ -2,6 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './iframe-runtime';
+export * from './iframe-host-runtime';
+export * from './iframe-proxy-runtime';
+export * from './services';
+export * from './shell-controller';
+export * from './shell-runtime';
+export * from './vault-resource-lock';
 export * from './worker-runtime';
 export * from './worker-session';

package/src/packlets/vault/services.ts

@@ -3,7 +3,7 @@
 //
 
 import { schema } from '@dxos/protocols';
-import type { IframeService, WorkerService } from '@dxos/protocols/proto/dxos/iframe';
+import type { IframeService, AppService, ShellService, WorkerService } from '@dxos/protocols/proto/dxos/iframe';
 import type { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ServiceBundle } from '@dxos/rpc';
 
@@ -24,3 +24,19 @@ export type WorkerServiceBundle = {
 export const workerServiceBundle: ServiceBundle<WorkerServiceBundle> = {
   WorkerService: schema.getService('dxos.iframe.WorkerService')
 };
+
+export type AppServiceBundle = {
+  AppService: AppService;
+};
+
+export const appServiceBundle: ServiceBundle<AppServiceBundle> = {
+  AppService: schema.getService('dxos.iframe.AppService')
+};
+
+export type ShellServiceBundle = {
+  ShellService: ShellService;
+};
+
+export const shellServiceBundle: ServiceBundle<ShellServiceBundle> = {
+  ShellService: schema.getService('dxos.iframe.ShellService')
+};

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

@@ -0,0 +1,77 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { AppContextRequest, LayoutRequest, ShellDisplay, ShellLayout } from '@dxos/protocols/proto/dxos/iframe';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+
+import { appServiceBundle, shellServiceBundle, ShellServiceBundle } from './services';
+
+/**
+ * Provide access to the shell via RPC connection.
+ */
+export class ShellController {
+  readonly contextUpdate = new Event<AppContextRequest>();
+  private _shellRpc?: ProtoRpcPeer<ShellServiceBundle>;
+  private _display = ShellDisplay.NONE;
+  private _spaceKey?: PublicKey;
+  private _invitationCode?: string;
+
+  constructor(private readonly _port: RpcPort) {}
+
+  get display() {
+    return this._display;
+  }
+
+  get spaceKey() {
+    return this._spaceKey;
+  }
+
+  setSpace(key?: PublicKey) {
+    this._spaceKey = key;
+    this._emitUpdate();
+  }
+
+  async setLayout(layout: ShellLayout, options: Omit<LayoutRequest, 'layout'> = {}) {
+    this._display = ShellDisplay.FULLSCREEN;
+    this._emitUpdate();
+    await this._shellRpc?.rpc.ShellService.setLayout({ layout, ...options });
+  }
+
+  async open() {
+    this._shellRpc = createProtoRpcPeer({
+      requested: shellServiceBundle,
+      exposed: appServiceBundle,
+      handlers: {
+        AppService: {
+          setContext: async (request) => {
+            log('set context', request);
+            this._display = request.display;
+            this._spaceKey = request.spaceKey;
+            this._invitationCode = request.invitationCode;
+            this.contextUpdate.emit(request);
+          }
+        }
+      },
+      port: this._port
+    });
+
+    await this._shellRpc.open();
+  }
+
+  async close() {
+    await this._shellRpc?.close();
+    this._shellRpc = undefined;
+  }
+
+  private _emitUpdate() {
+    this.contextUpdate.emit({
+      display: this._display,
+      spaceKey: this._spaceKey,
+      invitationCode: this._invitationCode
+    });
+  }
+}

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

@@ -0,0 +1,133 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Event } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { AppContextRequest, LayoutRequest, ShellLayout } from '@dxos/protocols/proto/dxos/iframe';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+
+import { AppServiceBundle, appServiceBundle, shellServiceBundle } from './services';
+
+export interface ShellRuntime {
+  layoutUpdate: Event<LayoutRequest>;
+  layout: ShellLayout;
+  invitationCode?: string;
+  spaceKey?: PublicKey;
+  setLayout: (layout: ShellLayout, options?: Omit<LayoutRequest, 'layout'>) => void;
+  setAppContext: (context: AppContextRequest) => Promise<void>;
+}
+
+/**
+ * Endpoint that handles shell services.
+ */
+export class ShellRuntimeImpl implements ShellRuntime {
+  readonly layoutUpdate = new Event<LayoutRequest>();
+  private _appRpc?: ProtoRpcPeer<AppServiceBundle>;
+  private _layout = ShellLayout.DEFAULT;
+  private _invitationCode?: string;
+  private _spaceKey?: PublicKey;
+
+  constructor(private readonly _port: RpcPort) {}
+
+  get layout() {
+    return this._layout;
+  }
+
+  get invitationCode() {
+    return this._invitationCode;
+  }
+
+  get spaceKey() {
+    return this._spaceKey;
+  }
+
+  setLayout(layout: ShellLayout, options: Omit<LayoutRequest, 'layout'> = {}) {
+    this._layout = layout;
+    this._invitationCode = options.invitationCode;
+    this._spaceKey = options.spaceKey;
+    this.layoutUpdate.emit({ layout, ...options });
+  }
+
+  async setAppContext(context: AppContextRequest) {
+    assert(this._appRpc, 'runtime not open');
+
+    if (context.spaceKey) {
+      this._spaceKey = context.spaceKey;
+    }
+
+    if (context.invitationCode) {
+      this._invitationCode = context.invitationCode;
+    }
+
+    await this._appRpc.rpc.AppService.setContext({
+      ...context,
+      spaceKey: this._spaceKey,
+      invitationCode: this._invitationCode
+    });
+  }
+
+  async open() {
+    this._appRpc = createProtoRpcPeer({
+      requested: appServiceBundle,
+      exposed: shellServiceBundle,
+      handlers: {
+        ShellService: {
+          setLayout: async (request) => {
+            this._layout = request.layout;
+            this._invitationCode = request.invitationCode;
+            this._spaceKey = request.spaceKey;
+            this.layoutUpdate.emit(request);
+          }
+        }
+      },
+      port: this._port
+    });
+
+    await this._appRpc.open();
+  }
+
+  async close() {
+    await this._appRpc?.close();
+    this._appRpc = undefined;
+  }
+}
+
+export class MemoryShellRuntime implements ShellRuntime {
+  readonly layoutUpdate = new Event<LayoutRequest>();
+  readonly contextUpdate = new Event<AppContextRequest>();
+  private _layout: ShellLayout;
+  private _invitationCode?: string;
+  private _spaceKey?: PublicKey;
+
+  constructor({ layout, invitationCode, spaceKey }: Partial<LayoutRequest> & Partial<AppContextRequest> = {}) {
+    this._layout = layout ?? ShellLayout.DEFAULT;
+    this._invitationCode = invitationCode;
+    this._spaceKey = spaceKey;
+  }
+
+  get layout() {
+    return this._layout;
+  }
+
+  get invitationCode() {
+    return this._invitationCode;
+  }
+
+  get spaceKey() {
+    return this._spaceKey;
+  }
+
+  setLayout(layout: ShellLayout, options: Omit<LayoutRequest, 'layout'> = {}) {
+    this._layout = layout;
+    this._invitationCode = options.invitationCode;
+    this._spaceKey = options.spaceKey;
+    this.layoutUpdate.emit({ layout, ...options });
+  }
+
+  async setAppContext(context: AppContextRequest) {
+    this.contextUpdate.emit(context);
+  }
+}

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

@@ -0,0 +1,76 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { log } from '@dxos/log';
+import { MaybePromise } from '@dxos/util';
+
+enum Message {
+  ACQUIRING = 'acquiring'
+}
+
+export type VaultResourceLockOptions = {
+  lockKey: string;
+  onAcquire?: () => MaybePromise<void>;
+  onRelease?: () => MaybePromise<void>;
+};
+
+export class VaultResourceLock {
+  private readonly _broadcastChannel = new BroadcastChannel('vault-resource-lock');
+  private readonly _lockKey: string;
+  private readonly _onAcquire: VaultResourceLockOptions['onAcquire'];
+  private readonly _onRelease: VaultResourceLockOptions['onRelease'];
+  private _releaseTrigger = new Trigger();
+
+  constructor({ lockKey, onAcquire, onRelease }: VaultResourceLockOptions) {
+    this._lockKey = lockKey;
+    this._onAcquire = onAcquire;
+    this._onRelease = onRelease;
+    this._broadcastChannel.onmessage = this._onMessage.bind(this);
+  }
+
+  async acquire() {
+    this._broadcastChannel.postMessage({
+      message: Message.ACQUIRING
+    });
+
+    try {
+      await asyncTimeout(this._requestLock(), 3_000);
+    } catch {
+      await this._requestLock(true);
+    }
+  }
+
+  async release() {
+    this._releaseTrigger.wake();
+  }
+
+  private _onMessage(event: MessageEvent<any>) {
+    if (event.data.message === Message.ACQUIRING) {
+      this._releaseTrigger.wake();
+    }
+  }
+
+  private async _requestLock(steal = false) {
+    log('requesting lock...', { steal });
+    const acquired = new Trigger();
+
+    void navigator.locks
+      .request(this._lockKey, { steal }, async () => {
+        await this._onAcquire?.();
+        acquired.wake();
+        this._releaseTrigger = new Trigger();
+        await this._releaseTrigger.wait();
+        log('releasing lock...');
+        await this._onRelease?.();
+        log('released lock');
+      })
+      .catch(async () => {
+        await this._onRelease?.();
+      });
+
+    await acquired.wait();
+    log('recieved lock', { steal });
+  }
+}

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

@@ -4,6 +4,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 { RpcPort } from '@dxos/rpc';
@@ -16,6 +17,7 @@ import { WorkerSession } from './worker-session';
 export type CreateSessionParams = {
   appPort: RpcPort;
   systemPort: RpcPort;
+  shellPort: RpcPort;
 };
 
 /**
@@ -37,6 +39,7 @@ export class WorkerRuntime {
   ) { }
 
   async start() {
+    log('starting...');
     try {
       this._config = await this._configProvider();
       const signalServer = this._config.get('runtime.services.signal.server');
@@ -53,8 +56,10 @@ export class WorkerRuntime {
 
       await this._clientServices.open();
       this._ready.wake(undefined);
+      log('started');
     } catch (err: any) {
       this._ready.wake(err);
+      log.catch(err);
     }
   }
 
@@ -66,17 +71,24 @@ export class WorkerRuntime {
   /**
    * Create a new session.
    */
-  async createSession({ appPort, systemPort }: CreateSessionParams) {
+  async createSession({ appPort, systemPort, shellPort }: CreateSessionParams) {
     const session = new WorkerSession({
-      getServices: async () => {
+      getService: async (find) => {
         const error = await this._ready.wait();
-        if (error !== undefined) {
+        if (error) {
           throw error;
         }
-        return this._clientServices;
+
+        const service = find(this._clientServices.services);
+        if (!service) {
+          throw new Error('Service not found');
+        }
+
+        return service;
       },
       appPort,
       systemPort,
+      shellPort,
       readySignal: this._ready
     });