@dxos/edge-client 0.8.2-main.36232bc → 0.8.2-main.5885341

package/dist/lib/node-esm/index.mjs

@@ -1,19 +1,21 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  EdgeWsConnection,
+  CLOUDFLARE_MESSAGE_MAX_BYTES,
+  CLOUDFLARE_RPC_MAX_BYTES,
   Protocol,
+  WebSocketMuxer,
   getTypename,
   protocol,
   toUint8Array
-} from "./chunk-HNRMNQPG.mjs";
+} from "./chunk-25HGRGNZ.mjs";
 
 // packages/core/mesh/edge-client/src/index.ts
 export * from "@dxos/protocols/buf/dxos/edge/messenger_pb";
 
 // packages/core/mesh/edge-client/src/edge-client.ts
 import { Trigger, scheduleMicroTask, TriggerState, PersistentLifecycle, Event } from "@dxos/async";
-import { Resource } from "@dxos/context";
-import { log, logInfo } from "@dxos/log";
+import { Resource as Resource2 } from "@dxos/context";
+import { log as log2, logInfo as logInfo2 } from "@dxos/log";
 import { EdgeStatus } from "@dxos/protocols/proto/dxos/client/services";
 
 // packages/core/mesh/edge-client/src/edge-identity.ts
@@ -56,6 +58,261 @@ var handleAuthChallenge = async (failedResponse, identity) => {
   return schema.getCodecForType("dxos.halo.credentials.Presentation").encode(presentation);
 };
 
+// packages/core/mesh/edge-client/src/edge-ws-connection.ts
+import WebSocket from "isomorphic-ws";
+import { scheduleTask, scheduleTaskInterval } from "@dxos/async";
+import { Context, Resource } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log, logInfo } from "@dxos/log";
+import { EdgeWebsocketProtocol } from "@dxos/protocols";
+import { buf } from "@dxos/protocols/buf";
+import { MessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-ws-connection.ts";
+var SIGNAL_KEEPALIVE_INTERVAL = 4e3;
+var SIGNAL_KEEPALIVE_TIMEOUT = 12e3;
+var EdgeWsConnection = class extends Resource {
+  constructor(_identity, _connectionInfo, _callbacks) {
+    super();
+    this._identity = _identity;
+    this._connectionInfo = _connectionInfo;
+    this._callbacks = _callbacks;
+  }
+  get info() {
+    return {
+      open: this.isOpen,
+      identity: this._identity.identityKey,
+      device: this._identity.peerKey
+    };
+  }
+  send(message) {
+    invariant2(this._ws, void 0, {
+      F: __dxlog_file2,
+      L: 52,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    invariant2(this._wsMuxer, void 0, {
+      F: __dxlog_file2,
+      L: 53,
+      S: this,
+      A: [
+        "this._wsMuxer",
+        ""
+      ]
+    });
+    log("sending...", {
+      peerKey: this._identity.peerKey,
+      payload: protocol.getPayloadType(message)
+    }, {
+      F: __dxlog_file2,
+      L: 54,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ws?.protocol.includes(EdgeWebsocketProtocol.V0)) {
+      const binary = buf.toBinary(MessageSchema, message);
+      if (binary.length > CLOUDFLARE_MESSAGE_MAX_BYTES) {
+        log.error("Message dropped because it was too large (>1MB).", {
+          byteLength: binary.byteLength,
+          serviceId: message.serviceId,
+          payload: protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file2,
+          L: 58,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this._ws.send(binary);
+    } else {
+      this._wsMuxer.send(message).catch((e) => log.catch(e, void 0, {
+        F: __dxlog_file2,
+        L: 67,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }
+  }
+  async _open() {
+    const baseProtocols = [
+      ...Object.values(EdgeWebsocketProtocol)
+    ];
+    this._ws = new WebSocket(this._connectionInfo.url.toString(), this._connectionInfo.protocolHeader ? [
+      ...baseProtocols,
+      this._connectionInfo.protocolHeader
+    ] : [
+      ...baseProtocols
+    ]);
+    const muxer = new WebSocketMuxer(this._ws);
+    this._wsMuxer = muxer;
+    this._ws.onopen = () => {
+      if (this.isOpen) {
+        log("connected", void 0, {
+          F: __dxlog_file2,
+          L: 84,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onConnected();
+        this._scheduleHeartbeats();
+      } else {
+        log.verbose("connected after becoming inactive", {
+          currentIdentity: this._identity
+        }, {
+          F: __dxlog_file2,
+          L: 88,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onclose = (event) => {
+      if (this.isOpen) {
+        log.warn("disconnected while being open", {
+          code: event.code,
+          reason: event.reason
+        }, {
+          F: __dxlog_file2,
+          L: 93,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+        muxer.destroy();
+      }
+    };
+    this._ws.onerror = (event) => {
+      if (this.isOpen) {
+        log.warn("edge connection socket error", {
+          error: event.error,
+          info: event.message
+        }, {
+          F: __dxlog_file2,
+          L: 100,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      } else {
+        log.verbose("error ignored on closed connection", {
+          error: event.error
+        }, {
+          F: __dxlog_file2,
+          L: 103,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onmessage = async (event) => {
+      if (!this.isOpen) {
+        log.verbose("message ignored on closed connection", {
+          event: event.type
+        }, {
+          F: __dxlog_file2,
+          L: 111,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (event.data === "__pong__") {
+        this._rescheduleHeartbeatTimeout();
+        return;
+      }
+      const bytes = await toUint8Array(event.data);
+      if (!this.isOpen) {
+        return;
+      }
+      const message = this._ws?.protocol?.includes(EdgeWebsocketProtocol.V0) ? buf.fromBinary(MessageSchema, bytes) : muxer.receiveData(bytes);
+      if (message) {
+        log("received", {
+          from: message.source,
+          payload: protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file2,
+          L: 128,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onMessage(message);
+      }
+    };
+  }
+  async _close() {
+    void this._inactivityTimeoutCtx?.dispose().catch(() => {
+    });
+    try {
+      this._ws?.close();
+      this._ws = void 0;
+      this._wsMuxer?.destroy();
+      this._wsMuxer = void 0;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("WebSocket is closed before the connection is established.")) {
+        return;
+      }
+      log.warn("Error closing websocket", {
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 146,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  _scheduleHeartbeats() {
+    invariant2(this._ws, void 0, {
+      F: __dxlog_file2,
+      L: 151,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    scheduleTaskInterval(this._ctx, async () => {
+      this._ws?.send("__ping__");
+    }, SIGNAL_KEEPALIVE_INTERVAL);
+    this._ws.send("__ping__");
+    this._rescheduleHeartbeatTimeout();
+  }
+  _rescheduleHeartbeatTimeout() {
+    if (!this.isOpen) {
+      return;
+    }
+    void this._inactivityTimeoutCtx?.dispose();
+    this._inactivityTimeoutCtx = new Context(void 0, {
+      F: __dxlog_file2,
+      L: 170
+    });
+    scheduleTask(this._inactivityTimeoutCtx, () => {
+      if (this.isOpen) {
+        log.warn("restart due to inactivity timeout", void 0, {
+          F: __dxlog_file2,
+          L: 175,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      }
+    }, SIGNAL_KEEPALIVE_TIMEOUT);
+  }
+};
+_ts_decorate([
+  logInfo
+], EdgeWsConnection.prototype, "info", null);
+
 // packages/core/mesh/edge-client/src/errors.ts
 var EdgeConnectionClosedError = class extends Error {
   constructor() {
@@ -77,15 +334,15 @@ var getEdgeUrlWithProtocol = (baseUrl, protocol2) => {
 };
 
 // packages/core/mesh/edge-client/src/edge-client.ts
-function _ts_decorate(decorators, target, key, desc) {
+function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-client.ts";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-client.ts";
 var DEFAULT_TIMEOUT = 1e4;
-var EdgeClient = class extends Resource {
+var EdgeClient = class extends Resource2 {
   constructor(_identity, _config) {
     super();
     this._identity = _identity;
@@ -122,11 +379,11 @@ var EdgeClient = class extends Resource {
   }
   setIdentity(identity) {
     if (identity.identityKey !== this._identity.identityKey || identity.peerKey !== this._identity.peerKey) {
-      log("Edge identity changed", {
+      log2("Edge identity changed", {
         identity,
         oldIdentity: this._identity
       }, {
-        F: __dxlog_file2,
+        F: __dxlog_file3,
         L: 99,
         S: this,
         C: (f, a) => f(...a)
@@ -148,8 +405,8 @@ var EdgeClient = class extends Resource {
           try {
             listener();
           } catch (error) {
-            log.catch(error, void 0, {
-              F: __dxlog_file2,
+            log2.catch(error, void 0, {
+              F: __dxlog_file3,
               L: 121,
               S: this,
               C: (f, a) => f(...a)
@@ -164,19 +421,19 @@ var EdgeClient = class extends Resource {
   * Open connection to messaging service.
   */
   async _open() {
-    log("opening...", {
+    log2("opening...", {
       info: this.info
     }, {
-      F: __dxlog_file2,
+      F: __dxlog_file3,
       L: 133,
       S: this,
       C: (f, a) => f(...a)
     });
     this._persistentLifecycle.open().catch((err) => {
-      log.warn("Error while opening connection", {
+      log2.warn("Error while opening connection", {
         err
       }, {
-        F: __dxlog_file2,
+        F: __dxlog_file3,
         L: 135,
         S: this,
         C: (f, a) => f(...a)
@@ -187,10 +444,10 @@ var EdgeClient = class extends Resource {
   * Close connection and free resources.
   */
   async _close() {
-    log("closing...", {
+    log2("closing...", {
       peerKey: this._identity.peerKey
     }, {
-      F: __dxlog_file2,
+      F: __dxlog_file3,
       L: 143,
       S: this,
       C: (f, a) => f(...a)
@@ -206,8 +463,8 @@ var EdgeClient = class extends Resource {
     const path = `/ws/${identity.identityKey}/${identity.peerKey}`;
     const protocolHeader = this._config.disableAuth ? void 0 : await this._createAuthHeader(path);
     if (this._identity !== identity) {
-      log("identity changed during auth header request", void 0, {
-        F: __dxlog_file2,
+      log2("identity changed during auth header request", void 0, {
+        F: __dxlog_file3,
         L: 157,
         S: this,
         C: (f, a) => f(...a)
@@ -216,11 +473,11 @@ var EdgeClient = class extends Resource {
     }
     const restartRequired = new Trigger();
     const url = new URL(path, this._baseWsUrl);
-    log("Opening websocket", {
+    log2("Opening websocket", {
       url: url.toString(),
       protocolHeader
     }, {
-      F: __dxlog_file2,
+      F: __dxlog_file3,
       L: 163,
       S: this,
       C: (f, a) => f(...a)
@@ -234,8 +491,8 @@ var EdgeClient = class extends Resource {
           this._ready.wake();
           this._notifyReconnected();
         } else {
-          log.verbose("connected callback ignored, because connection is not active", void 0, {
-            F: __dxlog_file2,
+          log2.verbose("connected callback ignored, because connection is not active", void 0, {
+            F: __dxlog_file3,
             L: 173,
             S: this,
             C: (f, a) => f(...a)
@@ -247,8 +504,8 @@ var EdgeClient = class extends Resource {
           this._closeCurrentConnection();
           void this._persistentLifecycle.scheduleRestart();
         } else {
-          log.verbose("restart requested by inactive connection", void 0, {
-            F: __dxlog_file2,
+          log2.verbose("restart requested by inactive connection", void 0, {
+            F: __dxlog_file3,
             L: 181,
             S: this,
             C: (f, a) => f(...a)
@@ -260,11 +517,11 @@ var EdgeClient = class extends Resource {
         if (this._isActive(connection)) {
           this._notifyMessageReceived(message);
         } else {
-          log.verbose("ignored a message on inactive connection", {
+          log2.verbose("ignored a message on inactive connection", {
             from: message.source,
             type: message.payload?.typeUrl
           }, {
-            F: __dxlog_file2,
+            F: __dxlog_file3,
             L: 189,
             S: this,
             C: (f, a) => f(...a)
@@ -298,10 +555,10 @@ var EdgeClient = class extends Resource {
       try {
         listener();
       } catch (err) {
-        log.error("ws reconnect listener failed", {
+        log2.error("ws reconnect listener failed", {
           err
         }, {
-          F: __dxlog_file2,
+          F: __dxlog_file3,
           L: 225,
           S: this,
           C: (f, a) => f(...a)
@@ -314,11 +571,11 @@ var EdgeClient = class extends Resource {
       try {
         listener(message);
       } catch (err) {
-        log.error("ws incoming message processing failed", {
+        log2.error("ws incoming message processing failed", {
           err,
           payload: protocol.getPayloadType(message)
         }, {
-          F: __dxlog_file2,
+          F: __dxlog_file3,
           L: 235,
           S: this,
           C: (f, a) => f(...a)
@@ -332,8 +589,8 @@ var EdgeClient = class extends Resource {
   */
   async send(message) {
     if (this._ready.state !== TriggerState.RESOLVED) {
-      log("waiting for websocket to become ready", void 0, {
-        F: __dxlog_file2,
+      log2("waiting for websocket to become ready", void 0, {
+        F: __dxlog_file3,
         L: 246,
         S: this,
         C: (f, a) => f(...a)
@@ -359,11 +616,11 @@ var EdgeClient = class extends Resource {
     if (response.status === 401) {
       return encodePresentationWsAuthHeader(await handleAuthChallenge(response, this._identity));
     } else {
-      log.warn("no auth challenge from edge", {
+      log2.warn("no auth challenge from edge", {
         status: response.status,
         statusText: response.statusText
       }, {
-        F: __dxlog_file2,
+        F: __dxlog_file3,
         L: 271,
         S: this,
         C: (f, a) => f(...a)
@@ -372,8 +629,8 @@ var EdgeClient = class extends Resource {
     }
   }
 };
-_ts_decorate([
-  logInfo
+_ts_decorate2([
+  logInfo2
 ], EdgeClient.prototype, "info", null);
 var encodePresentationWsAuthHeader = (encodedPresentation) => {
   const encodedToken = Buffer.from(encodedPresentation).toString("base64").replace(/=*$/, "").replaceAll("/", "|");
@@ -382,10 +639,10 @@ var encodePresentationWsAuthHeader = (encodedPresentation) => {
 
 // packages/core/mesh/edge-client/src/auth.ts
 import { createCredential, signPresentation } from "@dxos/credentials";
-import { invariant as invariant2 } from "@dxos/invariant";
+import { invariant as invariant3 } from "@dxos/invariant";
 import { Keyring } from "@dxos/keyring";
 import { PublicKey } from "@dxos/keys";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/auth.ts";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/auth.ts";
 var createDeviceEdgeIdentity = async (signer, key) => {
   return {
     identityKey: key.toHex(),
@@ -429,8 +686,8 @@ var createChainEdgeIdentity = async (signer, identityKey, peerKey, chain, creden
     identityKey: identityKey.toHex(),
     peerKey: peerKey.toHex(),
     presentCredentials: async ({ challenge }) => {
-      invariant2(chain, void 0, {
-        F: __dxlog_file3,
+      invariant3(chain, void 0, {
+        F: __dxlog_file4,
         L: 75,
         S: void 0,
         A: [
@@ -493,20 +750,20 @@ var createStubEdgeIdentity = () => {
 
 // packages/core/mesh/edge-client/src/edge-http-client.ts
 import { sleep } from "@dxos/async";
-import { Context } from "@dxos/context";
-import { log as log2 } from "@dxos/log";
+import { Context as Context2 } from "@dxos/context";
+import { log as log3 } from "@dxos/log";
 import { EdgeCallFailedError, EdgeAuthChallengeError } from "@dxos/protocols";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-http-client.ts";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-http-client.ts";
 var DEFAULT_RETRY_TIMEOUT = 1500;
 var DEFAULT_RETRY_JITTER = 500;
 var DEFAULT_MAX_RETRIES_COUNT = 3;
 var EdgeHttpClient = class {
   constructor(baseUrl) {
     this._baseUrl = getEdgeUrlWithProtocol(baseUrl, "http");
-    log2("created", {
+    log3("created", {
       url: this._baseUrl
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 53,
       S: this,
       C: (f, a) => f(...a)
@@ -638,8 +895,8 @@ var EdgeHttpClient = class {
     });
   }
   async _call(path, args) {
-    const requestContext = args.context ?? new Context(void 0, {
-      F: __dxlog_file4,
+    const requestContext = args.context ?? new Context2(void 0, {
+      F: __dxlog_file5,
       L: 192
     });
     const shouldRetry = createRetryHandler(args);
@@ -651,12 +908,12 @@ var EdgeHttpClient = class {
       }
       url += `?${queryParams.toString()}`;
     }
-    log2("call", {
+    log3("call", {
       method: args.method,
       path,
       request: args.body
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 204,
       S: this,
       C: (f, a) => f(...a)
@@ -675,11 +932,11 @@ var EdgeHttpClient = class {
           if (body.success) {
             return body.data;
           }
-          log2("unsuccessful edge response", {
+          log3("unsuccessful edge response", {
             path,
             body
           }, {
-            F: __dxlog_file4,
+            F: __dxlog_file5,
             L: 223,
             S: this,
             C: (f, a) => f(...a)
@@ -700,11 +957,11 @@ var EdgeHttpClient = class {
         processingError = EdgeCallFailedError.fromProcessingFailureCause(error);
       }
       if (processingError.isRetryable && await shouldRetry(requestContext, retryAfterHeaderValue)) {
-        log2("retrying edge request", {
+        log3("retrying edge request", {
           path,
           processingError
         }, {
-          F: __dxlog_file4,
+          F: __dxlog_file5,
           L: 242,
           S: this,
           C: (f, a) => f(...a)
@@ -716,8 +973,8 @@ var EdgeHttpClient = class {
   }
   async _handleUnauthorized(response) {
     if (!this._edgeIdentity) {
-      log2.warn("edge unauthorized response received before identity was set", void 0, {
-        F: __dxlog_file4,
+      log3.warn("edge unauthorized response received before identity was set", void 0, {
+        F: __dxlog_file5,
         L: 251,
         S: this,
         C: (f, a) => f(...a)
@@ -726,8 +983,8 @@ var EdgeHttpClient = class {
     }
     const challenge = await handleAuthChallenge(response, this._edgeIdentity);
     this._authHeader = encodeAuthHeader(challenge);
-    log2("auth header updated", void 0, {
-      F: __dxlog_file4,
+    log3("auth header updated", void 0, {
+      F: __dxlog_file5,
       L: 256,
       S: this,
       C: (f, a) => f(...a)
@@ -770,11 +1027,14 @@ var encodeAuthHeader = (challenge) => {
   return `VerifiablePresentation pb;base64,${encodedChallenge}`;
 };
 export {
+  CLOUDFLARE_MESSAGE_MAX_BYTES,
+  CLOUDFLARE_RPC_MAX_BYTES,
   EdgeClient,
   EdgeConnectionClosedError,
   EdgeHttpClient,
   EdgeIdentityChangedError,
   Protocol,
+  WebSocketMuxer,
   createChainEdgeIdentity,
   createDeviceEdgeIdentity,
   createEphemeralEdgeIdentity,