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

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

@@ -0,0 +1,28 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { createCredential } from '@dxos/credentials';
+import { Signer } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+export const createMockCredential = async ({
+  signer,
+  issuer
+}: {
+  signer: Signer;
+  issuer: PublicKey;
+}): Promise<Credential> =>
+  createCredential({
+    signer,
+    issuer,
+    subject: new PublicKey(Buffer.from('test')),
+    assertion: {
+      '@type': 'example.testing.rpc.MessageWithAny',
+      payload: {
+        '@type': 'google.protobuf.Any',
+        value: Buffer.from('test')
+      }
+    }
+  });

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,10 +2,19 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
-
 import { Config } from '@dxos/config';
-import { ISpace } from '@dxos/echo-db';
+import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
+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';
 import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
 import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
@@ -63,18 +72,91 @@ 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);
+export const syncItems = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
+};
+
+export class TestBuilder {
+  public readonly signalContext = new MemorySignalManagerContext();
+
+  createPeer(): TestPeer {
+    return new TestPeer(this.signalContext);
+  }
+}
+
+export type TestPeerProps = {
+  storage?: Storage;
+  feedStore?: FeedStore<any>;
+  metadataStore?: MetadataStore;
+  keyring?: Keyring;
+  networkManager?: NetworkManager;
+  spaceManager?: SpaceManager;
+  snapshotStore?: SnapshotStore;
+};
+
+export class TestPeer {
+  private _props: TestPeerProps = {};
+
+  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+
+  get storage() {
+    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
   }
 
-  {
-    // 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);
+  get keyring() {
+    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
   }
+
+  get feedStore() {
+    return (this._props.feedStore ??= new FeedStore({
+      factory: new FeedFactory({
+        root: this.storage.createDirectory('feeds'),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding
+        }
+      })
+    }));
+  }
+
+  get metadataStore() {
+    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  }
+
+  get snapshotStore() {
+    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  }
+
+  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
+    }));
+  }
+}
+
+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

@@ -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);
+  }
+}