@dxos/client-services 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

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

@@ -5,7 +5,9 @@
 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 {
   type CredentialProcessor,
   createAdmissionCredentials,
@@ -13,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';
@@ -21,6 +24,7 @@ import { log } from '@dxos/log';
 import {
   ApiError,
   AuthorizationError,
+  FeedProtocol,
   IdentityNotInitializedError,
   SpaceNotFoundError,
   encodeError,
@@ -40,11 +44,13 @@ import {
   type QueryCredentialsRequest,
   type QuerySpacesResponse,
   type Space,
+  SpaceArchive,
   SpaceMember,
   SpaceState,
   type SpacesService,
   type SubscribeMessagesRequest,
   type UpdateMemberRoleRequest,
+  type CreateSpaceRequest,
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
@@ -54,8 +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';
 
@@ -63,29 +75,35 @@ 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(): 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();
+    const space = await dataSpaceManager.createSpace(ctx, {
+      tags: request?.tags,
+      membershipPolicy: request?.membershipPolicy,
+    });
     await this._updateMetrics();
     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();
+          await space.activate(ctx);
           break;
 
         case SpaceState.SPACE_INACTIVE:
-          await space.deactivate();
+          await space.deactivate(ctx);
           break;
         default:
           throw new ApiError({ message: 'Invalid space state' });
@@ -93,7 +111,7 @@ export class SpacesServiceImpl implements SpacesService {
     }
 
     if (edgeReplication !== undefined) {
-      await dataSpaceManager.setSpaceEdgeReplicationSetting(spaceKey, edgeReplication);
+      await dataSpaceManager.setSpaceEdgeReplicationSetting(ctx, spaceKey, edgeReplication);
     }
   }
 
@@ -262,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(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');
@@ -283,23 +309,92 @@ export class SpacesServiceImpl implements SpacesService {
       await writer.writeDocument(documentId, data);
     }
 
+    const feeds = await space.getAllFeeds();
+    for (const feed of feeds) {
+      const archiveBlocks = feed.blocks.map((block) => ({
+        actorId: block.actorId,
+        sequence: block.sequence,
+        prevActorId: block.prevActorId,
+        prevSequence: block.prevSequence,
+        position: block.position,
+        timestamp: block.timestamp,
+        data: Buffer.from(block.data).toString('base64'),
+      }));
+      await writer.writeFeed(feed.feedId, feed.feedNamespace, archiveBlocks);
+    }
+
     const archive = await writer.finish();
     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, { tags: request.tags });
+      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({
+    const space = await dataSpaceManager.createSpace(ctx, {
       documents: extracted.documents,
       rootUrl: extracted.metadata.echo?.currentRootUrl as AutomergeUrl,
+      tags: request.tags,
     });
     await this._updateMetrics();
     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;
@@ -308,9 +403,10 @@ export class SpacesServiceImpl implements SpacesService {
     const dataSpaceManager = await this._getDataSpaceManager();
     let dataSpace = dataSpaceManager.spaces.get(assertion.spaceKey);
     if (!dataSpace) {
-      dataSpace = await dataSpaceManager.acceptSpace({
+      dataSpace = await dataSpaceManager.acceptSpace(ctx, {
         spaceKey: assertion.spaceKey,
         genesisFeedKey: assertion.genesisFeedKey,
+        tags: assertion.tags,
       });
       await myIdentity.controlPipeline.writer.write({ credential: { credential } });
     }
@@ -363,6 +459,8 @@ export class SpacesServiceImpl implements SpacesService {
         }),
       ),
       creator: space.inner.spaceState.creator?.key,
+      tags: space.tags,
+      membershipPolicy: space.membershipPolicy,
       cache: space.cache,
       metrics: space.metrics,
       edgeReplication: space.getEdgeReplicationSetting(),

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

@@ -4,6 +4,7 @@
 
 import { Trigger } from '@dxos/async';
 import { type AuthenticatingInvitation, type CancellableInvitation, InvitationEncoder } from '@dxos/client-protocol';
+import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -229,7 +230,7 @@ export const createInvitation = async (
   };
 
   if (host instanceof ServiceContext) {
-    return host.invitationsManager.createInvitation({
+    return host.invitationsManager.createInvitation(new Context(), {
       kind: Invitation.Kind.SPACE,
       ...options,
     });
@@ -246,7 +247,7 @@ export const acceptInvitation = (
   invitation = sanitizeInvitation(invitation);
 
   if (guest instanceof ServiceContext) {
-    return guest.invitationsManager.acceptInvitation({
+    return guest.invitationsManager.acceptInvitation(new Context(), {
       invitation,
       deviceProfile: guestDeviceProfile,
     });

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

@@ -29,7 +29,6 @@ import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 import { type MaybePromise } from '@dxos/util';
 
 import { ClientServicesHost } from '../services';
-
 import { WorkerSession } from './worker-session';
 
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.
@@ -131,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
@@ -154,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({
@@ -176,12 +189,36 @@ export class WorkerRuntime {
     this._releaseLock();
     this._broadcastChannel?.close();
     this._broadcastChannel = undefined;
-    await this._clientServices.close();
+    await this._clientServices.close(Context.default());
     await this._runtime.dispose();
     await this._onStop?.();
     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.
    */
@@ -214,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();
           },
 
@@ -119,7 +113,7 @@ export class WorkerSession {
   }
 
   async open(): Promise<void> {
-    log.info('opening...');
+    log('opening...');
     await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     // Wait until the worker's RPC service has started.
@@ -130,11 +124,11 @@ export class WorkerSession {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
 
-    log.info('opened');
+    log('opened');
   }
 
   async close(): Promise<void> {
-    log.info('closing...');
+    log.debug('closing...');
     try {
       await this.onClose.callIfSet();
     } catch (err: any) {
@@ -142,7 +136,7 @@ export class WorkerSession {
     }
 
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
-    log.info('closed');
+    log.debug('closed');
   }
 
   private async _maybeOpenShell(): Promise<void> {

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.8.4-main.ef1bc66f44";
+export const DXOS_VERSION = "0.8.4-main.f466a3d56e";