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

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

@@ -2,36 +2,98 @@
 // Copyright 2022 DXOS.org
 //
 
-import { scheduleTask } from '@dxos/async';
+import { EventSubscriptions, scheduleTask } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
-import { raise } from '@dxos/debug';
-import { SpaceManager, SpaceNotFoundError } from '@dxos/echo-db';
+import { raise, todo } from '@dxos/debug';
+import { DataServiceSubscriptions, SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
+import { log } from '@dxos/log';
 import {
   QueryCredentialsRequest,
-  QueryMembersRequest,
-  QueryMembersResponse,
+  QuerySpacesResponse,
   Space,
+  SpaceMember,
   SpacesService,
+  SpaceStatus,
+  UpdateSpaceRequest,
   WriteCredentialsRequest
 } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { humanize, Provider } from '@dxos/util';
+
+import { IdentityManager } from '../identity';
+import { DataSpace } from './data-space';
+import { DataSpaceManager } from './data-space-manager';
 
 /**
  *
  */
 export class SpacesServiceImpl implements SpacesService {
-  constructor(private readonly _spaceManager: SpaceManager) {}
+  constructor(
+    private readonly _identityManager: IdentityManager,
+    private readonly _spaceManager: SpaceManager,
+    private readonly _dataServiceSubscriptions: DataServiceSubscriptions,
+    private readonly _getDataSpaceManager: Provider<Promise<DataSpaceManager>>
+  ) {}
 
   async createSpace(): Promise<Space> {
-    throw new Error();
+    if (!this._identityManager.identity) {
+      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/halo');
+    }
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const space = await dataSpaceManager.createSpace();
+    return this._transformSpace(space);
   }
 
-  querySpaces(): Stream<Space> {
-    throw new Error();
+  async updateSpace(request: UpdateSpaceRequest) {
+    todo();
   }
 
-  queryMembers(query: QueryMembersRequest): Stream<QueryMembersResponse> {
-    throw new Error();
+  querySpaces(): Stream<QuerySpacesResponse> {
+    return new Stream<QuerySpacesResponse>(({ next, ctx }) => {
+      const onUpdate = async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const spaces = Array.from(dataSpaceManager.spaces.values())
+          // Skip spaces without data service available.
+          .filter((space) => this._dataServiceSubscriptions.getDataService(space.key))
+          .map((space) => this._transformSpace(space));
+        log('update', { spaces });
+        next({ spaces });
+      };
+
+      setTimeout(async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const subscriptions = new EventSubscriptions();
+        // TODO(dmaretskyi): Create a pattern for subscribing to a set of objects.
+        const subscribeSpaces = () => {
+          subscriptions.clear();
+
+          for (const space of dataSpaceManager.spaces.values()) {
+            if (!this._dataServiceSubscriptions.getDataService(space.key)) {
+              // Skip spaces without data service available.
+              continue;
+            }
+
+            subscriptions.add(space.stateUpdate.on(ctx, onUpdate));
+            subscriptions.add(space.presence.updated.on(ctx, onUpdate));
+          }
+        };
+
+        dataSpaceManager.updated.on(ctx, () => {
+          subscribeSpaces();
+          void onUpdate();
+        });
+
+        ctx.onDispose(() => subscriptions.clear());
+        scheduleTask(ctx, () => {
+          subscribeSpaces();
+          void onUpdate();
+        });
+      });
+
+      if (!this._identityManager.identity) {
+        next({ spaces: [] });
+      }
+    });
   }
 
   queryCredentials({ spaceKey }: QueryCredentialsRequest): Stream<Credential> {
@@ -54,4 +116,24 @@ export class SpacesServiceImpl implements SpacesService {
       await space.controlPipeline.writer.write({ credential: { credential } });
     }
   }
+
+  private _transformSpace(space: DataSpace): Space {
+    return {
+      spaceKey: space.key,
+      status: space.isOpen ? SpaceStatus.ACTIVE : SpaceStatus.INACTIVE,
+      members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
+        identity: {
+          identityKey: member.key,
+          profile: {
+            displayName: member.assertion.profile?.displayName ?? humanize(member.key)
+          }
+        },
+        presence:
+          this._identityManager.identity?.identityKey.equals(member.key) ||
+          space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key)).length > 0
+            ? SpaceMember.PresenceState.ONLINE
+            : SpaceMember.PresenceState.OFFLINE
+      }))
+    };
+  }
 }

package/src/packlets/system/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './system-service';

package/src/packlets/system/system-service.test.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Event, Trigger } from '@dxos/async';
+import { Config } from '@dxos/config';
+import { SystemStatus, SystemStatusResponse, SystemService } from '@dxos/protocols/proto/dxos/client/services';
+import { beforeEach, describe, test } from '@dxos/test';
+
+import { SystemServiceImpl } from './system-service';
+
+describe('SystemService', () => {
+  let systemService: SystemService;
+  let config: Config;
+  let statusUpdate: Event<void>;
+  let currentStatus: SystemStatus;
+  let updateStatus: Trigger<SystemStatus>;
+  let reset: Trigger<boolean>;
+
+  const changeStatus = (status: SystemStatus) => {
+    currentStatus = status;
+    statusUpdate.emit();
+  };
+
+  beforeEach(() => {
+    config = new Config({ runtime: { client: { log: { filter: 'system-service:debug' } } } });
+    statusUpdate = new Event<void>();
+    currentStatus = SystemStatus.ACTIVE;
+    updateStatus = new Trigger<SystemStatus>();
+    reset = new Trigger<boolean>();
+
+    systemService = new SystemServiceImpl({
+      config,
+      statusUpdate,
+      getCurrentStatus: () => currentStatus,
+      onUpdateStatus: (status) => {
+        updateStatus.wake(status);
+      },
+      onReset: () => {
+        reset.wake(true);
+      }
+    });
+  });
+
+  test('getConfig returns config', async () => {
+    expect(await systemService.getConfig()).to.deep.equal(config.values);
+  });
+
+  test('updateStatus triggers callback', async () => {
+    await systemService.updateStatus({ status: SystemStatus.INACTIVE });
+    const result = await updateStatus.wait();
+    expect(result).to.equal(SystemStatus.INACTIVE);
+  });
+
+  test('queryStatus returns initial status', async () => {
+    const status = new Trigger<SystemStatusResponse>();
+    systemService.queryStatus().subscribe((response) => {
+      status.wake(response);
+    });
+    expect(await status.wait()).to.deep.equal({ status: SystemStatus.ACTIVE });
+  });
+
+  test('queryStatus streams status changes', async () => {
+    const statuses: SystemStatus[] = [];
+    systemService.queryStatus().subscribe(({ status }) => {
+      statuses.push(status);
+    });
+    changeStatus(SystemStatus.INACTIVE);
+    changeStatus(SystemStatus.ACTIVE);
+    expect(statuses).to.deep.equal([SystemStatus.ACTIVE, SystemStatus.INACTIVE, SystemStatus.ACTIVE]);
+  });
+
+  test('reset triggers callback', async () => {
+    await systemService.reset();
+    const result = await reset.wait();
+    expect(result).to.be.true;
+  });
+});

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

@@ -0,0 +1,70 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { Config } from '@dxos/config';
+import {
+  SystemStatus,
+  SystemStatusResponse,
+  SystemService,
+  UpdateSystemStatusRequest
+} from '@dxos/protocols/proto/dxos/client/services';
+import { MaybePromise } from '@dxos/util';
+
+export type SystemServiceOptions = {
+  config: Config;
+  statusUpdate: Event<void>;
+  getCurrentStatus: () => SystemStatus;
+  onUpdateStatus: (status: SystemStatus) => MaybePromise<void>;
+  onReset: () => MaybePromise<void>;
+};
+
+/**
+ *
+ */
+export class SystemServiceImpl implements SystemService {
+  private readonly _config: SystemServiceOptions['config'];
+  private readonly _statusUpdate: SystemServiceOptions['statusUpdate'];
+  private readonly _getCurrentStatus: SystemServiceOptions['getCurrentStatus'];
+  private readonly _onUpdateStatus: SystemServiceOptions['onUpdateStatus'];
+  private readonly _onReset: SystemServiceOptions['onReset'];
+
+  constructor({ config, statusUpdate, onUpdateStatus, getCurrentStatus, onReset }: SystemServiceOptions) {
+    this._config = config;
+    this._statusUpdate = statusUpdate;
+    this._getCurrentStatus = getCurrentStatus;
+    this._onUpdateStatus = onUpdateStatus;
+    this._onReset = onReset;
+  }
+
+  async getConfig() {
+    return this._config.values;
+  }
+
+  async updateStatus({ status }: UpdateSystemStatusRequest) {
+    await this._onUpdateStatus(status);
+  }
+
+  queryStatus(): Stream<SystemStatusResponse> {
+    return new Stream(({ next }) => {
+      const update = () => {
+        next({ status: this._getCurrentStatus() });
+      };
+
+      update();
+      const unsubscribe = this._statusUpdate.on(() => update());
+      const interval = setInterval(update, 3000);
+
+      return () => {
+        clearInterval(interval);
+        unsubscribe();
+      };
+    });
+  }
+
+  async reset() {
+    await this._onReset();
+  }
+}

package/src/packlets/testing/index.ts

@@ -3,5 +3,5 @@
 //
 
 export * from './credential-utils';
-export * from './test-builder';
 export * from './invitation-utils';
+export * from './test-builder';

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,
@@ -80,13 +98,12 @@ export class IFrameHostRuntime {
         exposed: clientServiceBundle,
         handlers: {
           DataService: async () => await this._getService((services) => services.DataService),
+          DeviceInvitationsService: async () => await this._getService((services) => services.DeviceInvitationsService),
           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),
+          IdentityService: async () => await this._getService((services) => services.IdentityService),
           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)
@@ -94,7 +111,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 +124,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,56 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+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;
+
+  constructor(private readonly _port: RpcPort) {}
+
+  get display() {
+    return this._display;
+  }
+
+  async setLayout(layout: ShellLayout, options: Omit<LayoutRequest, 'layout'> = {}) {
+    log('set layout', { layout, ...options });
+    this._display = ShellDisplay.FULLSCREEN;
+    this.contextUpdate.emit({ display: this._display });
+    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.contextUpdate.emit(request);
+          }
+        }
+      },
+      port: this._port
+    });
+
+    await this._shellRpc.open();
+  }
+
+  async close() {
+    await this._shellRpc?.close();
+    this._shellRpc = undefined;
+  }
+}