@dxos/client-services 0.3.11-main.3f845e1 → 0.3.11-main.463e5cd

package/src/packlets/services/platform.ts

@@ -2,20 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-export type Platform = {
-  type: 'browser' | 'shared-worker' | 'node';
-  userAgent?: string;
-  platform?: string;
-  runtime?: string;
-  uptime?: number;
-  memory?: {
-    rss: number;
-    heapTotal: number;
-    heapUsed: number;
-    external: number;
-    arrayBuffers: number;
-  };
-};
+import { Platform } from '@dxos/protocols/proto/dxos/client/services';
 
 export const getPlatform = (): Platform => {
   if ((process as any).browser) {
@@ -23,14 +10,14 @@ export const getPlatform = (): Platform => {
       // Browser.
       const { userAgent } = window.navigator;
       return {
-        type: 'browser',
+        type: Platform.PLATFORM_TYPE.BROWSER,
         userAgent,
         uptime: Math.floor((Date.now() - window.performance.timeOrigin) / 1_000),
       };
     } else {
       // Shared worker.
       return {
-        type: 'shared-worker',
+        type: Platform.PLATFORM_TYPE.SHARED_WORKER,
         uptime: Math.floor((Date.now() - performance.timeOrigin) / 1_000),
       };
     }
@@ -38,9 +25,10 @@ export const getPlatform = (): Platform => {
     // Node.
     const { platform, version, arch } = process;
     return {
-      type: 'node',
-      platform: `${platform} ${version} ${arch}`,
-      runtime: process.version,
+      type: Platform.PLATFORM_TYPE.NODE,
+      platform,
+      arch,
+      runtime: version,
       uptime: Math.floor(process.uptime()),
       memory: process.memoryUsage(),
     };

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

@@ -8,7 +8,7 @@ import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
-import { type TypedObject, base } from '@dxos/echo-schema';
+import { type TypedObject, base, getRawDoc } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -28,7 +28,7 @@ import { ServiceContext } from './service-context';
 import { ServiceRegistry } from './service-registry';
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
-import { type CreateIdentityOptions, IdentityServiceImpl } from '../identity';
+import { IdentityServiceImpl, type CreateIdentityOptions } from '../identity';
 import { InvitationsServiceImpl } from '../invitations';
 import { Lock, type ResourceLock } from '../locks';
 import { LoggingServiceImpl } from '../logging';
@@ -260,7 +260,7 @@ export class ClientServicesHost {
       SystemService: this._systemService,
 
       IdentityService: new IdentityServiceImpl(
-        (params) => this._createIdentity(params),
+        (params, useAutomerge) => this._createIdentity(params, useAutomerge),
         this._serviceContext.identityManager,
         this._serviceContext.keyring,
         (profile) => this._serviceContext.broadcastProfileUpdate(profile),
@@ -351,21 +351,36 @@ export class ClientServicesHost {
     await this._callbacks?.onReset?.();
   }
 
-  private async _createIdentity(params?: CreateIdentityOptions) {
+  private async _createIdentity(params: CreateIdentityOptions, useAutomerge: boolean) {
     const identity = await this._serviceContext.createIdentity(params);
 
     // Setup default space.
     await this._serviceContext.initialized.wait();
     const space = await this._serviceContext.dataSpaceManager!.createSpace();
-    const obj: TypedObject = new Properties(undefined, { automerge: false });
+
+    const obj: TypedObject = new Properties(undefined, { automerge: useAutomerge });
     obj[defaultKey] = identity.identityKey.toHex();
-    await this._serviceRegistry.services.DataService!.write({
-      spaceKey: space.key,
-      batch: {
-        objects: [createGenesisMutationFromTypedObject(obj)],
-      },
-    });
-    await this._serviceRegistry.services.DataService!.flush({ spaceKey: space.key });
+
+    if (!useAutomerge) {
+      await this._serviceRegistry.services.DataService!.write({
+        spaceKey: space.key,
+        batch: {
+          objects: [createGenesisMutationFromTypedObject(obj)],
+        },
+      });
+      await this._serviceRegistry.services.DataService!.flush({ spaceKey: space.key });
+    } else {
+      // TODO(dmaretskyi): Refactor this.
+      const automergeIndex = space.automergeSpaceState.rootUrl;
+      invariant(automergeIndex);
+      const document = await this._serviceContext.automergeHost.repo.find(automergeIndex as any);
+      await document.whenReady();
+
+      document.change((doc: any) => {
+        doc.objects ??= {};
+        doc.objects[obj[base]._id] = getRawDoc(obj).handle.docSync();
+      });
+    }
 
     return identity;
   }

package/src/packlets/spaces/automerge-space-state.ts

@@ -9,6 +9,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
   public rootUrl: string | undefined = undefined;
   public lastEpoch: SpecificCredential<Epoch> | undefined = undefined;
 
+  constructor(private readonly _onNewRoot: (rootUrl: string) => void) {}
+
   async processCredential(credential: Credential) {
     if (!checkCredentialType(credential, 'dxos.halo.credentials.Epoch')) {
       return;
@@ -17,6 +19,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
     this.lastEpoch = credential;
     if (credential.subject.assertion.automergeRoot) {
       this.rootUrl = credential.subject.assertion.automergeRoot;
+
+      this._onNewRoot(this.rootUrl);
     }
   }
 }

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

@@ -143,6 +143,9 @@ export class DataSpaceManager {
     const space = await this._constructSpace(metadata);
 
     const automergeRoot = this._automergeHost.repo.create();
+    automergeRoot.change((doc: any) => {
+      doc.experimental_spaceKey = spaceKey.toHex();
+    });
 
     const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, automergeRoot.url);
     await this._metadataStore.addSpace(metadata);
@@ -222,12 +225,13 @@ export class DataSpaceManager {
         credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
-      onNetworkConnection: (session) => {
+      onAuthorizedConnection: (session) => {
         session.addExtension(
           'dxos.mesh.teleport.gossip',
           gossip.createExtension({ remotePeerId: session.remotePeerId }),
         );
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
+        this._automergeHost.authorizeDevice(space.key, session.remotePeerId);
         session.addExtension('dxos.mesh.teleport.automerge', this._automergeHost.createExtension());
       },
       onAuthFailure: () => {

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

@@ -2,9 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
+import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
-import { cancelWithContext, Context } from '@dxos/context';
+import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed } from '@dxos/debug';
 import {
   type MetadataStore,
@@ -15,6 +15,7 @@ import {
   type AutomergeHost,
 } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
+import { failedInvariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -77,9 +78,12 @@ export type DataSpaceParams = {
 const ENABLE_FEED_PURGE = false;
 
 @trackLeaks('open', 'close')
+@trace.resource()
 export class DataSpace {
   private _ctx = new Context();
+  @trace.info()
   private readonly _inner: Space;
+
   private readonly _gossip: Gossip;
   private readonly _presence: Presence;
   private readonly _keyring: Keyring;
@@ -92,7 +96,7 @@ export class DataSpace {
   private readonly _automergeHost: AutomergeHost;
 
   // TODO(dmaretskyi): Move into Space?
-  private readonly _automergeSpaceState = new AutomergeSpaceState();
+  private readonly _automergeSpaceState = new AutomergeSpaceState((rootUrl) => this._onNewAutomergeRoot(rootUrl));
 
   private _state = SpaceState.CLOSED;
 
@@ -137,6 +141,7 @@ export class DataSpace {
     log('new state', { state: SpaceState[this._state] });
   }
 
+  @trace.info()
   get key() {
     return this._inner.key;
   }
@@ -145,6 +150,7 @@ export class DataSpace {
     return this._inner.isOpen;
   }
 
+  @trace.info({ enum: SpaceState })
   get state(): SpaceState {
     return this._state;
   }
@@ -174,6 +180,14 @@ export class DataSpace {
     return this._automergeSpaceState;
   }
 
+  @trace.info({ depth: null })
+  private get _automergeInfo() {
+    return {
+      rootUrl: this._automergeSpaceState.rootUrl,
+      lastEpoch: this._automergeSpaceState.lastEpoch,
+    };
+  }
+
   @synchronized
   async open() {
     await this._open();
@@ -232,7 +246,7 @@ export class DataSpace {
         this.metrics.pipelineInitBegin = new Date();
         await this.initializeDataPipeline();
       } catch (err) {
-        if (err instanceof CancelledError) {
+        if (err instanceof CancelledError || err instanceof ContextDisposedError) {
           log('data pipeline initialization cancelled', err);
           return;
         }
@@ -363,6 +377,25 @@ export class DataSpace {
     }
   }
 
+  private _onNewAutomergeRoot(rootUrl: string) {
+    log('loading automerge root doc for space', { space: this.key, rootUrl });
+    const handle = this._automergeHost.repo.find(rootUrl as any);
+
+    queueMicrotask(async () => {
+      try {
+        await asyncTimeout(handle.whenReady(), 5_000);
+        const doc = handle.docSync() ?? failedInvariant();
+        if (!doc.experimental_spaceKey) {
+          handle.change((doc: any) => {
+            doc.experimental_spaceKey = this.key.toHex();
+          });
+        }
+      } catch (err) {
+        log.warn('error loading automerge root doc', { space: this.key, rootUrl, err });
+      }
+    });
+  }
+
   // TODO(dmaretskyi): Use profile from signing context.
   async updateOwnProfile(profile: ProfileDocument) {
     const credential = await this._signingContext.credentialSigner.createCredential({

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

@@ -41,7 +41,7 @@ export class SpacesServiceImpl implements SpacesService {
 
   async createSpace(): Promise<Space> {
     if (!this._identityManager.identity) {
-      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/halo');
+      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo');
     }
 
     const dataSpaceManager = await this._getDataSpaceManager();
@@ -222,8 +222,8 @@ export class SpacesServiceImpl implements SpacesService {
           presence: member.removed
             ? SpaceMember.PresenceState.REMOVED
             : isMe || peers.length > 0
-            ? SpaceMember.PresenceState.ONLINE
-            : SpaceMember.PresenceState.OFFLINE,
+              ? SpaceMember.PresenceState.ONLINE
+              : SpaceMember.PresenceState.OFFLINE,
           peerStates: peers,
         };
       }),

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

@@ -12,16 +12,18 @@ import {
   type UpdateStatusRequest,
   type QueryStatusRequest,
   type QueryStatusResponse,
+  type Platform,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { jsonKeyReplacer, type MaybePromise } from '@dxos/util';
 
 import { type Diagnostics } from '../services';
+import { getPlatform } from '../services/platform';
 
 export type SystemServiceOptions = {
   config?: Config;
   statusUpdate: Event<void>;
   getCurrentStatus: () => SystemStatus;
-  getDiagnostics: () => Promise<Partial<Diagnostics>>;
+  getDiagnostics: () => Promise<Partial<Diagnostics['services']>>;
   onUpdateStatus: (status: SystemStatus) => MaybePromise<void>;
   onReset: () => MaybePromise<void>;
 };
@@ -73,6 +75,10 @@ export class SystemServiceImpl implements SystemService {
     };
   }
 
+  async getPlatform(): Promise<Platform> {
+    return getPlatform();
+  }
+
   async updateStatus({ status }: UpdateStatusRequest) {
     await this._onUpdateStatus(status);
   }

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

@@ -3,7 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
-import { type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
+import { InvitationEncoder, type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
 import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
@@ -13,15 +13,7 @@ import { ServiceContext } from '../services';
  * Strip secrets from invitation before giving it to the peer.
  */
 export const sanitizeInvitation = (invitation: Invitation): Invitation => {
-  return {
-    invitationId: invitation.invitationId,
-    type: invitation.type,
-    kind: invitation.kind,
-    authMethod: invitation.authMethod,
-    swarmKey: invitation.swarmKey,
-    state: invitation.state,
-    timeout: invitation.timeout,
-  };
+  return InvitationEncoder.decode(InvitationEncoder.encode(invitation));
 };
 
 export type InvitationHost = {

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

@@ -30,6 +30,8 @@ export type IFrameHostRuntimeParams = {
  *
  * 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.
+ *
+ * @deprecated
  */
 export class IFrameHostRuntime {
   private readonly _configProvider: IFrameHostRuntimeParams['config'];

package/src/packlets/vault/index.ts

@@ -3,7 +3,7 @@
 //
 
 export * from './iframe-host-runtime';
-export * from './iframe-proxy-runtime';
+export * from './shared-worker-connection';
 export * from './shell-runtime';
 export * from './worker-runtime';
 export * from './worker-session';

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

@@ -20,18 +20,21 @@ import { getAsyncValue, type MaybePromise, type Provider } from '@dxos/util';
 import { 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 = {
+export type SharedWorkerConnectionOptions = {
   config: Config | Provider<MaybePromise<Config>>;
   systemPort: RpcPort;
+  /**
+   * @deprecated Only used with iframes.
+   */
   shellPort?: RpcPort;
 };
 
 /**
  * Manages the client connection to the shared worker.
  */
-export class IFrameProxyRuntime {
+export class SharedWorkerConnection {
   private readonly _id = String(Math.floor(Math.random() * 1000000));
-  private readonly _configProvider: IFrameProxyRuntimeParams['config'];
+  private readonly _configProvider: SharedWorkerConnectionOptions['config'];
   private readonly _systemPort: RpcPort;
   private readonly _shellPort?: RpcPort;
   private _release = new Trigger();
@@ -40,7 +43,7 @@ export class IFrameProxyRuntime {
   private _systemRpc!: ProtoRpcPeer<WorkerServiceBundle>;
   private _shellRuntime?: ShellRuntimeImpl;
 
-  constructor({ config, systemPort, shellPort }: IFrameProxyRuntimeParams) {
+  constructor({ config, systemPort, shellPort }: SharedWorkerConnectionOptions) {
     this._configProvider = config;
     this._systemPort = systemPort;
     this._shellPort = shellPort;
@@ -54,7 +57,12 @@ export class IFrameProxyRuntime {
     return this._shellRuntime;
   }
 
-  async open(origin: string) {
+  async open(
+    /**
+     * @deprecated Only used with iframes.
+     */
+    origin: string,
+  ) {
     this._config = await getAsyncValue(this._configProvider);
 
     this._transportService = new SimplePeerTransportService({
@@ -96,7 +104,11 @@ export class IFrameProxyRuntime {
   async close() {
     this._release.wake();
     await this._shellRuntime?.close();
-    await this._systemRpc.rpc.WorkerService.stop();
+    try {
+      await this._systemRpc.rpc.WorkerService.stop();
+    } catch {
+      // If this fails, the worker is probably already gone.
+    }
     await this._systemRpc.close();
   }
 

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

@@ -18,7 +18,13 @@ import { ClientServicesHost } from '../services';
 export type CreateSessionParams = {
   appPort: RpcPort;
   systemPort: RpcPort;
-  shellPort: RpcPort;
+  shellPort?: RpcPort;
+};
+
+export type WorkerRuntimeCallbacks = {
+  acquireLock: () => Promise<void>;
+  releaseLock: () => void;
+  onReset: () => Promise<void>;
 };
 
 /**
@@ -27,6 +33,8 @@ export type CreateSessionParams = {
  * Tabs make requests to the `ClientServicesHost`, and provide a WebRTC gateway.
  */
 export class WorkerRuntime {
+  private readonly _acquireLock: () => Promise<void>;
+  private readonly _releaseLock: () => void;
   private readonly _transportFactory = new SimplePeerTransportProxyFactory();
   private readonly _ready = new Trigger<Error | undefined>();
   private readonly _sessions = new Set<WorkerSession>();
@@ -34,12 +42,15 @@ export class WorkerRuntime {
   private _sessionForNetworking?: WorkerSession; // TODO(burdon): Expose to client QueryStatusResponse.
   private _config!: Config;
 
-  constructor(private readonly _configProvider: () => MaybePromise<Config>) {
+  constructor(
+    private readonly _configProvider: () => MaybePromise<Config>,
+    { acquireLock, releaseLock, onReset }: WorkerRuntimeCallbacks,
+  ) {
+    this._acquireLock = acquireLock;
+    this._releaseLock = releaseLock;
     this._clientServices = new ClientServicesHost({
       callbacks: {
-        onReset: async () => {
-          self.close();
-        },
+        onReset: async () => onReset(),
       },
     });
   }
@@ -51,6 +62,7 @@ export class WorkerRuntime {
   async start() {
     log('starting...');
     try {
+      await this._acquireLock();
       this._config = await this._configProvider();
       const signals = this._config.get('runtime.services.signaling');
       this._clientServices.initialize({
@@ -71,7 +83,8 @@ export class WorkerRuntime {
   }
 
   async stop() {
-    // TODO(dmaretskyi): Terminate active sessions.
+    // Release the lock to notify remote clients that the worker is terminating.
+    this._releaseLock();
     await this._clientServices.close();
   }
 
@@ -87,10 +100,15 @@ export class WorkerRuntime {
       readySignal: this._ready,
     });
 
-    // When tab is closed.
+    // When tab is closed or client is destroyed.
     session.onClose.set(async () => {
       this._sessions.delete(session);
-      this._reconnectWebrtc();
+      if (this._sessions.size === 0) {
+        // Terminate the worker when all sessions are closed.
+        self.close();
+      } else {
+        this._reconnectWebrtc();
+      }
     });
 
     await session.open();
@@ -100,7 +118,7 @@ export class WorkerRuntime {
   }
 
   /**
-   * Selects one of the existing session fro WebRTC networking.
+   * Selects one of the existing session for WebRTC networking.
    */
   private _reconnectWebrtc() {
     log('reconnecting webrtc...');

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

@@ -21,7 +21,8 @@ export type WorkerSessionParams = {
   serviceHost: ClientServicesHost;
   systemPort: RpcPort;
   appPort: RpcPort;
-  shellPort: RpcPort;
+  // TODO(wittjosiah): Remove shellPort.
+  shellPort?: RpcPort;
   readySignal: Trigger<Error | undefined>;
 };
 
@@ -30,7 +31,7 @@ export type WorkerSessionParams = {
  */
 export class WorkerSession {
   private readonly _clientRpc: ClientRpcServer;
-  private readonly _shellClientRpc: ClientRpcServer;
+  private readonly _shellClientRpc?: ClientRpcServer;
   private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
   private readonly _serviceHost: ClientServicesHost;
@@ -74,11 +75,13 @@ export class WorkerSession {
       ...middleware,
     });
 
-    this._shellClientRpc = new ClientRpcServer({
-      serviceRegistry: this._serviceHost.serviceRegistry,
-      port: shellPort,
-      ...middleware,
-    });
+    this._shellClientRpc = shellPort
+      ? new ClientRpcServer({
+          serviceRegistry: this._serviceHost.serviceRegistry,
+          port: shellPort,
+          ...middleware,
+        })
+      : undefined;
 
     this._iframeRpc = createProtoRpcPeer({
       requested: iframeServiceBundle,
@@ -138,7 +141,7 @@ export class WorkerSession {
 
   private async _maybeOpenShell() {
     try {
-      await asyncTimeout(this._shellClientRpc.open(), 1_000);
+      this._shellClientRpc && (await asyncTimeout(this._shellClientRpc.open(), 1_000));
     } catch {
       log.info('No shell connected.');
     }

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.3.11-main.3f845e1";
+export const DXOS_VERSION = "0.3.11-main.463e5cd";