@dxos/client-services 0.4.7-main.731b147 → 0.4.7-main.772b4a3

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

@@ -4,8 +4,9 @@
 
 import { EventSubscriptions } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
+import { invariant } from '@dxos/invariant';
 import {
-  type Device,
+  Device,
   DeviceKind,
   type DevicesService,
   type QueryDevicesResponse,
@@ -28,27 +29,62 @@ export class DevicesServiceImpl implements DevicesService {
         if (!deviceKeys) {
           next({ devices: [] });
         } else {
+          invariant(this._identityManager.identity?.presence, 'presence not present');
+          const peers = this._identityManager.identity.presence.getPeersOnline();
           next({
-            devices: Array.from(deviceKeys.entries()).map(([key, profile]) => ({
-              deviceKey: key,
-              kind: this._identityManager.identity?.deviceKey.equals(key) ? DeviceKind.CURRENT : DeviceKind.TRUSTED,
-              profile,
-            })),
+            devices: Array.from(deviceKeys.entries()).map(([key, profile]) => {
+              const isMe = this._identityManager.identity?.deviceKey.equals(key);
+              const peerState = peers.find((peer) => peer.identityKey.equals(key));
+
+              return {
+                deviceKey: key,
+                kind: this._identityManager.identity?.deviceKey.equals(key) ? DeviceKind.CURRENT : DeviceKind.TRUSTED,
+                profile,
+                presence: isMe
+                  ? Device.PresenceState.ONLINE
+                  : peerState
+                    ? Device.PresenceState.ONLINE
+                    : Device.PresenceState.OFFLINE,
+              };
+            }),
+          });
+        }
+      };
+
+      let identitySubscribed = false;
+      let presenceSubscribed = false;
+      const subscribeIdentity = () => {
+        if (!identitySubscribed) {
+          this._identityManager.identity?.stateUpdate.on(() => {
+            update();
           });
+          identitySubscribed = true;
+        }
+      };
+
+      const subscribePresence = () => {
+        if (!presenceSubscribed) {
+          this._identityManager.identity?.presence?.updated.on(() => {
+            update();
+          });
+          presenceSubscribed = true;
         }
       };
 
       const subscriptions = new EventSubscriptions();
+
+      if (this._identityManager.identity) {
+        subscribeIdentity();
+        subscribePresence();
+      }
+
       subscriptions.add(
         this._identityManager.stateUpdate.on(() => {
           update();
 
           if (this._identityManager.identity) {
-            subscriptions.add(
-              this._identityManager.identity.stateUpdate.on(() => {
-                update();
-              }),
-            );
+            subscribeIdentity();
+            subscribePresence();
           }
         }),
       );

package/src/packlets/identity/identity-manager.ts

@@ -13,7 +13,7 @@ import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
-import { type Device, DeviceKind } from '@dxos/protocols/proto/dxos/client/services';
+import { Device, DeviceKind } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type IdentityRecord, type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import {
@@ -22,6 +22,7 @@ import {
   DeviceType,
   type ProfileDocument,
 } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { trace as Trace } from '@dxos/tracing';
 import { isNode, deferFunction } from '@dxos/util';
@@ -29,10 +30,14 @@ import { isNode, deferFunction } from '@dxos/util';
 import { createAuthProvider } from './authenticator';
 import { Identity } from './identity';
 
+const DEVICE_PRESENCE_ANNOUNCE_INTERVAL = 10_000;
+const DEVICE_PRESENCE_OFFLINE_TIMEOUT = 20_000;
+
 interface ConstructSpaceParams {
   spaceRecord: SpaceMetadata;
   swarmIdentity: SwarmIdentity;
   identityKey: PublicKey;
+  gossip: Gossip;
 }
 
 export type JoinIdentityParams = {
@@ -58,12 +63,19 @@ export type CreateIdentityOptions = {
   deviceProfile?: DeviceProfileDocument;
 };
 
+export type IdentityManagerRuntimeParams = {
+  devicePresenceAnnounceInterval?: number;
+  devicePresenceOfflineTimeout?: number;
+};
+
 // TODO(dmaretskyi): Rename: represents the peer's state machine.
 @Trace.resource()
 export class IdentityManager {
   readonly stateUpdate = new Event();
 
   private _identity?: Identity;
+  private readonly _devicePresenceAnnounceInterval: number;
+  private readonly _devicePresenceOfflineTimeout: number;
 
   // TODO(burdon): IdentityManagerParams.
   // TODO(dmaretskyi): Perhaps this should take/generate the peerKey outside of an initialized identity.
@@ -72,7 +84,15 @@ export class IdentityManager {
     private readonly _keyring: Keyring,
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _spaceManager: SpaceManager,
-  ) {}
+    params?: IdentityManagerRuntimeParams,
+  ) {
+    const {
+      devicePresenceAnnounceInterval = DEVICE_PRESENCE_ANNOUNCE_INTERVAL,
+      devicePresenceOfflineTimeout = DEVICE_PRESENCE_OFFLINE_TIMEOUT,
+    } = params ?? {};
+    this._devicePresenceAnnounceInterval = devicePresenceAnnounceInterval;
+    this._devicePresenceOfflineTimeout = devicePresenceOfflineTimeout;
+  }
 
   get identity() {
     return this._identity;
@@ -284,13 +304,28 @@ export class IdentityManager {
     const receipt = await this._identity.controlPipeline.writer.write({ credential: { credential } });
     await this._identity.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
     this.stateUpdate.emit();
-    return { deviceKey: this._identity.deviceKey, kind: DeviceKind.CURRENT, profile };
+    return {
+      deviceKey: this._identity.deviceKey,
+      kind: DeviceKind.CURRENT,
+      presence: Device.PresenceState.ONLINE,
+      profile,
+    };
   }
 
   private async _constructIdentity(identityRecord: IdentityRecord) {
     invariant(!this._identity);
     log('constructing identity', { identityRecord });
 
+    const gossip = new Gossip({
+      localPeerId: identityRecord.deviceKey,
+    });
+    const presence = new Presence({
+      announceInterval: this._devicePresenceAnnounceInterval,
+      offlineTimeout: this._devicePresenceOfflineTimeout,
+      identityKey: identityRecord.deviceKey,
+      gossip,
+    });
+
     // Must be created before the space so the feeds are writable.
     invariant(identityRecord.haloSpace.controlFeedKey);
     const controlFeed = await this._feedStore.openFeed(identityRecord.haloSpace.controlFeedKey, {
@@ -309,13 +344,15 @@ export class IdentityManager {
         credentialProvider: createAuthProvider(createCredentialSignerWithKey(this._keyring, identityRecord.deviceKey)),
         credentialAuthenticator: deferFunction(() => identity.authVerifier.verifier),
       },
+      gossip,
       identityKey: identityRecord.identityKey,
     });
     await space.setControlFeed(controlFeed);
-    space.setDataFeed(dataFeed);
+    void space.setDataFeed(dataFeed); // TODO(dmaretskyi): Should this be awaited?
 
     const identity: Identity = new Identity({
       space,
+      presence,
       signer: this._keyring,
       identityKey: identityRecord.identityKey,
       deviceKey: identityRecord.deviceKey,
@@ -331,14 +368,19 @@ export class IdentityManager {
     return identity;
   }
 
-  private async _constructSpace({ spaceRecord, swarmIdentity, identityKey }: ConstructSpaceParams) {
+  private async _constructSpace({ spaceRecord, swarmIdentity, identityKey, gossip }: ConstructSpaceParams) {
     return this._spaceManager.constructSpace({
       metadata: {
         key: spaceRecord.key,
         genesisFeedKey: spaceRecord.genesisFeedKey,
       },
       swarmIdentity,
-      onAuthorizedConnection: () => {},
+      onAuthorizedConnection: (session) => {
+        session.addExtension(
+          'dxos.mesh.teleport.gossip',
+          gossip.createExtension({ remotePeerId: session.remotePeerId }),
+        );
+      },
       onAuthFailure: () => {
         log.warn('auth failure');
       },

package/src/packlets/identity/identity.ts

@@ -25,6 +25,7 @@ import {
   type ProfileDocument,
 } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DeviceAdmissionRequest } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { type Presence } from '@dxos/teleport-extension-gossip';
 import { trace } from '@dxos/tracing';
 import { type ComplexMap, ComplexSet } from '@dxos/util';
 
@@ -35,6 +36,7 @@ export type IdentityParams = {
   deviceKey: PublicKey;
   signer: Signer;
   space: Space;
+  presence?: Presence;
 };
 
 /**
@@ -44,6 +46,7 @@ export type IdentityParams = {
 export class Identity {
   public readonly space: Space;
   private readonly _signer: Signer;
+  private readonly _presence?: Presence;
   private readonly _deviceStateMachine: DeviceStateMachine;
   private readonly _profileStateMachine: ProfileStateMachine;
   public readonly authVerifier: TrustedKeySetAuthVerifier;
@@ -53,9 +56,10 @@ export class Identity {
 
   public readonly stateUpdate = new Event();
 
-  constructor({ space, signer, identityKey, deviceKey }: IdentityParams) {
+  constructor({ space, signer, identityKey, deviceKey, presence }: IdentityParams) {
     this.space = space;
     this._signer = signer;
+    this._presence = presence;
 
     this.identityKey = identityKey;
     this.deviceKey = deviceKey;
@@ -128,6 +132,10 @@ export class Identity {
     return this._deviceStateMachine.deviceCredentialChain;
   }
 
+  get presence() {
+    return this._presence;
+  }
+
   /**
    * Issues credentials as identity.
    * Requires identity to be ready.

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

@@ -4,6 +4,7 @@
 
 import { Event } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/keys';
 import {
   type LogLevel,
   type LogProcessor,
@@ -21,14 +22,15 @@ import {
   type QueryMetricsRequest,
   type QueryMetricsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
-import { jsonify, numericalValues, tracer } from '@dxos/util';
+import { getDebugName, jsonify, numericalValues, tracer } from '@dxos/util';
 
 /**
  * Logging service used to spy on logs of the host.
  */
 export class LoggingServiceImpl implements LoggingService {
   private readonly _logs = new Event<NaturalLogEntry>();
-  private readonly _started = new Date();
+  private readonly _started = Date.now();
+  private readonly _sessionId = PublicKey.random().toHex();
 
   async open() {
     log.runtimeConfig.processors.push(this._logProcessor);
@@ -116,6 +118,11 @@ export class LoggingServiceImpl implements LoggingService {
             // TODO(dmaretskyi): Fix proto.
             file: entry.meta?.F ?? '',
             line: entry.meta?.L ?? 0,
+            scope: {
+              hostSessionId: this._sessionId,
+              uptimeSeconds: (Date.now() - this._started) / 1000,
+              name: getDebugName(entry.meta?.S),
+            },
           },
         };
 

package/src/packlets/services/automerge-host.test.ts

@@ -21,7 +21,7 @@ describe('AutomergeHost', () => {
 
     const storageDirectory = createStorage({ type: StorageType.RAM }).createDirectory();
 
-    const host = new AutomergeHost(storageDirectory);
+    const host = new AutomergeHost({ directory: storageDirectory });
     afterTest(() => host.close());
     const dataService = new DataServiceImpl(
       {} as DataServiceSubscriptions, // is not used in this test, just required argument

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

@@ -14,6 +14,7 @@ import {
   SnapshotStore,
   AutomergeHost,
 } from '@dxos/echo-pipeline';
+import { IndexMetadataStore } from '@dxos/echo-schema';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
@@ -31,15 +32,21 @@ import { BlobStore } from '@dxos/teleport-extension-object-sync';
 import { trace as Trace } from '@dxos/tracing';
 import { safeInstanceof } from '@dxos/util';
 
-import { type CreateIdentityOptions, IdentityManager, type JoinIdentityParams } from '../identity';
+import {
+  type CreateIdentityOptions,
+  IdentityManager,
+  type IdentityManagerRuntimeParams,
+  type JoinIdentityParams,
+} from '../identity';
 import {
   DeviceInvitationProtocol,
   InvitationsHandler,
   type InvitationProtocol,
   SpaceInvitationProtocol,
 } from '../invitations';
-import { DataSpaceManager, type SigningContext } from '../spaces';
+import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
+export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams & DataSpaceManagerRuntimeParams;
 /**
  * Shared backend for all client services.
  */
@@ -62,6 +69,7 @@ export class ServiceContext {
   public readonly identityManager: IdentityManager;
   public readonly invitations: InvitationsHandler;
   public readonly automergeHost: AutomergeHost;
+  public readonly indexMetadata: IndexMetadataStore;
 
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
@@ -80,9 +88,11 @@ export class ServiceContext {
     public readonly networkManager: NetworkManager,
     public readonly signalManager: SignalManager,
     public readonly modelFactory: ModelFactory,
+    public readonly _runtimeParams?: IdentityManagerRuntimeParams & DataSpaceManagerRuntimeParams,
   ) {
     // TODO(burdon): Move strings to constants.
     this.metadataStore = new MetadataStore(storage.createDirectory('metadata'));
+    this.indexMetadata = new IndexMetadataStore({ directory: storage.createDirectory('index-metadata') });
     this.snapshotStore = new SnapshotStore(storage.createDirectory('snapshots'));
     this.blobStore = new BlobStore(storage.createDirectory('blobs'));
 
@@ -107,9 +117,18 @@ export class ServiceContext {
       snapshotStore: this.snapshotStore,
     });
 
-    this.identityManager = new IdentityManager(this.metadataStore, this.keyring, this.feedStore, this.spaceManager);
+    this.identityManager = new IdentityManager(
+      this.metadataStore,
+      this.keyring,
+      this.feedStore,
+      this.spaceManager,
+      this._runtimeParams as IdentityManagerRuntimeParams,
+    );
 
-    this.automergeHost = new AutomergeHost(storage.createDirectory('automerge'));
+    this.automergeHost = new AutomergeHost({
+      directory: storage.createDirectory('automerge'),
+      metadata: this.indexMetadata,
+    });
 
     this.invitations = new InvitationsHandler(this.networkManager);
 
@@ -221,6 +240,7 @@ export class ServiceContext {
       signingContext,
       this.feedStore,
       this.automergeHost,
+      this._runtimeParams as DataSpaceManagerRuntimeParams,
     );
     await this.dataSpaceManager.open();
 

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, getRawDoc, type SpaceDoc } from '@dxos/echo-schema';
+import { type TypedObject, getRawDoc, type SpaceDoc, getAutomergeObjectCore } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -24,7 +24,7 @@ import { assignDeep } from '@dxos/util';
 import { WebsocketRpcClient } from '@dxos/websocket-rpc';
 
 import { createDiagnostics } from './diagnostics';
-import { ServiceContext } from './service-context';
+import { ServiceContext, type ServiceContextRuntimeParams } from './service-context';
 import { ServiceRegistry } from './service-registry';
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
@@ -54,6 +54,7 @@ export type ClientServicesHostParams = {
   storage?: Storage;
   lockKey?: string;
   callbacks?: ClientServicesHostCallbacks;
+  runtimeParams?: ServiceContextRuntimeParams;
 };
 
 export type ClientServicesHostCallbacks = {
@@ -88,6 +89,7 @@ export class ClientServicesHost {
   private _devtoolsProxy?: WebsocketRpcClient<{}, ClientServices>;
 
   private _serviceContext!: ServiceContext;
+  private readonly _runtimeParams?: ServiceContextRuntimeParams;
 
   @Trace.info()
   private _opening = false;
@@ -104,10 +106,12 @@ export class ClientServicesHost {
     // TODO(wittjosiah): Turn this on by default.
     lockKey,
     callbacks,
+    runtimeParams,
   }: ClientServicesHostParams = {}) {
     this._storage = storage;
     this._modelFactory = modelFactory;
     this._callbacks = callbacks;
+    this._runtimeParams = runtimeParams;
 
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
@@ -239,6 +243,7 @@ export class ClientServicesHost {
       this._networkManager,
       this._signalManager,
       this._modelFactory,
+      this._runtimeParams,
     );
 
     this._serviceRegistry.setServices({
@@ -352,7 +357,7 @@ export class ClientServicesHost {
     await document.whenReady();
 
     document.change((doc: SpaceDoc) => {
-      assignDeep(doc, ['objects', obj[base]._id], getRawDoc(obj).handle.docSync());
+      assignDeep(doc, ['objects', getAutomergeObjectCore(obj).id], getRawDoc(obj).handle.docSync());
     });
 
     return identity;

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

@@ -59,6 +59,11 @@ export type AcceptSpaceOptions = {
   dataTimeframe?: Timeframe;
 };
 
+export type DataSpaceManagerRuntimeParams = {
+  spaceMemberPresenceAnnounceInterval?: number;
+  spaceMemberPresenceOfflineTimeout?: number;
+};
+
 @trackLeaks('open', 'close')
 export class DataSpaceManager {
   private readonly _ctx = new Context();
@@ -69,6 +74,8 @@ export class DataSpaceManager {
 
   private _isOpen = false;
   private readonly _instanceId = PublicKey.random().toHex();
+  private readonly _spaceMemberPresenceAnnounceInterval: number;
+  private readonly _spaceMemberPresenceOfflineTimeout: number;
 
   constructor(
     private readonly _spaceManager: SpaceManager,
@@ -78,7 +85,15 @@ export class DataSpaceManager {
     private readonly _signingContext: SigningContext,
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _automergeHost: AutomergeHost,
-  ) {}
+    params?: DataSpaceManagerRuntimeParams,
+  ) {
+    const {
+      spaceMemberPresenceAnnounceInterval = PRESENCE_ANNOUNCE_INTERVAL,
+      spaceMemberPresenceOfflineTimeout = PRESENCE_OFFLINE_TIMEOUT,
+    } = params ?? {};
+    this._spaceMemberPresenceAnnounceInterval = spaceMemberPresenceAnnounceInterval;
+    this._spaceMemberPresenceOfflineTimeout = spaceMemberPresenceOfflineTimeout;
+  }
 
   // TODO(burdon): Remove.
   get spaces() {
@@ -204,8 +219,8 @@ export class DataSpaceManager {
       localPeerId: this._signingContext.deviceKey,
     });
     const presence = new Presence({
-      announceInterval: PRESENCE_ANNOUNCE_INTERVAL,
-      offlineTimeout: PRESENCE_OFFLINE_TIMEOUT, // TODO(burdon): Config.
+      announceInterval: this._spaceMemberPresenceAnnounceInterval,
+      offlineTimeout: this._spaceMemberPresenceOfflineTimeout,
       identityKey: this._signingContext.identityKey,
       gossip,
     });

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

@@ -215,9 +215,7 @@ export class SpacesServiceImpl implements SpacesService {
         return {
           identity: {
             identityKey: member.key,
-            profile: {
-              displayName: member.profile?.displayName,
-            },
+            profile: member.profile ?? {},
           },
           presence: member.removed
             ? SpaceMember.PresenceState.REMOVED

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

@@ -179,7 +179,7 @@ export class TestPeer {
   }
 
   get automergeHost() {
-    return (this._props.automergeHost ??= new AutomergeHost(this.storage.createDirectory('automerge')));
+    return (this._props.automergeHost ??= new AutomergeHost({ directory: this.storage.createDirectory('automerge') }));
   }
 
   get dataSpaceManager() {

package/src/packlets/vault/shared-worker-connection.ts

@@ -76,6 +76,8 @@ export class SharedWorkerConnection {
         BridgeService: this._transportService,
       },
       port: this._systemPort,
+      // TODO(wittjosiah): Make longer and factor out to constant.
+      // TODO(wittjosiah): If this is too long then it breaks the reset flows in Composer.
       timeout: 200,
     });
 

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.4.7-main.731b147";
+export const DXOS_VERSION = "0.4.7-main.772b4a3";