@dxos/client-services 0.3.11-main.68db74e → 0.3.11-main.6901f09

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

@@ -4,6 +4,7 @@
 
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
+import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import {
   type AdmissionRequest,
@@ -46,6 +47,17 @@ export class DeviceInvitationProtocol implements InvitationProtocol {
     };
   }
 
+  checkInvitation(invitation: Partial<Invitation>) {
+    try {
+      const identity = this._getIdentity();
+      if (identity) {
+        return new AlreadyJoinedError('Currently only one identity per client is supported.');
+      }
+    } catch {
+      // No identity.
+    }
+  }
+
   createIntroduction(): IntroductionRequest {
     return {};
   }
@@ -71,6 +83,8 @@ export class DeviceInvitationProtocol implements InvitationProtocol {
     invariant(request.device);
     const { deviceKey, controlFeedKey, dataFeedKey } = request.device;
 
+    // TODO(wittjosiah): When multiple identities are supported, verify identity doesn't already exist before accepting.
+
     await this._acceptIdentity({
       identityKey,
       deviceKey,

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

@@ -2,24 +2,62 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import {
-  type AdmissionRequest,
-  type AdmissionResponse,
-  type IntroductionRequest,
+import type { ApiError } from '@dxos/protocols';
+import type { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import type { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import type {
+  AdmissionRequest,
+  AdmissionResponse,
+  IntroductionRequest,
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 
 export interface InvitationProtocol {
+  //
   // Debugging
+  //
+
+  /**
+   * Protocol-specific debug info to include in logs.
+   */
   toJSON(): object;
 
+  //
   // Host
+  //
+
+  /**
+   * Protocol-specific information to include in the invitation.
+   */
   getInvitationContext(): Partial<Invitation> & Pick<Invitation, 'kind'>;
+
+  /**
+   * Once authentication is successful, the host can admit the guest to the requested resource.
+   */
   admit(request: AdmissionRequest, guestProfile?: ProfileDocument): Promise<AdmissionResponse>;
 
+  //
   // Guest
+  //
+
+  /**
+   * Check if the invitation is valid.
+   *
+   * For example, the guest may already be a member of the space.
+   */
+  checkInvitation(invitation: Partial<Invitation>): ApiError | undefined;
+
+  /**
+   * Get profile information to send to the host to identify the guest.
+   */
   createIntroduction(): IntroductionRequest;
+
+  /**
+   * Get key information to send to the host in order to create an admission credential for the guest.
+   */
   createAdmissionRequest(): Promise<AdmissionRequest>;
+
+  /**
+   * Redeem the admission credential.
+   */
   accept(response: AdmissionResponse, request: AdmissionRequest): Promise<Partial<Invitation>>;
 }

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

@@ -303,9 +303,6 @@ export class InvitationsHandler {
                     }
                   }
                 }
-              } else {
-                // Notify that introduction is complete even if auth is not required.
-                setState({ state: Invitation.State.READY_FOR_AUTHENTICATION });
               }
 
               // 3. Send admission credentials to host (with local space keys).
@@ -355,20 +352,25 @@ export class InvitationsHandler {
     };
 
     scheduleTask(ctx, async () => {
-      invariant(invitation.swarmKey);
-      const topic = invitation.swarmKey;
-      const swarmConnection = await this._networkManager.joinSwarm({
-        topic,
-        peerId: PublicKey.random(),
-        protocolProvider: createTeleportProtocolFactory(async (teleport) => {
-          teleport.addExtension('dxos.halo.invitations', createExtension());
-        }),
-        topology: new StarTopology(topic),
-        label: 'invitation guest',
-      });
-      ctx.onDispose(() => swarmConnection.close());
-
-      setState({ state: Invitation.State.CONNECTING });
+      const error = protocol.checkInvitation(invitation);
+      if (error) {
+        stream.error(error);
+      } else {
+        invariant(invitation.swarmKey);
+        const topic = invitation.swarmKey;
+        const swarmConnection = await this._networkManager.joinSwarm({
+          topic,
+          peerId: PublicKey.random(),
+          protocolProvider: createTeleportProtocolFactory(async (teleport) => {
+            teleport.addExtension('dxos.halo.invitations', createExtension());
+          }),
+          topology: new StarTopology(topic),
+          label: 'invitation guest',
+        });
+        ctx.onDispose(() => swarmConnection.close());
+
+        setState({ state: Invitation.State.CONNECTING });
+      }
     });
 
     const observable = new AuthenticatingInvitation({

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

@@ -7,6 +7,7 @@ import { expect } from 'chai';
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
+import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { afterTest, describe, test } from '@dxos/test';
 
@@ -71,6 +72,33 @@ describe('services/space-invitations-protocol', () => {
     }
   });
 
+  test('invitation when already joined', async () => {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    const space1 = await host.dataSpaceManager!.createSpace();
+    const spaceKey = space1.key;
+
+    await Promise.all(performInvitation({ host, guest, options: { kind: Invitation.Kind.SPACE, spaceKey } }));
+
+    {
+      const space1 = host.dataSpaceManager!.spaces.get(spaceKey)!;
+      const space2 = guest.dataSpaceManager!.spaces.get(spaceKey)!;
+      expect(space1).not.to.be.undefined;
+      expect(space2).not.to.be.undefined;
+
+      await host.dataSpaceManager?.waitUntilSpaceReady(space1.key);
+      await guest.dataSpaceManager?.waitUntilSpaceReady(space2.key);
+    }
+
+    const [_, guestResult] = performInvitation({
+      host,
+      guest,
+      options: { kind: Invitation.Kind.SPACE, spaceKey },
+    });
+
+    expect((await guestResult).error).to.be.instanceOf(AlreadyJoinedError);
+  });
+
   test('creates and accepts invitation with retry', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 

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

@@ -8,6 +8,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 } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -76,6 +77,12 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
+  checkInvitation(invitation: Partial<Invitation>) {
+    if (invitation.spaceKey && this._spaceManager.spaces.has(invitation.spaceKey)) {
+      return new AlreadyJoinedError('Already joined space.');
+    }
+  }
+
   createIntroduction(): IntroductionRequest {
     return {
       profile: this._signingContext.getProfile(),
@@ -104,6 +111,10 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
     invariant(credential.subject.id.equals(this._signingContext.identityKey));
 
+    if (this._spaceManager.spaces.has(assertion.spaceKey)) {
+      throw new AlreadyJoinedError('Already joined space.');
+    }
+
     // Create local space.
     await this._spaceManager.acceptSpace({
       spaceKey: assertion.spaceKey,

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

@@ -12,13 +12,17 @@ import {
 } from '@dxos/protocols/proto/dxos/client/services';
 
 export class NetworkServiceImpl implements NetworkService {
-  constructor(private readonly networkManager: NetworkManager, private readonly signalManager: SignalManager) {}
+  constructor(
+    private readonly networkManager: NetworkManager,
+    private readonly signalManager: SignalManager,
+  ) {}
 
   queryStatus() {
     return new Stream<NetworkStatus>(({ next }) => {
       const update = () => {
         next({
           swarm: this.networkManager.connectionState,
+          connectionInfo: this.networkManager.connectionLog?.swarms,
           signaling: this.signalManager.getStatus().map(({ host, state }) => ({ server: host, state })),
         });
       };

package/src/packlets/services/diagnostics.ts

@@ -18,13 +18,17 @@ import {
   type Metrics,
   type NetworkStatus,
   type Space as SpaceProto,
+  type Platform,
   SpaceMember,
+  type LogEntry,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type SubscribeToFeedsResponse } from '@dxos/protocols/proto/dxos/devtools/host';
 import { type SwarmInfo } from '@dxos/protocols/proto/dxos/devtools/swarm';
 import { type Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Resource, type Span } from '@dxos/protocols/proto/dxos/tracing';
+import { TRACE_PROCESSOR } from '@dxos/tracing';
 
-import { getPlatform, type Platform } from './platform';
+import { getPlatform } from './platform';
 import { type ServiceContext } from './service-context';
 import { DXOS_VERSION } from '../../version';
 import { type DataSpace } from '../spaces';
@@ -32,22 +36,36 @@ import { type DataSpace } from '../spaces';
 const DEFAULT_TIMEOUT = 1_000;
 
 export type Diagnostics = {
-  created: string;
-  platform: Platform;
-  config?: ConfigProto;
   client: {
-    version: string;
-    storage: {
-      version: number;
+    config: ConfigProto;
+    trace: TraceDiagnostic;
+  };
+  services: {
+    trace: TraceDiagnostic;
+    created: string;
+    platform: Platform;
+    config?: ConfigProto;
+    client: {
+      version: string;
+      storage: {
+        version: number;
+      };
     };
+    identity?: Identity;
+    devices?: Device[];
+    spaces?: SpaceStats[];
+    networkStatus?: NetworkStatus;
+    swarms?: SwarmInfo[];
+    feeds?: Partial<SubscribeToFeedsResponse.Feed>[];
+    metrics?: Metrics;
+    storage?: { file: string; count: number }[];
   };
-  identity?: Identity;
-  devices?: Device[];
-  spaces?: SpaceStats[];
-  networkStatus?: NetworkStatus;
-  swarms?: SwarmInfo[];
-  feeds?: Partial<SubscribeToFeedsResponse.Feed>[];
-  metrics?: Metrics;
+};
+
+export type TraceDiagnostic = {
+  resources: Record<string, Resource>;
+  spans: Span[];
+  logs: LogEntry[];
 };
 
 // TODO(burdon): Normalize for ECHO/HALO.
@@ -74,8 +92,8 @@ export const createDiagnostics = async (
   clientServices: Partial<ClientServices>,
   serviceContext: ServiceContext,
   config: Config,
-): Promise<Diagnostics> => {
-  const diagnostics: Diagnostics = {
+): Promise<Diagnostics['services']> => {
+  const diagnostics: Diagnostics['services'] = {
     created: new Date().toISOString(),
     platform: getPlatform(),
     client: {
@@ -84,6 +102,7 @@ export const createDiagnostics = async (
         version: STORAGE_VERSION,
       },
     },
+    trace: TRACE_PROCESSOR.getDiagnostics(),
   };
 
   // Trace metrics.
@@ -95,6 +114,23 @@ export const createDiagnostics = async (
     }).catch(() => undefined);
   }
 
+  if (typeof navigator !== 'undefined' && navigator.storage) {
+    const map = new Map();
+    const dir = await navigator.storage.getDirectory();
+    for await (const filename of (dir as any)?.keys()) {
+      const idx = filename.indexOf('-', filename.indexOf('-') + 1);
+      if (idx === -1) {
+        continue;
+      }
+
+      map.set(filename.slice(0, idx), (map.get(filename.slice(0, idx)) ?? 0) + 1);
+    }
+
+    diagnostics.storage = Array.from(map.entries())
+      .sort((a, b) => b[1] - a[1])
+      .map(([file, count]) => ({ file, count }));
+  }
+
   const identity = serviceContext.identityManager.identity;
   if (identity) {
     // Identity.

package/src/packlets/services/platform.ts

@@ -2,20 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-export type Platform = {
-  type: 'browser' | 'shared-worker' | 'node';
-  userAgent?: string;
-  platform?: string;
-  runtime?: string;
-  uptime?: number;
-  memory?: {
-    rss: number;
-    heapTotal: number;
-    heapUsed: number;
-    external: number;
-    arrayBuffers: number;
-  };
-};
+import { Platform } from '@dxos/protocols/proto/dxos/client/services';
 
 export const getPlatform = (): Platform => {
   if ((process as any).browser) {
@@ -23,14 +10,14 @@ export const getPlatform = (): Platform => {
       // Browser.
       const { userAgent } = window.navigator;
       return {
-        type: 'browser',
+        type: Platform.PLATFORM_TYPE.BROWSER,
         userAgent,
         uptime: Math.floor((Date.now() - window.performance.timeOrigin) / 1_000),
       };
     } else {
       // Shared worker.
       return {
-        type: 'shared-worker',
+        type: Platform.PLATFORM_TYPE.SHARED_WORKER,
         uptime: Math.floor((Date.now() - performance.timeOrigin) / 1_000),
       };
     }
@@ -38,9 +25,10 @@ export const getPlatform = (): Platform => {
     // Node.
     const { platform, version, arch } = process;
     return {
-      type: 'node',
-      platform: `${platform} ${version} ${arch}`,
-      runtime: process.version,
+      type: Platform.PLATFORM_TYPE.NODE,
+      platform,
+      arch,
+      runtime: version,
       uptime: Math.floor(process.uptime()),
       memory: process.memoryUsage(),
     };

package/src/packlets/spaces/automerge-space-state.ts

@@ -9,6 +9,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
   public rootUrl: string | undefined = undefined;
   public lastEpoch: SpecificCredential<Epoch> | undefined = undefined;
 
+  constructor(private readonly _onNewRoot: (rootUrl: string) => void) {}
+
   async processCredential(credential: Credential) {
     if (!checkCredentialType(credential, 'dxos.halo.credentials.Epoch')) {
       return;
@@ -17,6 +19,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
     this.lastEpoch = credential;
     if (credential.subject.assertion.automergeRoot) {
       this.rootUrl = credential.subject.assertion.automergeRoot;
+
+      this._onNewRoot(this.rootUrl);
     }
   }
 }

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

@@ -143,6 +143,9 @@ export class DataSpaceManager {
     const space = await this._constructSpace(metadata);
 
     const automergeRoot = this._automergeHost.repo.create();
+    automergeRoot.change((doc: any) => {
+      doc.experimental_spaceKey = spaceKey.toHex();
+    });
 
     const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, automergeRoot.url);
     await this._metadataStore.addSpace(metadata);
@@ -222,12 +225,13 @@ export class DataSpaceManager {
         credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
-      onNetworkConnection: (session) => {
+      onAuthorizedConnection: (session) => {
         session.addExtension(
           'dxos.mesh.teleport.gossip',
           gossip.createExtension({ remotePeerId: session.remotePeerId }),
         );
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
+        this._automergeHost.authorizeDevice(space.key, session.remotePeerId);
         session.addExtension('dxos.mesh.teleport.automerge', this._automergeHost.createExtension());
       },
       onAuthFailure: () => {

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

@@ -2,9 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
+import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
-import { cancelWithContext, Context } from '@dxos/context';
+import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed } from '@dxos/debug';
 import {
   type MetadataStore,
@@ -15,6 +15,7 @@ import {
   type AutomergeHost,
 } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
+import { failedInvariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -77,9 +78,12 @@ export type DataSpaceParams = {
 const ENABLE_FEED_PURGE = false;
 
 @trackLeaks('open', 'close')
+@trace.resource()
 export class DataSpace {
   private _ctx = new Context();
+  @trace.info()
   private readonly _inner: Space;
+
   private readonly _gossip: Gossip;
   private readonly _presence: Presence;
   private readonly _keyring: Keyring;
@@ -92,7 +96,7 @@ export class DataSpace {
   private readonly _automergeHost: AutomergeHost;
 
   // TODO(dmaretskyi): Move into Space?
-  private readonly _automergeSpaceState = new AutomergeSpaceState();
+  private readonly _automergeSpaceState = new AutomergeSpaceState((rootUrl) => this._onNewAutomergeRoot(rootUrl));
 
   private _state = SpaceState.CLOSED;
 
@@ -137,6 +141,7 @@ export class DataSpace {
     log('new state', { state: SpaceState[this._state] });
   }
 
+  @trace.info()
   get key() {
     return this._inner.key;
   }
@@ -145,6 +150,7 @@ export class DataSpace {
     return this._inner.isOpen;
   }
 
+  @trace.info({ enum: SpaceState })
   get state(): SpaceState {
     return this._state;
   }
@@ -174,6 +180,14 @@ export class DataSpace {
     return this._automergeSpaceState;
   }
 
+  @trace.info({ depth: null })
+  private get _automergeInfo() {
+    return {
+      rootUrl: this._automergeSpaceState.rootUrl,
+      lastEpoch: this._automergeSpaceState.lastEpoch,
+    };
+  }
+
   @synchronized
   async open() {
     await this._open();
@@ -232,7 +246,7 @@ export class DataSpace {
         this.metrics.pipelineInitBegin = new Date();
         await this.initializeDataPipeline();
       } catch (err) {
-        if (err instanceof CancelledError) {
+        if (err instanceof CancelledError || err instanceof ContextDisposedError) {
           log('data pipeline initialization cancelled', err);
           return;
         }
@@ -363,6 +377,25 @@ export class DataSpace {
     }
   }
 
+  private _onNewAutomergeRoot(rootUrl: string) {
+    log('loading automerge root doc for space', { space: this.key, rootUrl });
+    const handle = this._automergeHost.repo.find(rootUrl as any);
+
+    queueMicrotask(async () => {
+      try {
+        await asyncTimeout(handle.whenReady(), 5_000);
+        const doc = handle.docSync() ?? failedInvariant();
+        if (!doc.experimental_spaceKey) {
+          handle.change((doc: any) => {
+            doc.experimental_spaceKey = this.key.toHex();
+          });
+        }
+      } catch (err) {
+        log.warn('error loading automerge root doc', { space: this.key, rootUrl, err });
+      }
+    });
+  }
+
   // TODO(dmaretskyi): Use profile from signing context.
   async updateOwnProfile(profile: ProfileDocument) {
     const credential = await this._signingContext.credentialSigner.createCredential({

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

@@ -41,7 +41,7 @@ export class SpacesServiceImpl implements SpacesService {
 
   async createSpace(): Promise<Space> {
     if (!this._identityManager.identity) {
-      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/halo');
+      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo');
     }
 
     const dataSpaceManager = await this._getDataSpaceManager();
@@ -222,8 +222,8 @@ export class SpacesServiceImpl implements SpacesService {
           presence: member.removed
             ? SpaceMember.PresenceState.REMOVED
             : isMe || peers.length > 0
-            ? SpaceMember.PresenceState.ONLINE
-            : SpaceMember.PresenceState.OFFLINE,
+              ? SpaceMember.PresenceState.ONLINE
+              : SpaceMember.PresenceState.OFFLINE,
           peerStates: peers,
         };
       }),

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

@@ -12,16 +12,18 @@ import {
   type UpdateStatusRequest,
   type QueryStatusRequest,
   type QueryStatusResponse,
+  type Platform,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { jsonKeyReplacer, type MaybePromise } from '@dxos/util';
 
 import { type Diagnostics } from '../services';
+import { getPlatform } from '../services/platform';
 
 export type SystemServiceOptions = {
   config?: Config;
   statusUpdate: Event<void>;
   getCurrentStatus: () => SystemStatus;
-  getDiagnostics: () => Promise<Partial<Diagnostics>>;
+  getDiagnostics: () => Promise<Partial<Diagnostics['services']>>;
   onUpdateStatus: (status: SystemStatus) => MaybePromise<void>;
   onReset: () => MaybePromise<void>;
 };
@@ -73,6 +75,10 @@ export class SystemServiceImpl implements SystemService {
     };
   }
 
+  async getPlatform(): Promise<Platform> {
+    return getPlatform();
+  }
+
   async updateStatus({ status }: UpdateStatusRequest) {
     await this._onUpdateStatus(status);
   }

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

@@ -3,7 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
-import { type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
+import { InvitationEncoder, type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
 import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
@@ -13,15 +13,7 @@ import { ServiceContext } from '../services';
  * Strip secrets from invitation before giving it to the peer.
  */
 export const sanitizeInvitation = (invitation: Invitation): Invitation => {
-  return {
-    invitationId: invitation.invitationId,
-    type: invitation.type,
-    kind: invitation.kind,
-    authMethod: invitation.authMethod,
-    swarmKey: invitation.swarmKey,
-    state: invitation.state,
-    timeout: invitation.timeout,
-  };
+  return InvitationEncoder.decode(InvitationEncoder.encode(invitation));
 };
 
 export type InvitationHost = {

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.3.11-main.68db74e";
+export const DXOS_VERSION = "0.3.11-main.6901f09";