@dxos/network-manager 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/swarm/connection.test.ts

@@ -10,7 +10,6 @@ import { PublicKey } from '@dxos/keys';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { createRtcTransportFactory } from '../transport';
 import { chooseInitiatorPeer } from '../transport/webrtc/utils';
-
 import { Connection } from './connection';
 
 // Segfault in node-datachannel.
@@ -44,9 +43,9 @@ describe.skip('Connection', () => {
       sessionId,
       true,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await fastConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await fastConnection.signal(ctx, msg);
         },
       },
       slowPeerProtocol.factory({
@@ -66,9 +65,9 @@ describe.skip('Connection', () => {
       sessionId,
       false,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await slowConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await slowConnection.signal(ctx, msg);
         },
       },
       fastPeerProtocol.factory({

package/src/swarm/connection.ts

@@ -118,7 +118,7 @@ export class Connection {
   public readonly transportStats = new Event<TransportStats>();
 
   private readonly _signalSendTask = new DeferredTask(this._ctx, async () => {
-    await this._flushSignalBuffer();
+    await this._flushSignalBuffer(this._ctx);
   });
 
   private _signallingDelay = STARTING_SIGNALLING_DELAY;
@@ -185,16 +185,18 @@ export class Connection {
     this._protocol.stream.on('close', () => {
       log('protocol stream closed');
       this._protocolClosed.wake();
-      this.close({ error: new ProtocolError('protocol stream closed') }).catch((err) => this.errors.raise(err));
+      this.close({ error: new ProtocolError({ message: 'protocol stream closed' }) }).catch((err) =>
+        this.errors.raise(err),
+      );
     });
 
     scheduleTask(
       this.connectedTimeoutContext,
       async () => {
         log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect, aborting`);
-        await this.abort(new TimeoutError(`${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect`)).catch(
-          (err) => this.errors.raise(err),
-        );
+        await this.abort(
+          new TimeoutError({ message: `${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect` }),
+        ).catch((err) => this.errors.raise(err));
       },
       TRANSPORT_CONNECTION_TIMEOUT,
     );
@@ -364,21 +366,21 @@ export class Connection {
     this._signalSendTask.schedule();
   }
 
-  private async _flushSignalBuffer(): Promise<void> {
+  private async _flushSignalBuffer(ctx: Context): Promise<void> {
     if (this._outgoingSignalBuffer.length === 0) {
       return;
     }
 
     try {
       if (process.env.NODE_ENV !== 'test') {
-        await cancelWithContext(this._ctx, sleep(this._signallingDelay));
+        await cancelWithContext(ctx, sleep(this._signallingDelay));
         this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
       }
 
       const signals = [...this._outgoingSignalBuffer];
       this._outgoingSignalBuffer.length = 0;
 
-      await this._signalMessaging.signal({
+      await this._signalMessaging.signal(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId: this.sessionId,
@@ -397,14 +399,14 @@ export class Connection {
 
       // If signal fails treat connection as failed
       log.info('signal message failed to deliver', { err });
-      await this.close({ error: new ConnectivityError('signal message failed to deliver', err) });
+      await this.close({ error: new ConnectivityError({ message: 'signal message failed to deliver', cause: err }) });
     }
   }
 
   /**
    * Receive a signal from the remote peer.
    */
-  async signal(msg: SignalMessage): Promise<void> {
+  async signal(_ctx: Context, msg: SignalMessage): Promise<void> {
     invariant(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('dropping signal for incorrect session id');

package/src/swarm/peer.ts

@@ -14,13 +14,12 @@ import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { type OfferMessage, type SignalMessage, type SignalMessenger } from '../signal';
 import { type TransportFactory } from '../transport';
 import { type WireProtocolProvider } from '../wire-protocol';
-
 import { Connection, ConnectionState } from './connection';
 import { type ConnectionLimiter } from './connection-limiter';
 
 export class ConnectionDisplacedError extends SystemError {
   constructor() {
-    super('Connection displaced by remote initiator.');
+    super({ message: 'Connection displaced by remote initiator.' });
   }
 }
 
@@ -106,7 +105,7 @@ export class Peer {
   /**
    * Respond to remote offer.
    */
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(_ctx: Context, message: OfferMessage): Promise<Answer> {
     const remote = message.author;
 
     if (
@@ -162,13 +161,14 @@ export class Peer {
         return { accept: true };
       }
     }
+
     return { accept: false };
   }
 
   /**
    * Initiate a connection to the remote peer.
    */
-  async initiateConnection(): Promise<void> {
+  async initiateConnection(ctx: Context): Promise<void> {
     invariant(!this.initiating, 'Initiation in progress.');
     invariant(!this.connection, 'Already connected.');
     const sessionId = PublicKey.random();
@@ -182,7 +182,7 @@ export class Peer {
       await this._connectionLimiter.connecting(sessionId);
       connection.initiate();
 
-      answer = await this._signalMessaging.offer({
+      answer = await this._signalMessaging.offer(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId,
@@ -377,13 +377,13 @@ export class Peer {
     log('closed', { peerId: this.remoteInfo, sessionId: connection.sessionId });
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     if (!this.connection) {
       log('dropping signal message for non-existent connection', { message });
       return;
     }
 
-    await this.connection.signal(message);
+    await this.connection.signal(ctx, message);
   }
 
   @synchronized

package/src/swarm/swarm.test.ts

@@ -18,7 +18,6 @@ import { ComplexSet } from '@dxos/util';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
 import { createRtcTransportFactory } from '../transport';
-
 import { ConnectionState } from './connection';
 import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
@@ -159,9 +158,9 @@ describe.skip('Swarm', () => {
     const messages = new ComplexSet<{ author: PeerInfo; recipient: PeerInfo }>(
       ({ author, recipient }) => author.peerKey + recipient.peerKey,
     );
-    signalManager.sendMessage = async (message) => {
+    signalManager.sendMessage = async (ctx, message) => {
       messages.add({ author: message.author, recipient: message.recipient });
-      return sendOriginal(message);
+      return sendOriginal(ctx, message);
     };
     // Stop signaling to stop connection in initiation state.
     signalManager.freeze();

package/src/swarm/swarm.ts

@@ -18,7 +18,6 @@ import { type SwarmController, type Topology } from '../topology';
 import { type TransportFactory } from '../transport';
 import { type Topic } from '../types';
 import { type WireProtocolProvider } from '../wire-protocol';
-
 import { type Connection, ConnectionState } from './connection';
 import { type ConnectionLimiter } from './connection-limiter';
 import { Peer } from './peer';
@@ -94,9 +93,9 @@ export class Swarm {
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new SwarmMessenger({
-      sendMessage: async (msg) => await this._messenger.sendMessage(msg),
-      onSignal: async (msg) => await this.onSignal(msg),
-      onOffer: async (msg) => await this.onOffer(msg),
+      sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
+      onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
+      onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
       topic: this._topic,
     });
     log.trace('dxos.mesh.swarm.constructor', trace.end({ id: this._instanceId }));
@@ -136,7 +135,7 @@ export class Swarm {
       payloadType: 'dxos.mesh.swarm.SwarmMessage',
       onMessage: async (message) => {
         await this._swarmMessenger
-          .receiveMessage(message)
+          .receiveMessage(this._ctx, message)
           // TODO(nf): discriminate between errors
           .catch((err) => log.info('Error while receiving message', { err }));
       },
@@ -205,7 +204,7 @@ export class Swarm {
   }
 
   @synchronized
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(ctx: Context, message: OfferMessage): Promise<Answer> {
     log('offer', { message });
     if (this._ctx.disposed) {
       log('ignored for disposed swarm');
@@ -224,7 +223,7 @@ export class Swarm {
     }
 
     const peer = this._getOfferSenderPeer(message.author);
-    const answer = await peer.onOffer(message);
+    const answer = await peer.onOffer(ctx, message);
     this._topology.update();
     return answer;
   }
@@ -243,7 +242,7 @@ export class Swarm {
     return peer;
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     log('signal', { message });
     if (this._ctx.disposed) {
       log.info('ignored for offline swarm');
@@ -257,7 +256,7 @@ export class Swarm {
     invariant(message.author);
 
     const peer = this._getOrCreatePeer(message.author);
-    await peer.onSignal(message);
+    await peer.onSignal(ctx, message);
   }
 
   // For debug purposes
@@ -404,7 +403,7 @@ export class Swarm {
     }
 
     log('initiating connection...', { remotePeer });
-    await peer.initiateConnection();
+    await peer.initiateConnection(ctx);
     this._topology.update();
     log('initiated', { remotePeer });
   }

package/src/testing/test-builder.ts

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -28,7 +29,6 @@ import {
   TransportKind,
   createRtcTransportFactory,
 } from '../transport';
-
 import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 
 // Signal server will be started by the setup script.
@@ -169,7 +169,7 @@ export class TestPeer {
 
     await this._proxy?.close();
     await this._service?.close();
-    await this._networkManager.close();
+    await this._networkManager.close(Context.default());
   }
 
   getSwarm(topic: PublicKey): TestSwarmConnection {
@@ -218,7 +218,7 @@ export class TestSwarmConnection {
   // TODO(burdon): Need to create new plugin instance per swarm?
   //  If so, then perhaps joinSwarm should return swarm object with access to plugins.
   async join(topology = new FullyConnectedTopology()): Promise<this> {
-    await this.peer._networkManager.joinSwarm({
+    await this.peer._networkManager.joinSwarm(Context.default(), {
       topic: this.topic,
       peerInfo: { peerKey: this.peer.peerId.toHex(), identityKey: this.peer.peerId.toHex() },
       protocolProvider: this.protocol.factory,
@@ -229,7 +229,7 @@ export class TestSwarmConnection {
   }
 
   async leave(): Promise<this> {
-    await this.peer._networkManager.leaveSwarm(this.topic);
+    await this.peer._networkManager.leaveSwarm(Context.default(), this.topic);
     return this;
   }
 }

package/src/tests/basic-test-suite.ts

@@ -11,7 +11,6 @@ import { range } from '@dxos/util';
 
 import { type TestBuilder } from '../testing';
 import { FullyConnectedTopology, StarTopology } from '../topology';
-
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 
 // TODO(burdon): Use PublicKey throughout (remove conversion to strings, from buffers, etc.)

package/src/tests/memory-transport.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { randomBytes } from 'node:crypto';
-
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
@@ -11,7 +10,6 @@ import { range } from '@dxos/util';
 
 import { TestBuilder } from '../testing';
 import { FullyConnectedTopology } from '../topology';
-
 import { basicTestSuite } from './basic-test-suite';
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 

package/src/tests/property-test-suite.ts

@@ -6,6 +6,7 @@ import * as fc from 'fast-check';
 import { type ModelRunSetup } from 'fast-check';
 import { test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { todo } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { ComplexMap, ComplexSet, range } from '@dxos/util';
@@ -97,7 +98,7 @@ export const propertyTestSuite = () => {
         model.joinedPeers.delete(this.peerId);
 
         const peer = real.peers.get(this.peerId);
-        await peer!.networkManager.close();
+        await peer!.networkManager.close(Context.default());
         real.peers.delete(this.peerId);
 
         await assertState(model, real);
@@ -119,7 +120,7 @@ export const propertyTestSuite = () => {
         // afterTest(() => presence.stop());
         // const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
 
-        await peer.networkManager.joinSwarm({
+        await peer.networkManager.joinSwarm(Context.default(), {
           peerInfo: {
             peerKey: this.peerId.toHex(),
             identityKey: this.peerId.toHex(),
@@ -146,7 +147,7 @@ export const propertyTestSuite = () => {
         model.joinedPeers.delete(this.peerId);
 
         const peer = real.peers.get(this.peerId)!;
-        await peer.networkManager.leaveSwarm(model.topic);
+        await peer.networkManager.leaveSwarm(Context.default(), model.topic);
         peer.presence = undefined;
 
         await assertState(model, real);

package/src/tests/tcp-transport.node.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { randomBytes } from 'node:crypto';
-
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
@@ -12,7 +11,6 @@ import { range } from '@dxos/util';
 import { TestBuilder } from '../testing';
 import { FullyConnectedTopology } from '../topology';
 import { TransportKind } from '../transport';
-
 import { basicTestSuite } from './basic-test-suite';
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 

package/src/tests/webrtc-transport.test.ts

@@ -5,7 +5,6 @@
 import { describe } from 'vitest';
 
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
-
 import { basicTestSuite } from './basic-test-suite';
 
 // Segfault in node-datachannel.

package/src/transport/tcp/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './tcp-transport';
+export * from '#tcp-transport-impl';

package/src/transport/webrtc/rtc-peer-connection.ts

@@ -11,7 +11,6 @@ import { trace } from '@dxos/tracing';
 
 import type { IceProvider } from '../../signal';
 import { type TransportOptions } from '../transport';
-
 import { type RtcConnectionFactory } from './rtc-connection-factory';
 import { RtcTransportChannel } from './rtc-transport-channel';
 import { areSdpEqual, chooseInitiatorPeer } from './utils';
@@ -469,7 +468,7 @@ type IceCandidateErrorDetails = { url: string; errorCode: number; errorText: str
 
 const createIceFailureError = (details: IceCandidateErrorDetails[]) => {
   const candidateErrors = details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`);
-  return new ConnectivityError(`ICE failed:\n${candidateErrors.join('\n')}`);
+  return new ConnectivityError({ message: `ICE failed:\n${candidateErrors.join('\n')}` });
 };
 
 type ChannelCreatedCallback = {

package/src/transport/webrtc/rtc-transport-channel.test.ts

@@ -3,13 +3,11 @@
 //
 
 import { Duplex } from 'node:stream';
-
 import { describe, expect, test } from 'vitest';
 
 import { sleep } from '@dxos/async';
 
 import { type TransportOptions } from '../transport';
-
 import { type RtcPeerConnection } from './rtc-peer-connection';
 import { RtcTransportChannel } from './rtc-transport-channel';
 import { handleChannelErrors } from './test-utils';

package/src/transport/webrtc/rtc-transport-channel.ts

@@ -13,7 +13,6 @@ import { ConnectivityError } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { type Transport, type TransportOptions, type TransportStats } from '../transport';
-
 import { type RtcPeerConnection } from './rtc-peer-connection';
 import { createRtcTransportStats, describeSelectedRemoteCandidate } from './rtc-transport-stats';
 
@@ -71,7 +70,7 @@ export class RtcTransportChannel extends Resource implements Transport {
           const error =
             err instanceof Error
               ? err
-              : new ConnectivityError(`Failed to create a channel: ${JSON.stringify(err?.message)}`);
+              : new ConnectivityError({ message: `Failed to create a channel: ${JSON.stringify(err?.message)}` });
           this.errors.raise(error);
         } else {
           log.verbose('connection establishment failed after transport was closed', { err });

package/src/transport/webrtc/rtc-transport-factory.ts

@@ -4,7 +4,6 @@
 
 import type { IceProvider } from '../../signal';
 import type { TransportFactory } from '../transport';
-
 import { getRtcConnectionFactory } from './rtc-connection-factory';
 import { RtcPeerConnection } from './rtc-peer-connection';
 

package/src/transport/webrtc/rtc-transport-proxy.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { Duplex } from 'stream';
-
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event as AsyncEvent, TestStream, Trigger, sleep } from '@dxos/async';
@@ -14,7 +13,6 @@ import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { type RpcPort, createLinkedPorts, createProtoRpcPeer } from '@dxos/rpc';
 
 import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from '../transport';
-
 import { RtcTransportProxy } from './rtc-transport-proxy';
 import { RtcTransportService } from './rtc-transport-service';
 import { handleChannelErrors } from './test-utils';

package/src/transport/webrtc/rtc-transport-proxy.ts

@@ -176,7 +176,9 @@ export class RtcTransportProxy extends Resource implements Transport {
     } catch (error) {
       const type = signalEvent.payload.payload.data?.type;
       if (type === 'offer' || type === 'answer') {
-        this._raiseIfOpen(new ConnectivityError(`Session establishment failed: ${type} couldn't be sent.`));
+        this._raiseIfOpen(
+          new ConnectivityError({ message: `Session establishment failed: ${type} couldn't be sent.` }),
+        );
       }
     }
   }
@@ -255,11 +257,11 @@ export class RtcTransportProxyFactory implements TransportFactory {
 const decodeError = (err: Error | string) => {
   const message = typeof err === 'string' ? err : err.message;
   if (message.includes('CONNECTION_RESET')) {
-    return new ConnectionResetError(message);
+    return new ConnectionResetError({ message });
   } else if (message.includes('TIMEOUT')) {
-    return new TimeoutError(message);
+    return new TimeoutError({ message });
   } else if (message.includes('CONNECTIVITY_ERROR')) {
-    return new ConnectivityError(message);
+    return new ConnectivityError({ message });
   } else {
     return typeof err === 'string' ? new Error(err) : err;
   }

package/src/transport/webrtc/rtc-transport-service.ts

@@ -25,7 +25,6 @@ import { ComplexMap } from '@dxos/util';
 
 import { type IceProvider } from '../../signal';
 import { type Transport, type TransportFactory } from '../transport';
-
 import { createRtcTransportFactory } from './rtc-transport-factory';
 
 type TransportState = {

package/src/transport/webrtc/rtc-transport.test.ts

@@ -8,7 +8,6 @@ import { TestStream, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 
 import { type TransportOptions } from '../transport';
-
 import { getRtcConnectionFactory } from './rtc-connection-factory';
 import { RtcPeerConnection } from './rtc-peer-connection';
 import { type RtcTransportChannel } from './rtc-transport-channel';

package/src/wire-protocol.ts

@@ -5,16 +5,16 @@
 import { type Duplex } from 'node:stream';
 
 import { type PublicKey } from '@dxos/keys';
-import { Teleport, type TeleportParams } from '@dxos/teleport';
+import { Teleport, type TeleportProps } from '@dxos/teleport';
 
-export type WireProtocolParams = {
+export type WireProtocolProps = {
   initiator: boolean;
   localPeerId: PublicKey;
   remotePeerId: PublicKey;
   topic: PublicKey;
 };
 
-export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
+export type WireProtocolProvider = (params: WireProtocolProps) => WireProtocol;
 
 /**
  * Application-specific network protocol that is used when a connection to a peer is established.
@@ -31,15 +31,15 @@ export interface WireProtocol {
 /**
  * Create a wire-protocol provider backed by a teleport instance.
  * @param onConnection Called after teleport is initialized for the session. Protocol extensions could be attached here.
- * @param defaultParams Optionally provide default Teleport params that might be overridden by factory callers.
+ * @param defaultProps Optionally provide default Teleport params that might be overridden by factory callers.
  * @returns
  */
 export const createTeleportProtocolFactory = (
   onConnection: (teleport: Teleport) => Promise<void>,
-  defaultParams?: Partial<TeleportParams>,
+  defaultProps?: Partial<TeleportProps>,
 ): WireProtocolProvider => {
   return (params) => {
-    const teleport = new Teleport({ ...defaultParams, ...params });
+    const teleport = new Teleport({ ...defaultProps, ...params });
     return {
       stream: teleport.stream,
       open: async (sessionId?: PublicKey) => {