@dxos/client-services 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

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

@@ -21,6 +21,7 @@ import {
   Invitation,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { trace } from '@dxos/tracing';
 
 import type { InvitationProtocol } from './invitation-protocol';
 import { type InvitationsHandler, createAdmissionKeypair } from './invitations-handler';
@@ -29,6 +30,7 @@ import { type InvitationsHandler, createAdmissionKeypair } from './invitations-h
  * Entry point for creating and accepting invitations, keeps track of existing invitation set and
  * emits events when the set changes.
  */
+@trace.resource()
 export class InvitationsManager {
   private readonly _createInvitations = new Map<string, CancellableInvitation>();
   private readonly _acceptInvitations = new Map<string, AuthenticatingInvitation>();
@@ -48,7 +50,11 @@ export class InvitationsManager {
     private readonly _metadataStore: MetadataStore,
   ) {}
 
-  async createInvitation(options: Partial<Invitation> & Pick<Invitation, 'kind'>): Promise<CancellableInvitation> {
+  @trace.span({ showInBrowserTimeline: true })
+  async createInvitation(
+    ctx: Context,
+    options: Partial<Invitation> & Pick<Invitation, 'kind'>,
+  ): Promise<CancellableInvitation> {
     if (options.invitationId) {
       const existingInvitation = this._createInvitations.get(options.invitationId);
       if (existingInvitation) {
@@ -63,7 +69,11 @@ export class InvitationsManager {
     }
     const invitation = this._createInvitation(handler, options);
 
-    const { ctx, stream, observableInvitation } = this._createObservableInvitation(handler, invitation);
+    const {
+      ctx: invitationCtx,
+      stream,
+      observableInvitation,
+    } = this._createObservableInvitation(ctx, handler, invitation);
 
     this._createInvitations.set(invitation.invitationId, observableInvitation);
     this.invitationCreated.emit(invitation);
@@ -84,12 +94,12 @@ export class InvitationsManager {
       return observableInvitation;
     }
 
-    this._invitationsHandler.handleInvitationFlow(ctx, stream, handler, observableInvitation.get());
+    this._invitationsHandler.handleInvitationFlow(invitationCtx, stream, handler, observableInvitation.get());
 
     return observableInvitation;
   }
 
-  async loadPersistentInvitations(): Promise<{ invitations: Invitation[] }> {
+  async loadPersistentInvitations(ctx: Context): Promise<{ invitations: Invitation[] }> {
     if (this._persistentInvitationsLoaded) {
       const invitations = this.getCreatedInvitations().filter((i) => i.persistent);
       return { invitations };
@@ -101,7 +111,7 @@ export class InvitationsManager {
 
       const loadTasks = freshInvitations.map((persistentInvitation) => {
         invariant(!this._createInvitations.get(persistentInvitation.invitationId), 'invitation already exists');
-        return this.createInvitation({ ...persistentInvitation, persistent: false });
+        return this.createInvitation(ctx, { ...persistentInvitation, persistent: false });
       });
       const cInvitations = await Promise.all(loadTasks);
 
@@ -115,7 +125,7 @@ export class InvitationsManager {
     }
   }
 
-  acceptInvitation(request: AcceptInvitationRequest): AuthenticatingInvitation {
+  acceptInvitation(_ctx: Context, request: AcceptInvitationRequest): AuthenticatingInvitation {
     const options = request.invitation;
     const existingInvitation = this._acceptInvitations.get(options.invitationId);
     if (existingInvitation) {
@@ -123,8 +133,20 @@ export class InvitationsManager {
     }
 
     const handler = this._getHandler(options);
-    const { ctx, invitation, stream, otpEnteredTrigger } = this._createObservableAcceptingInvitation(handler, options);
-    this._invitationsHandler.acceptInvitation(ctx, stream, handler, options, otpEnteredTrigger, request.deviceProfile);
+    const {
+      ctx: invitationCtx,
+      invitation,
+      stream,
+      otpEnteredTrigger,
+    } = this._createObservableAcceptingInvitation(handler, options);
+    this._invitationsHandler.acceptInvitation(
+      invitationCtx,
+      stream,
+      handler,
+      options,
+      otpEnteredTrigger,
+      request.deviceProfile,
+    );
     this._acceptInvitations.set(invitation.get().invitationId, invitation);
     this.invitationAccepted.emit(invitation.get());
 
@@ -198,7 +220,7 @@ export class InvitationsManager {
       state = Invitation.State.INIT,
       timeout = INVITATION_TIMEOUT,
       swarmKey = PublicKey.random(),
-      persistent = _options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY, // default no not storing keypairs
+      persistent = _options?.authMethod !== Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
       created = new Date(),
       guestKeypair = undefined,
       role = SpaceMember.Role.ADMIN,
@@ -232,17 +254,18 @@ export class InvitationsManager {
   }
 
   private _createObservableInvitation(
+    ctx: Context,
     handler: InvitationProtocol,
     invitation: Invitation,
   ): { ctx: Context; stream: PushStream<Invitation>; observableInvitation: CancellableInvitation } {
     const stream = new PushStream<Invitation>();
-    const ctx = new Context({
+    const invitationCtx = ctx.derive({
       onError: (err) => {
         stream.error(err);
-        void ctx.dispose();
+        void invitationCtx.dispose();
       },
     });
-    ctx.onDispose(() => {
+    invitationCtx.onDispose(() => {
       log('complete', { ...handler.toJSON() });
       stream.complete();
     });
@@ -251,10 +274,10 @@ export class InvitationsManager {
       subscriber: stream.observable,
       onCancel: async () => {
         stream.next({ ...invitation, state: Invitation.State.CANCELLED });
-        await ctx.dispose();
+        await invitationCtx.dispose();
       },
     });
-    return { ctx, stream, observableInvitation };
+    return { ctx: invitationCtx, stream, observableInvitation };
   }
 
   private _createObservableAcceptingInvitation(

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

@@ -28,9 +28,9 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   createInvitation(options: Invitation): Stream<Invitation> {
-    return new Stream<Invitation>(({ next, close }) => {
+    return new Stream<Invitation>(({ ctx, next, close }) => {
       void this._invitationsManager
-        .createInvitation(options)
+        .createInvitation(ctx, options)
         .then((invitation) => {
           trace.metrics.increment('dxos.invitation.created');
           invitation.subscribe(next, close, close);
@@ -40,8 +40,8 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   acceptInvitation(request: AcceptInvitationRequest): Stream<Invitation> {
-    const invitation = this._invitationsManager.acceptInvitation(request);
-    return new Stream<Invitation>(({ next, close }) => {
+    return new Stream<Invitation>(({ ctx, next, close }) => {
+      const invitation = this._invitationsManager.acceptInvitation(ctx, request);
       invitation.subscribe(next, close, close);
     });
   }

package/src/packlets/invitations/space-invitation-protocol.test.ts

@@ -5,6 +5,7 @@
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger, chain } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { raise } from '@dxos/debug';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
@@ -24,26 +25,26 @@ describe('services/space-invitations-protocol', () => {
   test('genesis', async () => {
     const [peer] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
-    const space = await peer.dataSpaceManager!.createSpace();
+    const space = await peer.dataSpaceManager!.createSpace(new Context());
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
 
-    await space.close();
+    await space.close(new Context());
   });
 
   test('genesis & ready', async () => {
     const [peer] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
-    const space = await peer.dataSpaceManager!.createSpace();
+    const space = await peer.dataSpaceManager!.createSpace(new Context());
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
 
     await peer.dataSpaceManager?.waitUntilSpaceReady(space.key);
-    await space.close();
+    await space.close(new Context());
   });
 
   test('invitation with no auth', async () => {
     const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
-    const space1 = await host.dataSpaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace(new Context());
     const spaceKey = space1.key;
 
     await Promise.all(performInvitation({ host, guest, options: { kind: Invitation.Kind.SPACE, spaceKey } }));
@@ -59,15 +60,15 @@ describe('services/space-invitations-protocol', () => {
 
       await space2.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
 
-      await space1.close();
-      await space2.close();
+      await space1.close(new Context());
+      await space2.close(new Context());
     }
   });
 
   test('invitation when already joined', async () => {
     const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
-    const space1 = await host.dataSpaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace(new Context());
     const spaceKey = space1.key;
 
     await Promise.all(performInvitation({ host, guest, options: { kind: Invitation.Kind.SPACE, spaceKey } }));
@@ -96,7 +97,7 @@ describe('services/space-invitations-protocol', () => {
 
     let attempt = 0;
 
-    const space1 = await host.dataSpaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace(new Context());
 
     const [{ invitation: invitation1, error: error1 }, { invitation: invitation2, error: error2 }] = await Promise.all(
       performInvitation({
@@ -143,8 +144,8 @@ describe('services/space-invitations-protocol', () => {
 
       await space2.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
 
-      await space1.close();
-      await space2.close();
+      await space1.close(new Context());
+      await space2.close(new Context());
     }
 
     expect(
@@ -154,14 +155,14 @@ describe('services/space-invitations-protocol', () => {
 
   test('timeout', async () => {
     const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
-    const space = await host.dataSpaceManager!.createSpace();
+    const space = await host.dataSpaceManager!.createSpace(new Context());
     const hostInvitation = await createInvitation(host, {
       kind: Invitation.Kind.SPACE,
       spaceKey: space.key,
       timeout: 100,
     });
     const invitation = hostInvitation.get();
-    await host.close();
+    await host.close(Context.default());
 
     const guestTimeout = new Trigger();
     const guestInvitation = await acceptInvitation(guest, invitation);
@@ -180,7 +181,7 @@ describe('services/space-invitations-protocol', () => {
     const hostConnected = new Trigger<Invitation>();
     const guestConnected = new Trigger<Invitation>();
 
-    const space1 = await host.dataSpaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace(new Context());
 
     const invitationPromises = performInvitation({
       host,
@@ -213,7 +214,7 @@ describe('services/space-invitations-protocol', () => {
     expect(invitation1?.state).to.eq(Invitation.State.CANCELLED);
     expect(error).to.exist;
 
-    await space1.close();
+    await space1.close(new Context());
   });
 
   // TODO(burdon): Flaky.
@@ -223,7 +224,7 @@ describe('services/space-invitations-protocol', () => {
   //     createPeers(GUEST_COUNT + 1)
   //   );
 
-  //   const hostSpace = await host.dataSpaceManager!.createSpace();
+  //   const hostSpace = await host.dataSpaceManager!.createSpace(new Context());
   //   const swarmKey = PublicKey.random();
   //   const hostObservable = await host.spaceInvitations!.createInvitation(hostSpace, {
   //     swarmKey,

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Context } from '@dxos/context';
 import {
   createCancelDelegatedSpaceInvitationCredential,
   createDelegatedSpaceInvitationCredential,
@@ -12,13 +13,7 @@ import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import {
-  AlreadyJoinedError,
-  type ApiError,
-  AuthorizationError,
-  InvalidInvitationError,
-  SpaceNotFoundError,
-} from '@dxos/protocols';
+import { AlreadyJoinedError, AuthorizationError, InvalidInvitationError, SpaceNotFoundError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type ProfileDocument, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
@@ -28,7 +23,6 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 
 import { type DataSpaceManager, type SigningContext } from '../spaces';
-
 import { type InvitationProtocol } from './invitation-protocol';
 import { computeExpirationTime } from './utils';
 
@@ -48,16 +42,16 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  checkCanInviteNewMembers(): ApiError | undefined {
+  checkCanInviteNewMembers(): Error | undefined {
     if (this._spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     const space = this._spaceManager.spaces.get(this._spaceKey);
     if (space == null) {
       return new SpaceNotFoundError(this._spaceKey);
     }
     if (!space?.inner.spaceState.hasMembershipManagementPermission(this._signingContext.identityKey)) {
-      return new AuthorizationError('No member management permission.');
+      return new AuthorizationError({ message: 'No member management permission.' });
     }
     return undefined;
   }
@@ -148,10 +142,10 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
 
   checkInvitation(invitation: Partial<Invitation>): InvalidInvitationError | AlreadyJoinedError | undefined {
     if (invitation.spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     if (this._spaceManager.spaces.has(invitation.spaceKey)) {
-      return new AlreadyJoinedError('Already joined space.');
+      return new AlreadyJoinedError({ message: 'Already joined space.' });
     }
   }
 
@@ -184,15 +178,16 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     invariant(credential.subject.id.equals(this._signingContext.identityKey));
 
     if (this._spaceManager.spaces.has(assertion.spaceKey)) {
-      throw new AlreadyJoinedError('Already joined space.');
+      throw new AlreadyJoinedError({ message: 'Already joined space.' });
     }
 
     // Create local space.
-    await this._spaceManager.acceptSpace({
+    await this._spaceManager.acceptSpace(Context.default(), {
       spaceKey: assertion.spaceKey,
       genesisFeedKey: assertion.genesisFeedKey,
       controlTimeframe,
       dataTimeframe,
+      tags: assertion.tags,
     });
 
     await this._signingContext.recordCredential(credential);

package/src/packlets/locks/index.ts

@@ -3,4 +3,4 @@
 //
 
 export type * from './resource-lock';
-export * from './node';
+export * from '#locks-platform';

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

@@ -26,6 +26,10 @@ import { getDebugName, jsonify, numericalValues, tracer } from '@dxos/util';
 
 /**
  * Logging service used to spy on logs of the host.
+ *
+ * @deprecated This was created so that logs from the shared worker (WorkerClientServices) could be
+ * seen in the main window console without opening the shared worker DevTools. Shared worker client
+ * services is deprecated; dedicated worker logs already show in the main window console.
  */
 export class LoggingServiceImpl implements LoggingService {
   private readonly _logs = new Event<NaturalLogEntry>();

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

@@ -10,7 +10,6 @@ import { ConnectionState, type NetworkService } from '@dxos/protocols/proto/dxos
 
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
-
 import { NetworkServiceImpl } from './network-service';
 
 describe('NetworkService', () => {

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

@@ -3,6 +3,7 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf/stream';
+import { Context } from '@dxos/context';
 import { type EdgeConnection } from '@dxos/edge-client';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
@@ -48,15 +49,15 @@ export class NetworkServiceImpl implements NetworkService {
   }
 
   async joinSwarm(request: JoinRequest): Promise<void> {
-    return this.signalManager.join(request);
+    return this.signalManager.join(Context.default(), request);
   }
 
   async leaveSwarm(request: LeaveRequest): Promise<void> {
-    return this.signalManager.leave(request);
+    return this.signalManager.leave(Context.default(), request);
   }
 
   async querySwarm(request: QueryRequest): Promise<SwarmResponse> {
-    return this.signalManager.query(request);
+    return this.signalManager.query(Context.default(), request);
   }
 
   subscribeSwarmState(request: SubscribeSwarmStateRequest): Stream<SwarmResponse> {
@@ -70,7 +71,7 @@ export class NetworkServiceImpl implements NetworkService {
   }
 
   async sendMessage(message: Message): Promise<void> {
-    return this.signalManager.sendMessage(message);
+    return this.signalManager.sendMessage(Context.default(), message);
   }
 
   subscribeMessages(peer: Peer): Stream<Message> {

package/src/packlets/services/client-rpc-server.ts

@@ -11,7 +11,7 @@ import { type MaybePromise } from '@dxos/util';
 
 import { type ServiceRegistry } from './service-registry';
 
-export type ClientRpcServerParams = {
+export type ClientRpcServerProps = {
   serviceRegistry: ServiceRegistry<ClientServices>;
   handleCall?: (
     method: string,
@@ -30,8 +30,8 @@ export class ClientRpcServer {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _rpcPeer: RpcPeer;
   private readonly _handlerCache = new Map<string, ServiceHandler<any>>();
-  private readonly _handleCall: ClientRpcServerParams['handleCall'];
-  private readonly _handleStream: ClientRpcServerParams['handleStream'];
+  private readonly _handleCall: ClientRpcServerProps['handleCall'];
+  private readonly _handleStream: ClientRpcServerProps['handleStream'];
 
   @trace.metricsCounter()
   private readonly _callMetrics = new MapCounter();
@@ -41,7 +41,7 @@ export class ClientRpcServer {
     return Object.keys(this._serviceRegistry.services);
   }
 
-  constructor(params: ClientRpcServerParams) {
+  constructor(params: ClientRpcServerProps) {
     const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
     this._handleCall = handleCall;
     this._handleStream = handleStream;