@dxos/client-services 0.4.10-main.ec8b427 → 0.4.10-main.eedd150

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

@@ -2,12 +2,14 @@
 // Copyright 2021 DXOS.org
 //
 
+import { type Level } from 'level';
+
 import { Event, synchronized } from '@dxos/async';
-import { Properties, clientServiceBundle, defaultKey, type ClientServices } from '@dxos/client-protocol';
+import { clientServiceBundle, defaultKey, type ClientServices, Properties } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
-import { DataServiceImpl } from '@dxos/echo-pipeline';
-import { getAutomergeObjectCore, getRawDoc, type SpaceDoc, type TypedObject } from '@dxos/echo-schema';
+import { DataServiceImpl, type ObjectStructure, encodeReference, type SpaceDoc } from '@dxos/echo-pipeline';
+import * as E from '@dxos/echo-schema';
 import { IndexServiceImpl } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
@@ -32,7 +34,7 @@ import { Lock, type ResourceLock } from '../locks';
 import { LoggingServiceImpl } from '../logging';
 import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
-import { createStorageObjects } from '../storage';
+import { createLevel, createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
 
 export type ClientServicesHostParams = {
@@ -76,6 +78,7 @@ export class ClientServicesHost {
   private _signalManager?: SignalManager;
   private _networkManager?: NetworkManager;
   private _storage?: Storage;
+  private _level?: Level<string, string>;
   private _callbacks?: ClientServicesHostCallbacks;
   private _devtoolsProxy?: WebsocketRpcClient<{}, ClientServices>;
 
@@ -187,6 +190,9 @@ export class ClientServicesHost {
       }
     }
 
+    if (!options.signalManager) {
+      log.warn('running signaling without telemetry metadata.');
+    }
     const {
       connectionLog = true,
       transportFactory = createSimplePeerTransportFactory({
@@ -223,12 +229,17 @@ export class ClientServicesHost {
 
     this._opening = true;
     log('opening...', { lockKey: this._resourceLock?.lockKey });
+
+    if (!this._level) {
+      this._level = await createLevel(this._config.get('runtime.client.storage', {})!);
+    }
     await this._resourceLock?.acquire();
 
     await this._loggingService.open();
 
     this._serviceContext = new ServiceContext(
       this._storage,
+      this._level,
       this._networkManager,
       this._signalManager,
       this._runtimeParams,
@@ -320,6 +331,7 @@ export class ClientServicesHost {
     this._serviceRegistry.setServices({ SystemService: this._systemService });
     await this._loggingService.close();
     await this._serviceContext.close();
+    await this._level?.close();
     this._open = false;
     this._statusUpdate.emit();
     log('closed', { deviceKey });
@@ -344,18 +356,30 @@ export class ClientServicesHost {
     await this._serviceContext.initialized.wait();
     const space = await this._serviceContext.dataSpaceManager!.createSpace();
 
-    const obj: TypedObject = new Properties(undefined);
-    obj[defaultKey] = identity.identityKey.toHex();
-
     const automergeIndex = space.automergeSpaceState.rootUrl;
     invariant(automergeIndex);
     const document = await this._serviceContext.automergeHost.repo.find<SpaceDoc>(automergeIndex as any);
     await document.whenReady();
 
+    // TODO(dmaretskyi): Better API for low-level data access.
+    const properties: ObjectStructure = {
+      system: {
+        type: encodeReference(E.getTypeReference(Properties)!),
+      },
+      data: {
+        [defaultKey]: identity.identityKey.toHex(),
+      },
+      meta: {
+        keys: [],
+      },
+    };
+    const propertiesId = PublicKey.random().toHex();
     document.change((doc: SpaceDoc) => {
-      assignDeep(doc, ['objects', getAutomergeObjectCore(obj).id], getRawDoc(obj).handle.docSync());
+      assignDeep(doc, ['objects', propertiesId], properties);
     });
 
+    await this._serviceContext.automergeHost.repo.flush();
+
     return identity;
   }
 }

package/src/packlets/services/service-registry.test.ts

@@ -31,7 +31,7 @@ const serviceBundle = createServiceBundle<TestServices>({
 describe('service registry', () => {
   test('builds a service registry', async () => {
     const remoteSource = 'https://remote.source';
-    const serviceContext = createServiceContext();
+    const serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
 
     const serviceRegistry = new ServiceRegistry(serviceBundle, {

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

@@ -6,7 +6,15 @@ import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } fr
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import { type MetadataStore, type Space, createMappedFeedWriter, type AutomergeHost } from '@dxos/echo-pipeline';
+import { TYPE_PROPERTIES } from '@dxos/echo-db';
+import {
+  type MetadataStore,
+  type Space,
+  createMappedFeedWriter,
+  type AutomergeHost,
+  type SpaceDoc,
+} from '@dxos/echo-pipeline';
+import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -26,7 +34,7 @@ import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gos
 import { type Gossip, type Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { ComplexSet } from '@dxos/util';
+import { ComplexSet, assignDeep } from '@dxos/util';
 
 import { AutomergeSpaceState } from './automerge-space-state';
 import { type SigningContext } from './data-space-manager';
@@ -437,6 +445,47 @@ export class DataSpace {
           };
         }
         break;
+      case CreateEpochRequest.Migration.FRAGMENT_AUTOMERGE_ROOT:
+        {
+          log.info('Fragmenting');
+
+          const currentRootUrl = this._automergeSpaceState.rootUrl;
+          const rootHandle = this._automergeHost.repo.find<SpaceDoc>(currentRootUrl as any);
+          await cancelWithContext(this._ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+
+          // Find properties object.
+          const objects = Object.entries((rootHandle.docSync() as SpaceDoc).objects!);
+          const properties = objects.find(([_, value]) => value.system.type?.itemId === TYPE_PROPERTIES);
+          const otherObjects = objects.filter(([key]) => key !== properties?.[0]);
+          invariant(properties, 'Properties not found');
+
+          // Create a new space doc with the properties object.
+          const newSpaceDoc: SpaceDoc = { ...rootHandle.docSync(), objects: Object.fromEntries([properties]) };
+          const newRoot = this._automergeHost.repo.create(newSpaceDoc);
+          invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
+
+          // Create new automerge documents for all objects.
+          const docLoader = new AutomergeDocumentLoaderImpl(this.key, this._automergeHost.repo);
+          await docLoader.loadSpaceRootDocHandle(this._ctx, { rootUrl: newRoot.url });
+
+          otherObjects.forEach(([key, value]) => {
+            const handle = docLoader.createDocumentForObject(key);
+            handle.change((doc: any) => {
+              assignDeep(doc, ['objects', key], value);
+            });
+          });
+
+          // TODO(mykola): Delete old root.
+
+          // TODO(dmaretskyi): Unify epoch construction.
+          epoch = {
+            previousId: this._automergeSpaceState.lastEpoch?.id,
+            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
+            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
+            automergeRoot: newRoot.url,
+          };
+        }
+        break;
     }
 
     if (!epoch) {

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

@@ -22,7 +22,7 @@ describe('SpacesService', () => {
   let spacesService: SpacesService;
 
   beforeEach(async () => {
-    serviceContext = createServiceContext();
+    serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
     spacesService = new SpacesServiceImpl(serviceContext.identityManager, serviceContext.spaceManager, async () => {
       await serviceContext.initialized.wait();

package/src/packlets/storage/index.ts

@@ -3,3 +3,4 @@
 //
 
 export * from './storage';
+export * from './level';

package/src/packlets/storage/level.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Level } from 'level';
+import path from 'node:path';
+
+import { PublicKey } from '@dxos/keys';
+import { type Runtime } from '@dxos/protocols/proto/dxos/config';
+
+import { getRootPath, isPersistent } from './util';
+
+export const createLevel = async (config: Runtime.Client.Storage) => {
+  const persistent = isPersistent(config);
+  const storagePath = persistent ? getRootPath(config) : path.join('tmp', 'level', PublicKey.random().toHex());
+  const level = new Level<string, string>(storagePath);
+  await level.open();
+  return level;
+};

package/src/packlets/storage/storage.ts

@@ -4,22 +4,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { DX_DATA } from '@dxos/client-protocol';
 import { InvalidConfigError } from '@dxos/protocols';
 import { Runtime } from '@dxos/protocols/proto/dxos/config';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
-import { isNode } from '@dxos/util';
 
 import StorageDriver = Runtime.Client.Storage.StorageDriver;
+import { getRootPath } from './util';
 
 // TODO(burdon): Factor out.
 export const createStorageObjects = (config: Runtime.Client.Storage) => {
-  const {
-    persistent = false,
-    keyStore,
-    dataStore,
-    dataRoot = isNode() ? DX_DATA : 'dxos/storage', // TODO(burdon): Factor out const.
-  } = config ?? {};
+  const { persistent = false, keyStore, dataStore } = config ?? {};
 
   if (persistent && dataStore === StorageDriver.RAM) {
     throw new InvalidConfigError('RAM storage cannot be used in persistent mode.');
@@ -37,7 +31,7 @@ export const createStorageObjects = (config: Runtime.Client.Storage) => {
   return {
     storage: createStorage({
       type: persistent ? toStorageType(dataStore) : StorageType.RAM,
-      root: `${dataRoot}/`,
+      root: getRootPath(config),
     }),
   };
 };

package/src/packlets/storage/util.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { DX_DATA } from '@dxos/client-protocol';
+import { Runtime } from '@dxos/protocols/proto/dxos/config';
+import { isNode } from '@dxos/util';
+
+export const getRootPath = (config: Runtime.Client.Storage) => {
+  const { dataRoot = isNode() ? DX_DATA : 'dxos/storage' } = config ?? {};
+  return `${dataRoot}/`;
+};
+
+export const isPersistent = (config: Runtime.Client.Storage) => {
+  const { persistent = false } = config ?? {};
+  return (
+    (config.dataStore !== undefined && config.dataStore !== Runtime.Client.Storage.StorageDriver.RAM) || persistent
+  );
+};

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

@@ -8,6 +8,7 @@ import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/cred
 import { failUndefined } from '@dxos/debug';
 import { AutomergeHost, MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
+import { createTestLevel } from '@dxos/indexing/testing';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
@@ -29,7 +30,7 @@ export const createServiceHost = (config: Config, signalManagerContext: MemorySi
   });
 };
 
-export const createServiceContext = ({
+export const createServiceContext = async ({
   signalContext = new MemorySignalManagerContext(),
   storage = createStorage({ type: StorageType.RAM }),
 }: {
@@ -41,8 +42,9 @@ export const createServiceContext = ({
     signalManager,
     transportFactory: MemoryTransportFactory,
   });
+  const level = await createTestLevel();
 
-  return new ServiceContext(storage, networkManager, signalManager);
+  return new ServiceContext(storage, level, networkManager, signalManager);
 };
 
 export const createPeers = async (numPeers: number) => {
@@ -50,7 +52,7 @@ export const createPeers = async (numPeers: number) => {
 
   return await Promise.all(
     Array.from(Array(numPeers)).map(async () => {
-      const peer = createServiceContext({ signalContext });
+      const peer = await createServiceContext({ signalContext });
       await peer.open(new Context());
       return peer;
     }),

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

@@ -57,12 +57,7 @@ export class SharedWorkerConnection {
     return this._shellRuntime;
   }
 
-  async open(
-    /**
-     * @deprecated Only used with iframes.
-     */
-    origin: string,
-  ) {
+  async open(params: { origin: string; observabilityGroup?: string; signalTelemetryEnabled?: boolean }) {
     this._config = await getAsyncValue(this._configProvider);
 
     this._transportService = new SimplePeerTransportService({
@@ -83,7 +78,7 @@ export class SharedWorkerConnection {
 
     let lockKey: string | undefined;
     if (typeof navigator !== 'undefined') {
-      lockKey = this._lockKey(origin);
+      lockKey = this._lockKey(params.origin);
       this._release = new Trigger();
       const ready = new Trigger();
       void navigator.locks.request(lockKey, async () => {
@@ -95,7 +90,7 @@ export class SharedWorkerConnection {
 
     try {
       await this._systemRpc.open();
-      await this._systemRpc.rpc.WorkerService.start({ origin, lockKey });
+      await this._systemRpc.rpc.WorkerService.start({ lockKey, ...params });
     } catch (err) {
       log.catch(err);
       throw new RemoteServiceConnectionError('Failed to connect to worker');

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

@@ -5,8 +5,14 @@
 import { Trigger } from '@dxos/async';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import {
+  MemorySignalManager,
+  MemorySignalManagerContext,
+  WebsocketSignalManager,
+  setIdentityTags,
+} from '@dxos/messaging';
 import { SimplePeerTransportProxyFactory } from '@dxos/network-manager';
 import { type RpcPort } from '@dxos/rpc';
 import { type MaybePromise } from '@dxos/util';
@@ -41,6 +47,8 @@ export class WorkerRuntime {
   private readonly _clientServices!: ClientServicesHost;
   private _sessionForNetworking?: WorkerSession; // TODO(burdon): Expose to client QueryStatusResponse.
   private _config!: Config;
+  private _signalMetadataTags: any = { runtime: 'worker-runtime' };
+  private _signalTelemetryEnabled: boolean = false;
 
   constructor(
     private readonly _configProvider: () => MaybePromise<Config>,
@@ -68,7 +76,7 @@ export class WorkerRuntime {
       this._clientServices.initialize({
         config: this._config,
         signalManager: signals
-          ? new WebsocketSignalManager(signals)
+          ? new WebsocketSignalManager(signals, () => (this._signalTelemetryEnabled ? this._signalMetadataTags : {}))
           : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
         transportFactory: this._transportFactory,
       });
@@ -76,6 +84,13 @@ export class WorkerRuntime {
       await this._clientServices.open(new Context());
       this._ready.wake(undefined);
       log('started');
+      setIdentityTags({
+        identityService: this._clientServices.services.IdentityService!,
+        devicesService: this._clientServices.services.DevicesService!,
+        setTag: (k: string, v: string) => {
+          this._signalMetadataTags[k] = v;
+        },
+      });
     } catch (err: any) {
       this._ready.wake(err);
       log.error('starting', err);
@@ -112,6 +127,16 @@ export class WorkerRuntime {
     });
 
     await session.open();
+    // A worker can only service one origin currently
+    invariant(
+      !this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin,
+      `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`,
+    );
+    if (session.observabilityGroup) {
+      this._signalMetadataTags.group = session.observabilityGroup;
+    }
+    this._signalTelemetryEnabled = session.signalTelemetryEnabled ?? false;
+    this._signalMetadataTags.origin = session.origin;
     this._sessions.add(session);
 
     this._reconnectWebrtc();

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

@@ -41,6 +41,10 @@ export class WorkerSession {
   @logInfo
   public origin?: string;
 
+  // TODO(nf): factor out?
+  public observabilityGroup?: string;
+  public signalTelemetryEnabled?: boolean;
+
   @logInfo
   public lockKey?: string;
 
@@ -91,6 +95,8 @@ export class WorkerSession {
           start: async (request) => {
             this.origin = request.origin;
             this.lockKey = request.lockKey;
+            this.observabilityGroup = request.observabilityGroup;
+            this.signalTelemetryEnabled = request.signalTelemetryEnabled;
             this._startTrigger.wake();
           },
 

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.4.10-main.ec8b427";
+export const DXOS_VERSION = "0.4.10-main.eedd150";