@dxos/client-services 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

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

@@ -5,6 +5,7 @@
 import type { AutomergeUrl } from '@automerge/automerge-repo';
 
 import { SubscriptionList, UpdateScheduler, scheduleTask } from '@dxos/async';
+import { type RequestOptions } from '@dxos/codec-protobuf';
 import { Stream } from '@dxos/codec-protobuf/stream';
 import { Context } from '@dxos/context';
 import {
@@ -14,7 +15,8 @@ import {
   getCredentialAssertion,
 } from '@dxos/credentials';
 import { raise } from '@dxos/debug';
-import { type SpaceManager } from '@dxos/echo-pipeline';
+import { type EchoHost, type SpaceManager } from '@dxos/echo-pipeline';
+import { type DatabaseDirectory } from '@dxos/echo-protocol';
 import { writeMessages } from '@dxos/feed-store';
 import { assertArgument, assertState, invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
@@ -22,6 +24,7 @@ import { log } from '@dxos/log';
 import {
   ApiError,
   AuthorizationError,
+  FeedProtocol,
   IdentityNotInitializedError,
   SpaceNotFoundError,
   encodeError,
@@ -41,6 +44,7 @@ import {
   type QueryCredentialsRequest,
   type QuerySpacesResponse,
   type Space,
+  SpaceArchive,
   SpaceMember,
   SpaceState,
   type SpacesService,
@@ -56,7 +60,14 @@ import { trace } from '@dxos/tracing';
 import { type Provider } from '@dxos/util';
 
 import { type IdentityManager } from '../identity';
-import { SpaceArchiveWriter, extractSpaceArchive } from '../space-export';
+import {
+  SpaceArchiveWriter,
+  detectSpaceArchiveFormat,
+  extractSpaceArchive,
+  readSerializedSpaceArchive,
+  writeSerializedSpaceArchive,
+  objJsonToObjectStructure,
+} from '../space-export';
 import { type DataSpace } from './data-space';
 import { type DataSpaceManager } from './data-space-manager';
 
@@ -64,13 +75,15 @@ export class SpacesServiceImpl implements SpacesService {
   constructor(
     private readonly _identityManager: IdentityManager,
     private readonly _spaceManager: SpaceManager,
+    private readonly _echoHost: EchoHost,
     private readonly _getDataSpaceManager: Provider<Promise<DataSpaceManager>>,
   ) {}
 
-  async createSpace(request: CreateSpaceRequest): Promise<Space> {
+  async createSpace(request: CreateSpaceRequest, options?: RequestOptions): Promise<Space> {
     this._requireIdentity();
+    const ctx = options?.ctx ?? new Context();
     const dataSpaceManager = await this._getDataSpaceManager();
-    const space = await dataSpaceManager.createSpace(new Context(), {
+    const space = await dataSpaceManager.createSpace(ctx, {
       tags: request?.tags,
       membershipPolicy: request?.membershipPolicy,
     });
@@ -78,18 +91,19 @@ export class SpacesServiceImpl implements SpacesService {
     return this._serializeSpace(space);
   }
 
-  async updateSpace({ spaceKey, state, edgeReplication }: UpdateSpaceRequest): Promise<void> {
+  async updateSpace({ spaceKey, state, edgeReplication }: UpdateSpaceRequest, options?: RequestOptions): Promise<void> {
+    const ctx = options?.ctx ?? Context.default();
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
 
     if (state) {
       switch (state) {
         case SpaceState.SPACE_ACTIVE:
-          await space.activate(Context.default());
+          await space.activate(ctx);
           break;
 
         case SpaceState.SPACE_INACTIVE:
-          await space.deactivate(Context.default());
+          await space.deactivate(ctx);
           break;
         default:
           throw new ApiError({ message: 'Invalid space state' });
@@ -97,7 +111,7 @@ export class SpacesServiceImpl implements SpacesService {
     }
 
     if (edgeReplication !== undefined) {
-      await dataSpaceManager.setSpaceEdgeReplicationSetting(Context.default(), spaceKey, edgeReplication);
+      await dataSpaceManager.setSpaceEdgeReplicationSetting(ctx, spaceKey, edgeReplication);
     }
   }
 
@@ -266,18 +280,26 @@ export class SpacesServiceImpl implements SpacesService {
     });
   }
 
-  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest): Promise<JoinSpaceResponse> {
+  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest, options?: RequestOptions): Promise<JoinSpaceResponse> {
+    const ctx = options?.ctx ?? Context.default();
     const dataSpaceManager = await this._getDataSpaceManager();
-    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(Context.default(), spaceKey);
-    return this._joinByAdmission({ credential });
+    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(ctx, spaceKey);
+    return this._joinByAdmission(ctx, { credential });
   }
 
   async exportSpace(request: ExportSpaceRequest): Promise<ExportSpaceResponse> {
-    await using writer = await new SpaceArchiveWriter().open();
     assertArgument(SpaceId.isValid(request.spaceId), 'spaceId', 'Invalid space ID');
 
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = dataSpaceManager.getSpaceById(request.spaceId) ?? raise(new Error('Space not found'));
+
+    const format = request.format ?? SpaceArchive.Format.BINARY;
+    if (format === SpaceArchive.Format.JSON) {
+      const archive = await writeSerializedSpaceArchive({ space, echoHost: this._echoHost });
+      return { archive };
+    }
+
+    await using writer = await new SpaceArchiveWriter().open();
     await writer.begin({ spaceId: space.id });
     const rootUrl = space.automergeSpaceState.lastEpoch?.subject.assertion.automergeRoot;
     assertState(rootUrl, 'Space does not have a root URL');
@@ -305,11 +327,22 @@ export class SpacesServiceImpl implements SpacesService {
     return { archive };
   }
 
-  async importSpace(request: ImportSpaceRequest): Promise<ImportSpaceResponse> {
+  async importSpace(request: ImportSpaceRequest, options?: RequestOptions): Promise<ImportSpaceResponse> {
+    const ctx = options?.ctx ?? Context.default();
     const dataSpaceManager = await this._getDataSpaceManager();
+
+    const format = request.archive.format ?? detectSpaceArchiveFormat(request.archive);
+    if (format === SpaceArchive.Format.JSON) {
+      const serialized = readSerializedSpaceArchive(request.archive);
+      const space = await dataSpaceManager.createSpace(ctx);
+      await this._hydrateSpaceFromSerialized(space, serialized);
+      await this._updateMetrics();
+      return { newSpaceId: space.id };
+    }
+
     const extracted = await extractSpaceArchive(request.archive);
     invariant(extracted.metadata.echo?.currentRootUrl, 'Space archive does not contain a root URL');
-    const space = await dataSpaceManager.createSpace(Context.default(), {
+    const space = await dataSpaceManager.createSpace(ctx, {
       documents: extracted.documents,
       rootUrl: extracted.metadata.echo?.currentRootUrl as AutomergeUrl,
     });
@@ -317,7 +350,49 @@ export class SpacesServiceImpl implements SpacesService {
     return { newSpaceId: space.id };
   }
 
-  private async _joinByAdmission({ credential }: ContactAdmission): Promise<JoinSpaceResponse> {
+  /**
+   * Populate a freshly-created space with the objects and feed messages described in a {@link SerializedSpace}.
+   *
+   * Objects are written directly into the space's automerge root document as inline
+   * {@link ObjectStructure} entries; feed messages are appended to the appropriate queue
+   * via {@link EchoHost.queuesService}.
+   */
+  private async _hydrateSpaceFromSerialized(
+    space: DataSpace,
+    serialized: ReturnType<typeof readSerializedSpaceArchive>,
+  ): Promise<void> {
+    const databaseRoot = space.databaseRoot;
+    assertState(databaseRoot, 'Space database root is not ready');
+
+    databaseRoot.handle.change((doc: DatabaseDirectory) => {
+      if (!doc.objects) {
+        doc.objects = {};
+      }
+      for (const obj of serialized.objects) {
+        doc.objects[obj.id] = objJsonToObjectStructure(obj);
+      }
+    });
+
+    for (const feed of serialized.feeds ?? []) {
+      if (feed.messages.length === 0) {
+        continue;
+      }
+      const namespace =
+        feed.namespace === 'trace' ? FeedProtocol.WellKnownNamespaces.trace : FeedProtocol.WellKnownNamespaces.data;
+      try {
+        await this._echoHost.queuesService.insertIntoQueue({
+          spaceId: space.id,
+          queueId: feed.feedObjectId,
+          subspaceTag: namespace,
+          objects: feed.messages.map((message) => JSON.stringify(message)),
+        });
+      } catch (err) {
+        log.warn('failed to import feed data', { feedObjectId: feed.feedObjectId, error: err });
+      }
+    }
+  }
+
+  private async _joinByAdmission(ctx: Context, { credential }: ContactAdmission): Promise<JoinSpaceResponse> {
     const assertion = getCredentialAssertion(credential);
     invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
     const myIdentity = this._identityManager.identity;
@@ -326,7 +401,7 @@ export class SpacesServiceImpl implements SpacesService {
     const dataSpaceManager = await this._getDataSpaceManager();
     let dataSpace = dataSpaceManager.spaces.get(assertion.spaceKey);
     if (!dataSpace) {
-      dataSpace = await dataSpaceManager.acceptSpace(Context.default(), {
+      dataSpace = await dataSpaceManager.acceptSpace(ctx, {
         spaceKey: assertion.spaceKey,
         genesisFeedKey: assertion.genesisFeedKey,
         tags: assertion.tags,

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

@@ -130,20 +130,32 @@ export class WorkerRuntime {
   async start(): Promise<void> {
     log('starting...');
     try {
+      log('worker-runtime: acquiring liveness lock (background)');
       void this._livenessLock.acquire();
 
       // Steal the lock from the other worker.
+      log('worker-runtime: broadcasting stop to displace previous worker');
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({ action: 'stop' });
       this._broadcastChannel.onmessage = async (event) => {
         if (event.data?.action === 'stop') {
+          log('worker-runtime: received stop broadcast');
           await this.stop();
         }
       };
 
+      log('worker-runtime: acquiring storage lock');
       await this._acquireLock();
+      log('worker-runtime: storage lock acquired, resolving config');
       this._config = await this._configProvider();
+      log('worker-runtime: config resolved');
+      this._signalTelemetryEnabled = this._config.get('runtime.client.signalTelemetryEnabled') ?? false;
+      const observabilityGroup = this._config.get('runtime.client.observabilityGroup');
+      if (observabilityGroup) {
+        this._signalMetadataTags.group = observabilityGroup;
+      }
       const signals = this._config.get('runtime.services.signaling');
+      log('worker-runtime: initializing client services host');
       this._clientServices.initialize({
         config: this._config,
         signalManager: this._config.get('runtime.client.edgeFeatures')?.signaling
@@ -153,8 +165,10 @@ export class WorkerRuntime {
             : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
         transportFactory: this._transportFactory,
       });
+      log('worker-runtime: client services host initialized, opening');
 
       await this._clientServices.open(new Context());
+      log('worker-runtime: client services host opened, signalling ready');
       this._ready.wake(undefined);
       log('started');
       setIdentityTags({
@@ -181,6 +195,30 @@ export class WorkerRuntime {
     await this._livenessLock.release();
   }
 
+  /**
+   * Update signaling telemetry tags from a client-supplied config overlay.
+   *
+   * The worker services outlive individual client connections, so the first client seeds the
+   * worker's core config (storage, signaling, edge features). For fields that can legitimately
+   * differ per tab — `observabilityGroup` and `signalTelemetryEnabled` — this method lets later
+   * connections refresh the signal metadata the worker attaches to its signaling requests
+   * (last-writer-wins, matching the pre-DX-930 per-session RPC behaviour).
+   */
+  updateSignalMetadata(config: Config): void {
+    const observabilityGroup = config.get('runtime.client.observabilityGroup');
+    if (observabilityGroup) {
+      this._signalMetadataTags.group = observabilityGroup;
+    } else {
+      // Clear stale group so a later config that removes observabilityGroup stops attributing
+      // telemetry to the previous client's group (last-writer-wins).
+      delete this._signalMetadataTags.group;
+    }
+    const signalTelemetryEnabled = config.get('runtime.client.signalTelemetryEnabled');
+    if (signalTelemetryEnabled !== undefined) {
+      this._signalTelemetryEnabled = signalTelemetryEnabled;
+    }
+  }
+
   /**
    * Create a new session.
    */
@@ -213,10 +251,6 @@ export class WorkerRuntime {
       !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);
 

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

@@ -41,10 +41,6 @@ export class WorkerSession {
   @logInfo
   public origin?: string;
 
-  // TODO(nf): factor out?
-  public observabilityGroup?: string;
-  public signalTelemetryEnabled?: boolean;
-
   @logInfo
   public lockKey?: string;
 
@@ -55,21 +51,21 @@ export class WorkerSession {
     this._serviceHost = serviceHost;
 
     const middleware: Pick<ClientRpcServerProps, 'handleCall' | 'handleStream'> = {
-      handleCall: async (method, params, handler) => {
+      handleCall: async (method, params, handler, options) => {
         const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
         if (error) {
           throw error;
         }
 
-        return handler(method, params);
+        return handler(method, params, options);
       },
-      handleStream: async (method, params, handler) => {
+      handleStream: async (method, params, handler, options) => {
         const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
         if (error) {
           throw error;
         }
 
-        return handler(method, params);
+        return handler(method, params, options);
       },
     };
 
@@ -95,8 +91,6 @@ 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.8.4-main.9be5663bfe";
+export const DXOS_VERSION = "0.8.4-main.abd8ff62ef";