@dxos/network-manager 0.6.12 → 0.6.13-main.09887cd

package/package.json

@@ -1,36 +1,67 @@
 {
   "name": "@dxos/network-manager",
-  "version": "0.6.12",
+  "version": "0.6.13-main.09887cd",
   "description": "Network Manager",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "DXOS.org",
+  "imports": {
+    "#node-datachannel": {
+      "browser": "./module-stub.js",
+      "workerd": "./module-stub.js",
+      "default": "node-datachannel"
+    },
+    "#node-datachannel/*": {
+      "browser": "./module-stub.js",
+      "workerd": "./module-stub.js",
+      "default": "node-datachannel/*"
+    },
+    "#tcp-transport": {
+      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
+      "node": "./dist/lib/node/transport/tcp/index.cjs",
+      "import": "./dist/lib/browser/transport/tcp/index.mjs",
+      "require": "./dist/lib/node/transport/tcp/index.cjs",
+      "types": "./dist/types/src/transport/tcp/index.d.ts"
+    }
+  },
   "exports": {
     ".": {
       "browser": "./dist/lib/browser/index.mjs",
       "node": {
-        "default": "./dist/lib/node/index.cjs"
+        "require": "./dist/lib/node/index.cjs",
+        "default": "./dist/lib/node-esm/index.mjs"
       },
       "types": "./dist/types/src/index.d.ts"
     },
     "./testing": {
       "browser": "./dist/lib/browser/testing/index.mjs",
       "node": {
-        "default": "./dist/lib/node/testing/index.cjs"
+        "require": "./dist/lib/node/testing/index.cjs",
+        "default": "./dist/lib/node-esm/testing/index.mjs"
       },
       "types": "./dist/types/src/testing/index.d.ts"
+    },
+    "./transport/tcp": {
+      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
+      "node": {
+        "require": "./dist/lib/node/transport/tcp/index.cjs",
+        "default": "./dist/lib/node-esm/transport/tcp/index.mjs"
+      },
+      "types": "./dist/types/src/transport/tcp/index.d.ts"
     }
   },
   "browser": {
-    "./src/transport/tcp-transport.ts": "./src/transport/tcp-transport.browser.ts",
-    "./src/transport/datachannel/index.ts": "./src/transport/datachannel/index.browser.ts"
+    "./src/transport/tcp/tcp-transport.ts": "./src/transport/tcp/tcp-transport.browser.ts"
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
     "*": {
       "testing": [
         "dist/types/src/testing/index.d.ts"
+      ],
+      "transport/tcp": [
+        "dist/types/src/transport/tcp/index.d.ts"
       ]
     }
   },
@@ -41,43 +72,37 @@
     "src"
   ],
   "dependencies": {
-    "@koush/wrtc": "^0.5.3",
     "isomorphic-ws": "^5.0.0",
     "nanomessage-rpc": "^3.0.0",
-    "node-datachannel": "^0.5.5",
+    "node-datachannel": "^0.9.2",
     "p-defer": "^3.0.0",
-    "simple-peer": "9.11.1",
-    "stream": "^0.0.2",
+    "stream": "^0.0.3",
     "tiny-invariant": "^1.3.1",
     "ws": "^8.14.2",
     "xor-distance": "^2.0.0",
-    "@dxos/async": "0.6.12",
-    "@dxos/config": "0.6.12",
-    "@dxos/codec-protobuf": "0.6.12",
-    "@dxos/context": "0.6.12",
-    "@dxos/debug": "0.6.12",
-    "@dxos/credentials": "0.6.12",
-    "@dxos/crypto": "0.6.12",
-    "@dxos/edge-client": "0.6.12",
-    "@dxos/invariant": "0.6.12",
-    "@dxos/keys": "0.6.12",
-    "@dxos/log": "0.6.12",
-    "@dxos/messaging": "0.6.12",
-    "@dxos/node-std": "0.6.12",
-    "@dxos/protocols": "0.6.12",
-    "@dxos/rpc": "0.6.12",
-    "@dxos/util": "0.6.12",
-    "@dxos/teleport": "0.6.12"
+    "@dxos/async": "0.6.13-main.09887cd",
+    "@dxos/context": "0.6.13-main.09887cd",
+    "@dxos/codec-protobuf": "0.6.13-main.09887cd",
+    "@dxos/debug": "0.6.13-main.09887cd",
+    "@dxos/keys": "0.6.13-main.09887cd",
+    "@dxos/invariant": "0.6.13-main.09887cd",
+    "@dxos/log": "0.6.13-main.09887cd",
+    "@dxos/messaging": "0.6.13-main.09887cd",
+    "@dxos/node-std": "0.6.13-main.09887cd",
+    "@dxos/rpc": "0.6.13-main.09887cd",
+    "@dxos/protocols": "0.6.13-main.09887cd",
+    "@dxos/teleport": "0.6.13-main.09887cd",
+    "@dxos/tracing": "0.6.13-main.09887cd",
+    "@dxos/util": "0.6.13-main.09887cd"
   },
   "devDependencies": {
     "@swc-node/register": "1.9.1",
-    "@types/simple-peer": "9.11.3",
     "@types/ws": "^7.4.0",
-    "earljs": "~0.1.10",
     "fast-check": "^3.19.0",
     "fetch-mock": "^11.0.0",
-    "typescript": "^5.5.4",
-    "@dxos/signal": "0.6.12"
+    "@dxos/edge-client": "0.6.13-main.09887cd",
+    "@dxos/keyring": "0.6.13-main.09887cd",
+    "@dxos/signal": "0.6.13-main.09887cd"
   },
   "publishConfig": {
     "access": "public"

package/src/network-manager.ts

@@ -152,31 +152,23 @@ export class SwarmNetworkManager {
    */
   @synchronized
   async joinSwarm({
-    topic,
-    peerInfo,
+    topic, //
     topology,
     protocolProvider: protocol,
     label,
   }: SwarmOptions): Promise<SwarmConnection> {
     invariant(PublicKey.isPublicKey(topic));
-    if (!peerInfo) {
-      peerInfo = {
-        peerKey: this._peerInfo?.peerKey ?? PublicKey.random().toHex(),
-        identityKey: this._peerInfo?.identityKey ?? PublicKey.random().toHex(),
-      };
-    }
-    invariant(PublicKey.from(peerInfo.peerKey));
-    invariant(PublicKey.from(peerInfo.identityKey!));
     invariant(topology);
+    invariant(this._peerInfo);
     invariant(typeof protocol === 'function');
     if (this._swarms.has(topic)) {
       throw new Error(`Already connected to swarm: ${PublicKey.from(topic)}`);
     }
 
-    log('joining', { topic: PublicKey.from(topic), peerInfo, topology: topology.toString() }); // TODO(burdon): Log peerId.
+    log('joining', { topic: PublicKey.from(topic), peerInfo: this._peerInfo, topology: topology.toString() }); // TODO(burdon): Log peerId.
     const swarm = new Swarm(
       topic,
-      peerInfo,
+      this._peerInfo,
       topology,
       protocol,
       this._messenger,
@@ -195,7 +187,7 @@ export class SwarmNetworkManager {
     // Open before joining.
     await swarm.open();
 
-    this._signalConnection.join({ topic, peer: peerInfo }).catch((error) => log.catch(error));
+    this._signalConnection.join({ topic, peer: this._peerInfo }).catch((error) => log.catch(error));
 
     this.topicsUpdated.emit();
     this._connectionLog?.joinedSwarm(swarm);

package/src/signal/ice.test.ts

@@ -2,10 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
 import fetchMock from 'fetch-mock';
-
-import { test, describe } from '@dxos/test';
+import { afterEach, test, expect, describe } from 'vitest';
 
 import { createIceProvider } from './ice';
 

package/src/signal/ice.ts

@@ -24,7 +24,12 @@ export const createIceProvider = (iceProviders: Runtime.Services.IceProvider[]):
           iceProviders.map(({ urls }) =>
             asyncTimeout(fetch(urls, { method: 'GET' }), 10_000)
               .then((response) => response.json())
-              .catch((err) => log.error('Failed to fetch ICE servers from provider', { urls, err })),
+              .catch((err) => {
+                const isDev = typeof window !== 'undefined' && window.location.href.includes('localhost');
+                if (!isDev) {
+                  log.error('Failed to fetch ICE servers from provider', { urls, err });
+                }
+              }),
           ),
         )
       )

package/src/signal/{integration.test.ts → integration.node.test.ts}

@@ -2,15 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/test platform=nodejs
-
-import { expect } from 'earljs';
-import waitForExpect from 'wait-for-expect';
+import { afterAll, onTestFinished, beforeAll, describe, expect, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
 import { Messenger, type PeerInfo, WebsocketSignalManager } from '@dxos/messaging';
 import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
-import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
 import { type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
@@ -35,13 +31,15 @@ describe('Signal Integration Test', () => {
   }) => {
     const signalManager = new WebsocketSignalManager([{ server: broker.url() }]);
     await signalManager.open();
-    afterTest(() => signalManager.close());
+    onTestFinished(async () => {
+      await signalManager.close();
+    });
 
     const messenger = new Messenger({
       signalManager,
     });
     messenger.open();
-    afterTest(() => messenger.close());
+    onTestFinished(() => messenger.close());
     await messenger.listen({
       peer,
       onMessage: async (message) => await messageRouter.receiveMessage(message),
@@ -96,7 +94,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toBeAnObjectWith({ accept: true });
+    ).toEqual(expect.objectContaining({ accept: true }));
 
     expect(
       await peerNetworking2.messageRouter.offer({
@@ -108,7 +106,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toBeAnObjectWith({ accept: true });
+    ).toEqual(expect.objectContaining({ accept: true }));
 
     {
       const message: SignalMessage = {
@@ -123,9 +121,7 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking1.messageRouter.signal(message);
 
-      await waitForExpect(() => {
-        expect(peerNetworking2.receivedSignals[0]).toBeAnObjectWith(message);
-      });
+      await expect.poll(() => peerNetworking2.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }
 
     {
@@ -141,9 +137,7 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking2.messageRouter.signal(message);
 
-      await waitForExpect(() => {
-        expect(peerNetworking1.receivedSignals[0]).toBeAnObjectWith(message);
-      });
+      await expect.poll(() => peerNetworking1.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }
   });
 });

package/src/signal/{swarm-messenger.test.ts → swarm-messenger.node.test.ts}

@@ -2,22 +2,18 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/test platform=nodejs
-
-import { expect } from 'earljs';
-import waitForExpect from 'wait-for-expect';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, onTestFinished } from 'vitest';
 
 import { type Awaited } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { runTestSignalServer } from '@dxos/signal';
-import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
 
 import { type OfferMessage, type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
 
-describe('SwarmMessenger', () => {
+describe('SwarmMessenger', { timeout: 7000 }, () => {
   let topic: PublicKey;
 
   let broker1: Awaited<ReturnType<typeof runTestSignalServer>>;
@@ -48,7 +44,9 @@ describe('SwarmMessenger', () => {
     const peer = { peerKey: PublicKey.random().toHex() };
     const signalManager = new WebsocketSignalManager([{ server: signalApiUrl }]);
     await signalManager.open();
-    afterTest(() => signalManager.close());
+    onTestFinished(async () => {
+      await signalManager.close();
+    });
 
     const messenger = new Messenger({ signalManager });
     await messenger.listen({
@@ -106,10 +104,8 @@ describe('SwarmMessenger', () => {
     };
     await router2.signal(msg);
 
-    await waitForExpect(() => {
-      expect(received[0]).toBeAnObjectWith(msg);
-    }, 4_000);
-  }).timeout(5_000);
+    await expect.poll(() => received[0]).toEqual(expect.objectContaining(msg));
+  });
 
   test('offer/answer', async () => {
     const {
@@ -139,7 +135,7 @@ describe('SwarmMessenger', () => {
       data: { offer: {} },
     });
     expect(answer.accept).toEqual(true);
-  }).timeout(5_000);
+  });
 
   test('signaling between 3 clients', async () => {
     const received1: SignalMessage[] = [];
@@ -198,9 +194,7 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '1to3' } }, signalBatch: undefined },
     };
     await router1.signal(msg1to3);
-    await waitForExpect(() => {
-      expect(received3[0]).toBeAnObjectWith(msg1to3);
-    }, 4_000);
+    await expect.poll(() => received3[0]).toEqual(expect.objectContaining(msg1to3));
 
     // sending signal from peer2 to peer3.
     const msg2to3: SignalMessage = {
@@ -211,9 +205,7 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '2to3' } }, signalBatch: undefined },
     };
     await router2.signal(msg2to3);
-    await waitForExpect(() => {
-      expect(received3[1]).toBeAnObjectWith(msg2to3);
-    }, 4_000);
+    await expect.poll(() => received3[1]).toEqual(expect.objectContaining(msg2to3));
 
     // sending signal from peer3 to peer1.
     const msg3to1: SignalMessage = {
@@ -224,10 +216,8 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '3to1' } }, signalBatch: undefined },
     };
     await router3.signal(msg3to1);
-    await waitForExpect(() => {
-      expect(received1[0]).toBeAnObjectWith(msg3to1);
-    }, 4_000);
-  }).timeout(5_000);
+    await expect.poll(() => received1[0]).toEqual(expect.objectContaining(msg3to1));
+  });
 
   test('two offers', async () => {
     const {
@@ -273,5 +263,5 @@ describe('SwarmMessenger', () => {
       data: { offer: {} },
     });
     expect(answer2.accept).toEqual(true);
-  }).timeout(5_000);
+  });
 });

package/src/swarm/connection-limiter.test.ts

@@ -1,17 +1,14 @@
 //
 // Copyright 2023 DXOS.org
 //
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+
+import { describe, expect, test } from 'vitest';
 
 import { asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { describe, test } from '@dxos/test';
 
 import { ConnectionLimiter } from './connection-limiter';
 
-chai.use(chaiAsPromised);
-
 describe('ConnectionLimiter', () => {
   function* setupPeers(
     limiter: ConnectionLimiter,
@@ -37,7 +34,7 @@ describe('ConnectionLimiter', () => {
   test('rejects if done is called', async () => {
     const limiter = new ConnectionLimiter({ maxConcurrentInitConnections: 1 });
     const [first] = setupPeers(limiter);
-    const testPromise = expect(first.connecting()).to.be.rejected;
+    const testPromise = expect(first.connecting()).rejects.toBeInstanceOf(Error);
     first.doneConnecting();
     await testPromise;
   });

package/src/swarm/connection.test.ts

@@ -2,78 +2,103 @@
 // Copyright 2023 DXOS.org
 //
 
+import { describe, test } from 'vitest';
+
 import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { describe, test } from '@dxos/test';
 
 import { Connection } from './connection';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
-import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
+import { createRtcTransportFactory } from '../transport';
+import { chooseInitiatorPeer } from '../transport/webrtc/utils';
 
 describe('Connection', () => {
+  test('responder opens after initiator', async () => {
+    const { initiator, responder } = createPeerKeys();
+    await connectionTest({
+      fastConnectionKey: initiator,
+      slowConnectionKey: responder,
+    });
+  });
+
   test('initiator opens after responder', async () => {
+    const { initiator, responder } = createPeerKeys();
+    await connectionTest({
+      fastConnectionKey: responder,
+      slowConnectionKey: initiator,
+    });
+  });
+
+  const connectionTest = async (setup: { fastConnectionKey: PublicKey; slowConnectionKey: PublicKey }) => {
     const [topic, sessionId] = PublicKey.randomSequence();
-    const peer1 = { peerKey: PublicKey.random().toHex() };
-    const peer2 = { peerKey: PublicKey.random().toHex() };
-    const protocol1 = new TestWireProtocol(PublicKey.from(peer1.peerKey));
-    const connection1 = new Connection(
+    const slowPeer = { peerKey: setup.slowConnectionKey.toHex() };
+    const fastPeer = { peerKey: setup.fastConnectionKey.toHex() };
+
+    const slowPeerProtocol = new TestWireProtocol();
+    const slowConnection = new Connection(
       topic,
-      peer1,
-      peer2,
+      slowPeer,
+      fastPeer,
       sessionId,
       true,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection2.signal(msg);
+          await fastConnection.signal(msg);
         },
       },
-      protocol1.factory({
+      slowPeerProtocol.factory({
         initiator: true,
-        localPeerId: PublicKey.from(peer1.peerKey),
-        remotePeerId: PublicKey.from(peer2.peerKey),
+        localPeerId: PublicKey.from(slowPeer.peerKey),
+        remotePeerId: PublicKey.from(fastPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    const protocol2 = new TestWireProtocol(PublicKey.from(peer2.peerKey));
-    const connection2 = new Connection(
+    const fastPeerProtocol = new TestWireProtocol();
+    const fastConnection = new Connection(
       topic,
-      peer2,
-      peer1,
+      fastPeer,
+      slowPeer,
       sessionId,
       false,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection1.signal(msg);
+          await slowConnection.signal(msg);
         },
       },
-      protocol2.factory({
+      fastPeerProtocol.factory({
         initiator: false,
-        localPeerId: PublicKey.from(peer2.peerKey),
-        remotePeerId: PublicKey.from(peer1.peerKey),
+        localPeerId: PublicKey.from(fastPeer.peerKey),
+        remotePeerId: PublicKey.from(slowPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    connection2.initiate();
-    await connection2.openConnection();
-    await sleep(100);
+    fastConnection.initiate();
+    await fastConnection.openConnection();
+    await sleep(200);
+
+    slowConnection.initiate();
+    await slowConnection.openConnection();
 
-    connection1.initiate();
-    await connection1.openConnection();
     await Promise.all([
-      protocol1.testConnection(PublicKey.from(peer2.peerKey), 'test message 1'),
-      protocol2.testConnection(PublicKey.from(peer1.peerKey), 'test message 2'),
+      slowPeerProtocol.testConnection(PublicKey.from(fastPeer.peerKey), 'test message 1'),
+      fastPeerProtocol.testConnection(PublicKey.from(slowPeer.peerKey), 'test message 2'),
     ]);
-  });
+  };
+
+  const createPeerKeys = () => {
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const initiator = PublicKey.fromHex(chooseInitiatorPeer(peer1.toHex(), peer2.toHex()));
+    if (initiator.equals(peer1)) {
+      return { initiator: peer1, responder: peer2 };
+    } else {
+      return { initiator: peer2, responder: peer1 };
+    }
+  };
 });

package/src/swarm/connection.ts

@@ -15,7 +15,6 @@ import {
   ConnectionResetError,
   ConnectivityError,
   TimeoutError,
-  UnknownProtocolError,
   trace,
 } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -202,14 +201,15 @@ export class Connection {
 
     invariant(!this._transport);
     this._transport = this._transportFactory.createTransport({
+      ownPeerKey: this.localInfo.peerKey,
+      remotePeerKey: this.remoteInfo.peerKey,
+      topic: this.topic.toHex(),
       initiator: this.initiator,
       stream: this._protocol.stream,
       sendSignal: async (signal) => this._sendSignal(signal),
       sessionId: this.sessionId,
     });
 
-    await this._transport.open();
-
     this._transport.connected.once(async () => {
       this._changeState(ConnectionState.CONNECTED);
       await this.connectedTimeoutContext.dispose();
@@ -238,8 +238,6 @@ export class Connection {
       } else if (err instanceof ConnectivityError) {
         log.info('aborting due to transport ConnectivityError');
         this.abort().catch((err) => this.errors.raise(err));
-      } else if (err instanceof UnknownProtocolError) {
-        log.warn('unsure what to do with UnknownProtocolError, will keep on truckin', { err });
       }
 
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
@@ -248,6 +246,8 @@ export class Connection {
       }
     });
 
+    await this._transport.open();
+
     // Replay signals that were received before transport was created.
     for (const signal of this._incomingSignalBuffer) {
       void this._transport.onSignal(signal); // TODO(burdon): Remove async?