@dxos/client-services 0.1.24 → 0.1.25-next.3c6b542

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

@@ -5,7 +5,7 @@
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
 import { DocumentModel } from '@dxos/document-model';
-import { DataServiceImpl } from '@dxos/echo-db';
+import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';

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

@@ -6,7 +6,7 @@ import { expect } from 'chai';
 
 import { createAdmissionCredentials } from '@dxos/credentials';
 import { DocumentModel } from '@dxos/document-model';
-import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-db';
+import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';

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

@@ -8,15 +8,15 @@ import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { getCredentialAssertion } from '@dxos/credentials';
 import {
-  DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
-  SnapshotStore,
   Space,
   spaceGenesis,
   SpaceManager,
-  SnapshotManager
-} from '@dxos/echo-db';
+  DataServiceSubscriptions,
+  SnapshotManager,
+  SnapshotStore
+} from '@dxos/echo-pipeline';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';

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

@@ -10,10 +10,10 @@ import {
   DataPipelineControllerImpl,
   MetadataStore,
   Space,
-  SnapshotManager,
   SigningContext,
-  createMappedFeedWriter
-} from '@dxos/echo-db';
+  createMappedFeedWriter,
+  SnapshotManager
+} from '@dxos/echo-pipeline';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';

package/src/packlets/spaces/spaces-service.ts

@@ -5,7 +5,7 @@
 import { scheduleTask } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
-import { SpaceManager, SpaceNotFoundError } from '@dxos/echo-db';
+import { SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
 import {
   QueryCredentialsRequest,
   QueryMembersRequest,

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

@@ -5,14 +5,14 @@
 import { Config } from '@dxos/config';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import {
+  SnapshotStore,
   DataPipelineControllerImpl,
   MetadataStore,
   SigningContext,
-  SnapshotStore,
   SpaceManager,
   valueEncoding
-} from '@dxos/echo-db';
-import { testLocalDatabase } from '@dxos/echo-db/testing';
+} 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';

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

@@ -8,15 +8,17 @@ 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 { MaybePromise } from '@dxos/util';
+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: () => MaybePromise<Config>;
+  configProvider: Config | Provider<Promise<Config>>;
   appPort: RpcPort;
+  shellPort?: RpcPort;
 };
 
 /**
@@ -26,7 +28,7 @@ export type IFrameHostRuntimeParams = {
  * This should only be used when SharedWorker is not available.
  */
 export class IFrameHostRuntime {
-  private readonly _configProvider: () => MaybePromise<Config>;
+  private readonly _configProvider: Config | Provider<Promise<Config>>;
   private readonly _transportFactory = createWebRTCTransportFactory();
   private readonly _ready = new Trigger<Error | undefined>();
   private readonly _getService: <Service>(
@@ -34,16 +36,20 @@ export class IFrameHostRuntime {
   ) => Promise<Service>;
 
   private readonly _appPort: RpcPort;
+  private readonly _shellPort?: RpcPort;
+  private _config!: Config;
   private _clientServices!: ClientServicesHost;
   private _clientRpc!: ProtoRpcPeer<ClientServices>;
-  private _config!: Config;
+  private _shellRuntime?: ShellRuntimeImpl;
 
   @logInfo
   public origin?: string;
 
-  constructor({ configProvider, appPort }: IFrameHostRuntimeParams) {
+  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) {
@@ -57,12 +63,24 @@ export class IFrameHostRuntime {
 
       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 this._configProvider();
+      this._config = await getAsyncValue(this._configProvider);
       const signalServer = this._config.get('runtime.services.signal.server');
       this._clientServices = new ClientServicesHost({
         lockKey: LOCK_KEY,
@@ -94,7 +112,7 @@ export class IFrameHostRuntime {
         port: this._appPort
       });
 
-      await Promise.all([this._clientServices.open(), this._clientRpc.open()]);
+      await Promise.all([this._clientServices.open(), this._clientRpc.open(), this._shellRuntime?.open()]);
       this._ready.wake(undefined);
       log('started');
     } catch (err: any) {
@@ -107,6 +125,7 @@ export class IFrameHostRuntime {
     log('stopping...');
     await this._clientRpc.close();
     await this._clientServices.close();
+    await this._shellRuntime?.close();
     log('stopped');
   }
 }

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

@@ -7,12 +7,14 @@ 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 IFrameProxyRuntimeParams = {
   systemPort: RpcPort;
   workerAppPort: RpcPort;
   windowAppPort: RpcPort;
+  shellPort?: RpcPort;
 };
 
 /**
@@ -22,13 +24,16 @@ 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 }: IFrameProxyRuntimeParams) {
+  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 IFrameProxyRuntime {
 
     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

@@ -5,6 +5,8 @@
 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,78 @@
+//
+// 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'> = {}) {
+    log('set layout', { layout, ...options });
+    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/worker-runtime.ts

@@ -17,6 +17,7 @@ import { WorkerSession } from './worker-session';
 export type CreateSessionParams = {
   appPort: RpcPort;
   systemPort: RpcPort;
+  shellPort: RpcPort;
 };
 
 /**
@@ -70,7 +71,7 @@ export class WorkerRuntime {
   /**
    * Create a new session.
    */
-  async createSession({ appPort, systemPort }: CreateSessionParams) {
+  async createSession({ appPort, systemPort, shellPort }: CreateSessionParams) {
     const session = new WorkerSession({
       getService: async (find) => {
         const error = await this._ready.wait();
@@ -87,6 +88,7 @@ export class WorkerRuntime {
       },
       appPort,
       systemPort,
+      shellPort,
       readySignal: this._ready
     });
 

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

@@ -4,7 +4,7 @@
 
 import assert from 'node:assert';
 
-import { Trigger } from '@dxos/async';
+import { asyncTimeout, Trigger } from '@dxos/async';
 import { log, logInfo } from '@dxos/log';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
@@ -17,6 +17,7 @@ export type WorkerSessionParams = {
   getService: <Service>(find: (services: Partial<ClientServices>) => Service | undefined) => Promise<Service>;
   systemPort: RpcPort;
   appPort: RpcPort;
+  shellPort: RpcPort;
   readySignal: Trigger<Error | undefined>;
   options?: {
     heartbeatInterval: number;
@@ -28,6 +29,7 @@ export type WorkerSessionParams = {
  */
 export class WorkerSession {
   private readonly _clientRpc: ProtoRpcPeer<ClientServices>;
+  private readonly _shellClientRpc: ProtoRpcPeer<ClientServices>;
   private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
   private readonly _getService: WorkerSessionParams['getService'];
@@ -45,6 +47,7 @@ export class WorkerSession {
     getService,
     systemPort,
     appPort,
+    shellPort,
     options = {
       heartbeatInterval: 1_000
     }
@@ -54,23 +57,22 @@ export class WorkerSession {
     this._options = options;
     this._getService = getService;
 
-    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: appPort
-    });
+    const 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)
+    };
+
+    this._clientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: appPort });
+    this._shellClientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: shellPort });
 
     this._iframeRpc = createProtoRpcPeer({
       requested: iframeServiceBundle,
@@ -102,7 +104,7 @@ export class WorkerSession {
 
   async open() {
     log.info('opening..');
-    await Promise.all([this._clientRpc.open(), this._iframeRpc.open()]);
+    await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     await this._startTrigger.wait({ timeout: 3_000 });
 
@@ -137,4 +139,12 @@ export class WorkerSession {
 
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
   }
+
+  private async _maybeOpenShell() {
+    try {
+      await asyncTimeout(this._shellClientRpc.open(), 1_000);
+    } catch {
+      log.info('No shell connected.');
+    }
+  }
 }