@dxos/client-services 0.6.13-main.548ca8d → 0.6.13-main.ed424a1

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

@@ -355,7 +355,7 @@ export class InvitationsHandler {
     const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
       onInvitationSuccess: async (admissionResponse, admissionRequest) => {
         const result = await protocol.accept(admissionResponse, admissionRequest);
-        log('admitted by edge', { ...protocol.toJSON() });
+        log.info('admitted by edge', { ...protocol.toJSON() });
         guardedState.complete({ ...guardedState.current, ...result, state: Invitation.State.SUCCESS });
       },
     });
@@ -454,7 +454,6 @@ export class InvitationsHandler {
       throw new Error('challenge missing in the introduction');
     }
     log('sending authentication request');
-    setState(Invitation.State.AUTHENTICATING);
     const signature = sign(Buffer.from(introductionResponse.challenge), invitation.guestKeypair.privateKey);
     const response = await extension.rpc.InvitationHostService.authenticate({
       signedChallenge: signature,

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

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Mutex, scheduleMicroTask, Trigger } from '@dxos/async';
+import { Mutex, Trigger } from '@dxos/async';
 import { Context, Resource } from '@dxos/context';
 import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credentials';
 import { failUndefined, warnAfterTimeout } from '@dxos/debug';
@@ -15,7 +15,7 @@ import {
   valueEncoding,
 } from '@dxos/echo-pipeline';
 import { createChainEdgeIdentity, createEphemeralEdgeIdentity } from '@dxos/edge-client';
-import type { EdgeHttpClient, EdgeConnection } from '@dxos/edge-client';
+import type { EdgeHttpClient, EdgeConnection, EdgeIdentity } from '@dxos/edge-client';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
@@ -34,6 +34,7 @@ import { BlobStore } from '@dxos/teleport-extension-object-sync';
 import { trace as Trace } from '@dxos/tracing';
 import { safeInstanceof } from '@dxos/util';
 
+import { EdgeAgentManager } from '../agents';
 import {
   IdentityManager,
   type CreateIdentityOptions,
@@ -42,11 +43,11 @@ import {
 } from '../identity';
 import {
   DeviceInvitationProtocol,
+  type InvitationConnectionParams,
   InvitationsHandler,
   InvitationsManager,
   SpaceInvitationProtocol,
   type InvitationProtocol,
-  type InvitationConnectionParams,
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
@@ -83,6 +84,7 @@ export class ServiceContext extends Resource {
 
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
+  public edgeAgentManager?: EdgeAgentManager;
 
   private readonly _handlerFactories = new Map<
     Invitation.Kind,
@@ -138,40 +140,6 @@ export class ServiceContext extends Resource {
       devicePresenceAnnounceInterval: this._runtimeParams?.devicePresenceAnnounceInterval,
       edgeConnection: this._edgeConnection,
       edgeFeatures: this._edgeFeatures,
-      callbacks: {
-        onIdentityConstruction: (identity) => {
-          if (this._edgeConnection) {
-            scheduleMicroTask(this._ctx, async () => {
-              using _ = await this._edgeIdentityUpdateMutex.acquire();
-
-              log.info('Setting identity on edge connection', {
-                identity: identity.identityKey.toHex(),
-                oldIdentity: this._edgeConnection!.identityKey,
-                swarms: this.networkManager.topics,
-              });
-
-              await warnAfterTimeout(10_000, 'Waiting for identity to be ready for edge connection', async () => {
-                await identity.ready();
-              });
-
-              invariant(identity.deviceCredentialChain);
-              this._edgeConnection!.setIdentity(
-                await createChainEdgeIdentity(
-                  identity.signer,
-                  identity.identityKey,
-                  identity.deviceKey,
-                  identity.deviceCredentialChain,
-                  [], // TODO(dmaretskyi): Service access credentials.
-                ),
-              );
-              this.networkManager.setPeerInfo({
-                identityKey: identity.identityKey.toHex(),
-                peerKey: identity.deviceKey.toHex(),
-              });
-            });
-          }
-        },
-      },
     });
 
     this.echoHost = new EchoHost({ kv: this.level });
@@ -179,7 +147,7 @@ export class ServiceContext extends Resource {
     this._meshReplicator = new MeshEchoReplicator();
 
     this.invitations = new InvitationsHandler(
-      this.networkManager,
+      this.networkManager, //
       this._edgeHttpClient,
       _runtimeParams?.invitationConnectionDefaultParams,
     );
@@ -217,11 +185,12 @@ export class ServiceContext extends Resource {
 
     log('opening...');
     log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
-    if (this._edgeConnection) {
-      // TODO(dmaretskyi): Use device key.
-      this._edgeConnection.setIdentity(await createEphemeralEdgeIdentity());
-      await this._edgeConnection.open();
-    }
+
+    await this.identityManager.open(ctx);
+
+    await this._setNetworkIdentity();
+
+    await this._edgeConnection?.open();
     await this.signalManager.open();
     await this.networkManager.open();
 
@@ -236,9 +205,9 @@ export class ServiceContext extends Resource {
 
     await this.metadataStore.load();
     await this.spaceManager.open();
-    await this.identityManager.open(ctx);
 
     if (this.identityManager.identity) {
+      await this.identityManager.identity.joinNetwork();
       await this._initialize(ctx);
     }
 
@@ -255,6 +224,7 @@ export class ServiceContext extends Resource {
       await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
     }
     await this.dataSpaceManager?.close();
+    await this.edgeAgentManager?.close();
     await this.identityManager.close();
     await this.spaceManager.close();
     await this.feedStore.close();
@@ -270,6 +240,8 @@ export class ServiceContext extends Resource {
 
   async createIdentity(params: CreateIdentityOptions = {}) {
     const identity = await this.identityManager.createIdentity(params);
+    await this._setNetworkIdentity();
+    await identity.joinNetwork();
     await this._initialize(new Context());
     return identity;
   }
@@ -291,7 +263,10 @@ export class ServiceContext extends Resource {
   }
 
   private async _acceptIdentity(params: JoinIdentityParams) {
-    const identity = await this.identityManager.acceptIdentity(params);
+    const { identity, identityRecord } = await this.identityManager.prepareIdentity(params);
+    await this._setNetworkIdentity({ deviceCredential: params.authorizedDeviceCredential! });
+    await identity.joinNetwork();
+    await this.identityManager.acceptIdentity(identity, identityRecord, params.deviceProfile);
     await this._initialize(new Context());
     return identity;
   }
@@ -336,6 +311,14 @@ export class ServiceContext extends Resource {
     });
     await this.dataSpaceManager.open();
 
+    this.edgeAgentManager = new EdgeAgentManager(
+      this._edgeFeatures,
+      this._edgeHttpClient,
+      this.dataSpaceManager,
+      identity,
+    );
+    await this.edgeAgentManager.open();
+
     this._handlerFactories.set(Invitation.Kind.SPACE, (invitation) => {
       invariant(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
       return new SpaceInvitationProtocol(this.dataSpaceManager, signingContext, this.keyring, invitation.spaceKey);
@@ -375,4 +358,51 @@ export class ServiceContext extends Resource {
 
     await identity.space.spaceState.addCredentialProcessor(this._deviceSpaceSync);
   }
+
+  private async _setNetworkIdentity(params?: { deviceCredential: Credential }) {
+    using _ = await this._edgeIdentityUpdateMutex.acquire();
+
+    let edgeIdentity: EdgeIdentity;
+    const identity = this.identityManager.identity;
+    if (identity) {
+      log.info('Setting identity on edge connection', {
+        identity: identity.identityKey.toHex(),
+        swarms: this.networkManager.topics,
+      });
+      if (params?.deviceCredential) {
+        edgeIdentity = await createChainEdgeIdentity(
+          identity.signer,
+          identity.identityKey,
+          identity.deviceKey,
+          { credential: params.deviceCredential },
+          [], // TODO(dmaretskyi): Service access credentials.
+        );
+      } else {
+        // TODO: throw here or from identity if device chain can't be loaded, to avoid indefinite hangup
+        await warnAfterTimeout(10_000, 'Waiting for identity to be ready for edge connection', async () => {
+          await identity.ready();
+        });
+
+        invariant(identity.deviceCredentialChain);
+
+        edgeIdentity = await createChainEdgeIdentity(
+          identity.signer,
+          identity.identityKey,
+          identity.deviceKey,
+          identity.deviceCredentialChain,
+          [], // TODO(dmaretskyi): Service access credentials.
+        );
+      }
+    } else {
+      edgeIdentity = await createEphemeralEdgeIdentity();
+    }
+
+    if (this._edgeConnection) {
+      this._edgeConnection.setIdentity(edgeIdentity);
+    }
+    this.networkManager.setPeerInfo({
+      identityKey: edgeIdentity.identityKey,
+      peerKey: edgeIdentity.peerKey,
+    });
+  }
 }

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

@@ -26,6 +26,7 @@ import { WebsocketRpcClient } from '@dxos/websocket-rpc';
 
 import { ServiceContext, type ServiceContextRuntimeParams } from './service-context';
 import { ServiceRegistry } from './service-registry';
+import { EdgeAgentServiceImpl } from '../agents';
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsHostEvents, DevtoolsServiceImpl } from '../devtools';
 import {
@@ -289,6 +290,11 @@ export class ClientServicesHost {
       return this._serviceContext.dataSpaceManager!;
     };
 
+    const agentManagerProvider = async () => {
+      await this._serviceContext.initialized.wait();
+      return this._serviceContext.edgeAgentManager!;
+    };
+
     const identityService = new IdentityServiceImpl(
       this._serviceContext.identityManager,
       this._serviceContext.keyring,
@@ -330,6 +336,8 @@ export class ClientServicesHost {
         config: this._config,
         context: this._serviceContext,
       }),
+
+      EdgeAgentService: new EdgeAgentServiceImpl(agentManagerProvider),
     });
 
     await this._serviceContext.open(ctx);

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

@@ -35,7 +35,7 @@ import {
   type ObjectStructure,
   type SpaceDoc,
 } from '@dxos/echo-protocol';
-import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
+import { TYPE_PROPERTIES, createObjectId, getTypeReference } from '@dxos/echo-schema';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { writeMessages, type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
@@ -120,6 +120,7 @@ export type DataSpaceManagerParams = {
 export type DataSpaceManagerRuntimeParams = {
   spaceMemberPresenceAnnounceInterval?: number;
   spaceMemberPresenceOfflineTimeout?: number;
+  activeEdgeNotarizationPollingInterval?: number;
   disableP2pReplication?: boolean;
 };
 
@@ -296,7 +297,7 @@ export class DataSpaceManager extends Resource {
       },
     };
 
-    const propertiesId = generateEchoId();
+    const propertiesId = createObjectId();
     document.change((doc: SpaceDoc) => {
       setDeep(doc, ['objects', propertiesId], properties);
     });
@@ -507,6 +508,7 @@ export class DataSpaceManager extends Resource {
       edgeConnection: this._edgeConnection,
       edgeHttpClient: this._edgeHttpClient,
       edgeFeatures: this._edgeFeatures,
+      activeEdgeNotarizationPollingInterval: this._runtimeParams?.activeEdgeNotarizationPollingInterval,
     });
     dataSpace.postOpen.append(async () => {
       const setting = dataSpace.getEdgeReplicationSetting();

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

@@ -82,6 +82,7 @@ export type DataSpaceParams = {
   edgeConnection?: EdgeConnection;
   edgeHttpClient?: EdgeHttpClient;
   edgeFeatures?: Runtime.Client.EdgeFeatures;
+  activeEdgeNotarizationPollingInterval?: number;
 };
 
 export type CreateEpochOptions = {
@@ -146,6 +147,7 @@ export class DataSpace {
       spaceId: this._inner.id,
       edgeClient: params.edgeHttpClient,
       edgeFeatures: params.edgeFeatures,
+      activeEdgePollingInterval: params.activeEdgeNotarizationPollingInterval,
     });
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
@@ -242,6 +244,7 @@ export class DataSpace {
     }
 
     await this._inner.open(new Context());
+    await this._inner.startProtocol();
 
     await this._edgeFeedReplicator?.open();
 

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -3,16 +3,15 @@
 //
 
 import { decode as decodeCbor, encode as encodeCbor } from 'cbor-x';
-import { getRandomPort } from 'get-port-please';
-import { describe, test, onTestFinished, vi, expect } from 'vitest';
+import { getPort } from 'get-port-please';
+import { describe, expect, onTestFinished, test, vi } from 'vitest';
 
-import { Trigger, sleep } from '@dxos/async';
+import { sleep, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { valueEncoding } from '@dxos/echo-pipeline';
 import { createEphemeralEdgeIdentity, EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
-import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { type FeedWrapper } from '@dxos/feed-store';
+import { FeedFactory, FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { SpaceId } from '@dxos/keys';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
@@ -188,7 +187,7 @@ describe('EdgeFeedReplicator', () => {
   });
 
   const createEdge = async () => {
-    const port = await getRandomPort('127.0.0.1');
+    const port = await getPort({ host: 'localhost', port: 7200, portRange: [7200, 7299] });
     let lastBlockIndex = -1;
     const admitConnection = new Trigger();
     const { cleanup, endpoint, messageSink, sendResponseMessage } = await createTestEdgeWsServer(port, {

package/src/packlets/spaces/notarization-plugin.ts

@@ -25,6 +25,8 @@ const DEFAULT_SUCCESS_DELAY = 1_000;
 
 const DEFAULT_NOTARIZE_TIMEOUT = 10_000;
 
+const DEFAULT_ACTIVE_EDGE_POLLING_INTERVAL = 3_000;
+
 const MAX_EDGE_RETRIES = 2;
 
 const WRITER_NOT_SET_ERROR_CODE = 'WRITER_NOT_SET';
@@ -35,6 +37,7 @@ export type NotarizationPluginParams = {
   spaceId: SpaceId;
   edgeClient?: EdgeHttpClient;
   edgeFeatures?: Runtime.Client.EdgeFeatures;
+  activeEdgePollingInterval?: number;
 };
 
 export type NotarizeParams = {
@@ -85,6 +88,9 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
   private readonly _processCredentialsTriggers = new ComplexMap<PublicKey, Trigger>(PublicKey.hash);
 
+  private _activeEdgePollingIntervalHandle: any | undefined = undefined;
+  private readonly _activeEdgePollingInterval: number;
+
   @logInfo
   private readonly _spaceId: SpaceId;
 
@@ -93,11 +99,28 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   constructor(params: NotarizationPluginParams) {
     super();
     this._spaceId = params.spaceId;
+    this._activeEdgePollingInterval = params.activeEdgePollingInterval ?? DEFAULT_ACTIVE_EDGE_POLLING_INTERVAL;
     if (params.edgeClient && params.edgeFeatures?.feedReplicator) {
       this._edgeClient = params.edgeClient;
     }
   }
 
+  setActiveEdgePollingEnabled(enabled: boolean) {
+    invariant(this.isOpen);
+    const client = this._edgeClient;
+    invariant(client);
+    if (enabled && !this._activeEdgePollingIntervalHandle) {
+      this._activeEdgePollingIntervalHandle = setInterval(() => {
+        if (this._writer) {
+          this._notarizePendingEdgeCredentials(client, this._writer);
+        }
+      }, this._activeEdgePollingInterval);
+    } else if (!enabled && this._activeEdgePollingIntervalHandle) {
+      clearInterval(this._activeEdgePollingIntervalHandle);
+      this._activeEdgePollingIntervalHandle = undefined;
+    }
+  }
+
   get hasWriter() {
     return !!this._writer;
   }
@@ -109,6 +132,10 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   }
 
   protected override async _close() {
+    if (this._activeEdgePollingIntervalHandle) {
+      clearInterval(this._activeEdgePollingIntervalHandle);
+      this._activeEdgePollingIntervalHandle = undefined;
+    }
     await this._ctx.dispose();
   }
 

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

@@ -218,6 +218,10 @@ export class TestPeer {
 
   async createIdentity() {
     this._props.signingContext ??= await createSigningContext(this.keyring);
+    this.networkManager.setPeerInfo({
+      identityKey: this._props.signingContext.identityKey.toHex(),
+      peerKey: this._props.signingContext.deviceKey.toHex(),
+    });
   }
 
   async destroy() {

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.6.13-main.548ca8d";
+export const DXOS_VERSION = "0.6.13-main.ed424a1";