@dxos/client-services 0.1.26 → 0.1.27-next.a0dff21

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

@@ -0,0 +1,121 @@
+//
+// 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');
+
+    await this._appRpc.rpc.AppService.setContext(context);
+  }
+
+  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,21 @@ 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: () => this._getService((services) => services.DataService),
+      DeviceInvitationsService: () => this._getService((services) => services.DeviceInvitationsService),
+      DevicesService: () => this._getService((services) => services.DevicesService),
+      DevtoolsHost: () => this._getService((services) => services.DevtoolsHost),
+      NetworkService: () => this._getService((services) => services.NetworkService),
+      IdentityService: () => this._getService((services) => services.IdentityService),
+      SpaceInvitationsService: () => this._getService((services) => services.SpaceInvitationsService),
+      SpacesService: () => this._getService((services) => services.SpacesService),
+      SystemService: () => this._getService((services) => services.SystemService),
+      TracingService: () => 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 +103,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 +138,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.');
+    }
+  }
 }