@dxos/teleport 0.1.23 → 0.1.24

package/dist/lib/browser/chunk-F3DXMBSX.mjs

@@ -0,0 +1,657 @@
+import "@dxos/node-std/globals"
+
+// packages/core/mesh/teleport/src/muxing/framer.ts
+import assert from "@dxos/node-std/assert";
+import { Duplex } from "@dxos/node-std/stream";
+import * as varint from "varint";
+var Framer = class {
+  constructor() {
+    this._stream = new Duplex({
+      objectMode: false,
+      read: () => {
+      },
+      write: (chunk, encoding, callback) => {
+        assert(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.");
+        if (this._buffer && this._buffer.length > 0) {
+          this._buffer = Buffer.concat([
+            this._buffer,
+            chunk
+          ]);
+        } else {
+          this._buffer = chunk;
+        }
+        if (this._messageCb) {
+          this._popFrames();
+          callback();
+        } else {
+          this._subscribeCb = () => {
+            this._popFrames();
+            this._subscribeCb = void 0;
+            callback();
+          };
+        }
+      }
+    });
+    this.port = {
+      send: (message) => {
+        this._stream.push(encodeFrame(message));
+      },
+      subscribe: (callback) => {
+        var _a;
+        assert(!this._messageCb, "Rpc port already has a message listener.");
+        this._messageCb = callback;
+        (_a = this._subscribeCb) == null ? void 0 : _a.call(this);
+        return () => {
+          this._messageCb = void 0;
+        };
+      }
+    };
+  }
+  get stream() {
+    return this._stream;
+  }
+  /**
+  * Attempts to pop frames from the buffer and call the message callback.
+  */
+  _popFrames() {
+    let offset = 0;
+    while (offset < this._buffer.length) {
+      const frame = decodeFrame(this._buffer, offset);
+      if (!frame) {
+        break;
+      }
+      offset += frame.bytesConsumed;
+      this._messageCb(frame.payload);
+    }
+    if (offset < this._buffer.length) {
+      this._buffer = this._buffer.subarray(offset);
+    } else {
+      this._buffer = void 0;
+    }
+  }
+  destroy() {
+    this._stream.destroy();
+  }
+};
+var decodeFrame = (buffer, offset) => {
+  try {
+    const frameLength = varint.decode(buffer, offset);
+    const tagLength = varint.decode.bytes;
+    if (buffer.length < offset + tagLength + frameLength) {
+      return void 0;
+    }
+    const payload = buffer.subarray(offset + tagLength, offset + tagLength + frameLength);
+    return {
+      payload,
+      bytesConsumed: tagLength + frameLength
+    };
+  } catch (err) {
+    if (err instanceof RangeError) {
+      return void 0;
+    } else {
+      throw err;
+    }
+  }
+};
+var encodeFrame = (payload) => {
+  const tagLength = varint.encodingLength(payload.length);
+  const frame = Buffer.allocUnsafe(tagLength + payload.length);
+  varint.encode(payload.length, frame);
+  frame.set(payload, tagLength);
+  return frame;
+};
+
+// packages/core/mesh/teleport/src/muxing/muxer.ts
+import assert2 from "@dxos/node-std/assert";
+import { Duplex as Duplex2 } from "@dxos/node-std/stream";
+import { Event } from "@dxos/async";
+import { failUndefined } from "@dxos/debug";
+import { log } from "@dxos/log";
+import { schema } from "@dxos/protocols";
+var codec = schema.getCodecForType("dxos.mesh.muxer.Command");
+var Muxer = class {
+  constructor() {
+    this._framer = new Framer();
+    this.stream = this._framer.stream;
+    this._channelsByLocalId = /* @__PURE__ */ new Map();
+    this._channelsByTag = /* @__PURE__ */ new Map();
+    this._nextId = 0;
+    this._destroyed = false;
+    this._destroying = false;
+    this.close = new Event();
+    this._framer.port.subscribe((msg) => {
+      this._handleCommand(codec.decode(msg));
+    });
+  }
+  /**
+  * Creates a duplex Node.js-style stream.
+  * The remote peer is expected to call `createStream` with the same tag.
+  * The stream is immediately readable and writable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  createStream(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    assert2(!channel.push, `Channel already open: ${tag}`);
+    const stream = new Duplex2({
+      write: (data, encoding, callback) => {
+        this._sendData(channel, data);
+        callback();
+      },
+      read: () => {
+      }
+      // No-op. We will push data when we receive it.
+    });
+    channel.push = (data) => {
+      stream.push(data);
+    };
+    channel.destroy = (err) => {
+      stream.destroy(err);
+    };
+    this._sendCommand({
+      openChannel: {
+        id: channel.id,
+        tag: channel.tag,
+        contentType: channel.contentType
+      }
+    });
+    return stream;
+  }
+  /**
+  * Creates an RPC port.
+  * The remote peer is expected to call `createPort` with the same tag.
+  * The port is immediately usable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  createPort(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    assert2(!channel.push, `Channel already open: ${tag}`);
+    let inboundBuffer = [];
+    let callback;
+    channel.push = (data) => {
+      if (callback) {
+        callback(data);
+      } else {
+        inboundBuffer.push(data);
+      }
+    };
+    const port = {
+      send: (data) => {
+        this._sendData(channel, data);
+      },
+      subscribe: (cb) => {
+        assert2(!callback, "Only one subscriber is allowed");
+        callback = cb;
+        for (const data of inboundBuffer) {
+          cb(data);
+        }
+        inboundBuffer = [];
+      }
+    };
+    this._sendCommand({
+      openChannel: {
+        id: channel.id,
+        tag: channel.tag,
+        contentType: channel.contentType
+      }
+    });
+    return port;
+  }
+  /**
+  * Force-close with optional error.
+  */
+  destroy(err) {
+    if (this._destroying) {
+      return;
+    }
+    this._destroying = true;
+    this._sendCommand({
+      destroy: {
+        error: err == null ? void 0 : err.message
+      }
+    });
+    this._dispose();
+  }
+  _dispose(err) {
+    var _a;
+    if (this._destroyed) {
+      return;
+    }
+    this._destroyed = true;
+    this._framer.destroy();
+    for (const channel of this._channelsByTag.values()) {
+      (_a = channel.destroy) == null ? void 0 : _a.call(channel, err);
+    }
+    this.close.emit(err);
+    this._channelsByLocalId.clear();
+    this._channelsByTag.clear();
+  }
+  _handleCommand(cmd) {
+    var _a;
+    log("Received command", {
+      cmd
+    }, {
+      file: "muxer.ts",
+      line: 194,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._destroyed || this._destroying) {
+      log.warn("Received command after destroy", {}, {
+        file: "muxer.ts",
+        line: 197,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (cmd.openChannel) {
+      const channel = this._getOrCreateStream({
+        tag: cmd.openChannel.tag,
+        contentType: cmd.openChannel.contentType
+      });
+      channel.remoteId = cmd.openChannel.id;
+      for (const data of channel.buffer) {
+        this._sendCommand({
+          data: {
+            channelId: channel.remoteId,
+            data
+          }
+        });
+      }
+      channel.buffer = [];
+    } else if (cmd.data) {
+      const stream = (_a = this._channelsByLocalId.get(cmd.data.channelId)) != null ? _a : failUndefined();
+      if (!stream.push) {
+        log.warn("Received data for channel before it was opened", {
+          tag: stream.tag
+        }, {
+          file: "muxer.ts",
+          line: 221,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        return;
+      }
+      stream.push(cmd.data.data);
+    } else if (cmd.destroy) {
+      this._dispose();
+    }
+  }
+  _sendCommand(cmd) {
+    Promise.resolve(this._framer.port.send(codec.encode(cmd))).catch((err) => {
+      this.destroy(err);
+    });
+  }
+  _getOrCreateStream(params) {
+    let channel = this._channelsByTag.get(params.tag);
+    if (!channel) {
+      channel = {
+        id: this._nextId++,
+        remoteId: null,
+        tag: params.tag,
+        contentType: params.contentType,
+        buffer: [],
+        push: null,
+        destroy: null
+      };
+      this._channelsByTag.set(channel.tag, channel);
+      this._channelsByLocalId.set(channel.id, channel);
+    }
+    return channel;
+  }
+  _sendData(channel, data) {
+    if (channel.remoteId === null) {
+      channel.buffer.push(data);
+    } else {
+      this._sendCommand({
+        data: {
+          channelId: channel.remoteId,
+          data
+        }
+      });
+    }
+  }
+};
+
+// packages/core/mesh/teleport/src/teleport.ts
+import assert3 from "@dxos/node-std/assert";
+import { asyncTimeout, scheduleTaskInterval, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { schema as schema2 } from "@dxos/protocols";
+import { createProtoRpcPeer, RpcClosedError } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+var __decorate = function(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 Teleport = class {
+  constructor({ initiator, localPeerId, remotePeerId }) {
+    this._ctx = new Context({
+      onError: (err) => {
+        void this.destroy(err).catch(() => {
+          log2.error("Error during destroy", err, {
+            file: "teleport.ts",
+            line: 34,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        });
+      }
+    });
+    this._muxer = new Muxer();
+    this._control = new ControlExtension({
+      heartbeatInterval: 3e3,
+      heartbeatTimeout: 3e3,
+      onTimeout: () => {
+        this.destroy(new Error("Connection timed out")).catch((err) => log2.catch(err, {}, {
+          file: "teleport.ts",
+          line: 45,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        }));
+      }
+    });
+    this._extensions = /* @__PURE__ */ new Map();
+    this._remoteExtensions = /* @__PURE__ */ new Set();
+    this._open = false;
+    assert3(typeof initiator === "boolean");
+    assert3(PublicKey.isPublicKey(localPeerId));
+    assert3(PublicKey.isPublicKey(remotePeerId));
+    assert3(typeof initiator === "boolean");
+    this.initiator = initiator;
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this._control.onExtensionRegistered.set(async (name) => {
+      log2("remote extension", {
+        name
+      }, {
+        file: "teleport.ts",
+        line: 64,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      assert3(!this._remoteExtensions.has(name), "Remote extension already exists");
+      this._remoteExtensions.add(name);
+      if (this._extensions.has(name)) {
+        try {
+          await this._openExtension(name);
+        } catch (err) {
+          await this.destroy(err);
+        }
+      }
+    });
+    {
+      this._muxer.stream.on("close", async () => {
+        await this.destroy();
+      });
+      this._muxer.stream.on("error", async (err) => {
+        await this.destroy(err);
+      });
+    }
+  }
+  get stream() {
+    return this._muxer.stream;
+  }
+  /**
+  * Blocks until the handshake is complete.
+  */
+  async open() {
+    this._setExtension("dxos.mesh.teleport.control", this._control);
+    await this._openExtension("dxos.mesh.teleport.control");
+    this._open = true;
+  }
+  async close(err) {
+    await this.destroy(err);
+  }
+  async destroy(err) {
+    if (this._ctx.disposed) {
+      return;
+    }
+    await this._ctx.dispose();
+    for (const extension of this._extensions.values()) {
+      try {
+        await extension.onClose(err);
+      } catch (err1) {
+        log2.catch(err1, {}, {
+          file: "teleport.ts",
+          line: 120,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    }
+    this._muxer.destroy(err);
+  }
+  addExtension(name, extension) {
+    if (!this._open) {
+      throw new Error("Not open");
+    }
+    log2("addExtension", {
+      name
+    }, {
+      file: "teleport.ts",
+      line: 132,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._setExtension(name, extension);
+    scheduleTask(this._ctx, async () => {
+      try {
+        await this._control.registerExtension(name);
+      } catch (err) {
+        if (err instanceof RpcClosedError) {
+          return;
+        }
+        throw err;
+      }
+    });
+    if (this._remoteExtensions.has(name)) {
+      scheduleTask(this._ctx, async () => {
+        await this._openExtension(name);
+      });
+    }
+  }
+  _setExtension(extensionName, extension) {
+    assert3(!extensionName.includes("/"), "Invalid extension name");
+    assert3(!this._extensions.has(extensionName), "Extension already exists");
+    this._extensions.set(extensionName, extension);
+  }
+  async _openExtension(extensionName) {
+    var _a;
+    log2("open extension", {
+      extensionName
+    }, {
+      file: "teleport.ts",
+      line: 162,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const extension = (_a = this._extensions.get(extensionName)) != null ? _a : failUndefined2();
+    const context = {
+      initiator: this.initiator,
+      localPeerId: this.localPeerId,
+      remotePeerId: this.remotePeerId,
+      createPort: (channelName, opts) => {
+        assert3(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
+      },
+      createStream: (channelName, opts) => {
+        assert3(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
+      },
+      close: (err) => {
+        void runInContextAsync(this._ctx, async () => {
+          await this.close(err);
+        });
+      }
+    };
+    await extension.onOpen(context);
+    log2("extension opened", {
+      extensionName
+    }, {
+      file: "teleport.ts",
+      line: 185,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+__decorate([
+  synchronized
+], Teleport.prototype, "destroy", null);
+var ControlExtension = class {
+  constructor(opts) {
+    this.opts = opts;
+    this._ctx = new Context({
+      onError: (err) => {
+        this._extensionContext.close(err);
+      }
+    });
+    this.onExtensionRegistered = new Callback();
+  }
+  async onOpen(extensionContext) {
+    this._extensionContext = extensionContext;
+    this._rpc = createProtoRpcPeer({
+      requested: {
+        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      exposed: {
+        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      handlers: {
+        Control: {
+          registerExtension: async (request) => {
+            this.onExtensionRegistered.call(request.name);
+          },
+          heartbeat: async (request) => {
+          }
+        }
+      },
+      port: extensionContext.createPort("rpc", {
+        contentType: 'application/x-protobuf; messagType="dxos.rpc.Message"'
+      })
+    });
+    await this._rpc.open();
+    scheduleTaskInterval(this._ctx, async () => {
+      try {
+        await asyncTimeout(this._rpc.rpc.Control.heartbeat(), this.opts.heartbeatTimeout);
+      } catch (err) {
+        this.opts.onTimeout();
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  async onClose(err) {
+    await this._ctx.dispose();
+    await this._rpc.close();
+  }
+  async registerExtension(name) {
+    await this._rpc.rpc.Control.registerExtension({
+      name
+    });
+  }
+};
+
+// packages/core/mesh/teleport/src/testing/test-extension.ts
+import assert4 from "@dxos/node-std/assert";
+import { asyncTimeout as asyncTimeout2, Trigger } from "@dxos/async";
+import { log as log3 } from "@dxos/log";
+import { schema as schema3 } from "@dxos/protocols";
+import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
+var TestExtension = class {
+  constructor(callbacks = {}) {
+    this.callbacks = callbacks;
+    this.open = new Trigger();
+    this.closed = new Trigger();
+  }
+  get remotePeerId() {
+    var _a;
+    return (_a = this.extensionContext) == null ? void 0 : _a.remotePeerId;
+  }
+  async onOpen(context) {
+    var _a, _b;
+    log3("onOpen", {
+      localPeerId: context.localPeerId,
+      remotePeerId: context.remotePeerId
+    }, {
+      file: "test-extension.ts",
+      line: 33,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this.extensionContext = context;
+    this._rpc = createProtoRpcPeer2({
+      port: context.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      requested: {
+        TestService: schema3.getService("example.testing.rpc.TestService")
+      },
+      exposed: {
+        TestService: schema3.getService("example.testing.rpc.TestService")
+      },
+      handlers: {
+        TestService: {
+          voidCall: async (request) => {
+          },
+          testCall: async (request) => {
+            return {
+              data: request.data
+            };
+          }
+        }
+      },
+      timeout: 1e3
+    });
+    await this._rpc.open();
+    await ((_b = (_a = this.callbacks).onOpen) == null ? void 0 : _b.call(_a));
+    this.open.wake();
+  }
+  async onClose(err) {
+    var _a, _b, _c;
+    log3("onClose", {
+      err
+    }, {
+      file: "test-extension.ts",
+      line: 67,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await ((_b = (_a = this.callbacks).onClose) == null ? void 0 : _b.call(_a));
+    this.closed.wake();
+    await ((_c = this._rpc) == null ? void 0 : _c.close());
+  }
+  async test() {
+    await this.open.wait({
+      timeout: 500
+    });
+    const res = await asyncTimeout2(this._rpc.rpc.TestService.testCall({
+      data: "test"
+    }), 500);
+    assert4(res.data === "test");
+  }
+};
+
+export {
+  Framer,
+  decodeFrame,
+  encodeFrame,
+  Muxer,
+  Teleport,
+  TestExtension
+};
+//# sourceMappingURL=chunk-F3DXMBSX.mjs.map