@delali/narsil 0.2.2 → 0.2.3-next.33

package/dist/distribution/transport/tcp.mjs

@@ -0,0 +1,595 @@
+import { DEFAULT_TCP_CONFIG, encodeTransportMessage, encodeFrame, FRAME_TYPE_REQUEST, FrameParser, FRAME_TYPE_RESPONSE, decodeTransportMessage, FRAME_TYPE_STREAM_CHUNK, FRAME_TYPE_STREAM_END } from '../../chunk-MFFAJ2NR.mjs';
+import { MAX_MESSAGE_SIZE_BYTES, TransportError, TransportErrorCodes } from '../../chunk-C6VVLMRX.mjs';
+import { connect as connect$1, createServer as createServer$1 } from 'net';
+import { connect, createServer } from 'tls';
+
+// src/distribution/transport/tcp/parse-address.ts
+function parseAddress(address) {
+  const lastColon = address.lastIndexOf(":");
+  if (lastColon === -1) {
+    throw new TransportError(
+      TransportErrorCodes.CONNECT_FAILED,
+      `Invalid address format '${address}', expected host:port`,
+      {
+        address
+      }
+    );
+  }
+  const host = address.slice(0, lastColon);
+  const port = address.slice(lastColon + 1);
+  if (host.length === 0 || host.includes("\0")) {
+    throw new TransportError(TransportErrorCodes.CONNECT_FAILED, `Invalid host in address '${address}'`, { address });
+  }
+  return [host, port];
+}
+
+// src/distribution/transport/tcp/connection.ts
+var TcpConnectionPool = class {
+  connections = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  pendingStreams = /* @__PURE__ */ new Map();
+  parsers = /* @__PURE__ */ new Map();
+  config;
+  closed = false;
+  constructor(config) {
+    this.config = config;
+  }
+  updateTlsConfig(nextTlsConfig) {
+    this.config = {
+      ...this.config,
+      tls: nextTlsConfig
+    };
+  }
+  async send(target, message) {
+    if (this.closed) {
+      throw new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, "Connection pool has been shut down");
+    }
+    const messageBytes = encodeTransportMessage(message);
+    if (messageBytes.byteLength > MAX_MESSAGE_SIZE_BYTES) {
+      throw new TransportError(
+        TransportErrorCodes.MESSAGE_TOO_LARGE,
+        `Message payload (${messageBytes.byteLength} bytes) exceeds the ${MAX_MESSAGE_SIZE_BYTES} byte limit`,
+        { target, requestId: message.requestId, payloadSize: messageBytes.byteLength }
+      );
+    }
+    const socket = await this.getOrCreateConnection(target);
+    const frame = encodeFrame(FRAME_TYPE_REQUEST, message.requestId, messageBytes);
+    const pendingKey = `${target}:${message.requestId}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(pendingKey);
+        reject(
+          new TransportError(
+            TransportErrorCodes.TIMEOUT,
+            `Request to '${target}' timed out after ${this.config.requestTimeout}ms`,
+            {
+              target,
+              requestId: message.requestId,
+              timeoutMs: this.config.requestTimeout
+            }
+          )
+        );
+      }, this.config.requestTimeout);
+      this.pendingRequests.set(pendingKey, { target, resolve, reject, timer });
+      socket.write(frame, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pendingRequests.delete(pendingKey);
+          reject(
+            new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, `Failed to write to '${target}': ${err.message}`, {
+              target,
+              requestId: message.requestId
+            })
+          );
+        }
+      });
+    });
+  }
+  async stream(target, message, handler) {
+    if (this.closed) {
+      throw new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, "Connection pool has been shut down");
+    }
+    const messageBytes = encodeTransportMessage(message);
+    const socket = await this.getOrCreateConnection(target);
+    const frame = encodeFrame(FRAME_TYPE_REQUEST, message.requestId, messageBytes);
+    const pendingKey = `${target}:${message.requestId}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingStreams.delete(pendingKey);
+        reject(
+          new TransportError(
+            TransportErrorCodes.TIMEOUT,
+            `Stream to '${target}' timed out after ${this.config.snapshotTimeout}ms`,
+            {
+              target,
+              requestId: message.requestId,
+              timeoutMs: this.config.snapshotTimeout
+            }
+          )
+        );
+      }, this.config.snapshotTimeout);
+      this.pendingStreams.set(pendingKey, { target, handler, resolve, reject, timer });
+      socket.write(frame, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pendingStreams.delete(pendingKey);
+          reject(
+            new TransportError(
+              TransportErrorCodes.PEER_UNAVAILABLE,
+              `Failed to write stream to '${target}': ${err.message}`,
+              {
+                target,
+                requestId: message.requestId
+              }
+            )
+          );
+        }
+      });
+    });
+  }
+  async getOrCreateConnection(target) {
+    const existing = this.connections.get(target);
+    if (existing !== void 0 && !existing.destroyed) {
+      return existing;
+    }
+    const [host, portStr] = parseAddress(target);
+    const port = Number.parseInt(portStr, 10);
+    if (Number.isNaN(port) || port < 0 || port > 65535) {
+      throw new TransportError(TransportErrorCodes.CONNECT_FAILED, `Invalid port in target address '${target}'`, {
+        target
+      });
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const tlsConfig = this.config.tls;
+      const socket = tlsConfig !== void 0 ? connect({
+        host,
+        port,
+        cert: tlsConfig.cert,
+        key: tlsConfig.key,
+        ca: tlsConfig.ca,
+        rejectUnauthorized: tlsConfig.rejectUnauthorized ?? true
+      }) : connect$1({ host, port });
+      const connectEvent = tlsConfig !== void 0 ? "secureConnect" : "connect";
+      const connectTimer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          socket.destroy();
+          reject(
+            new TransportError(
+              TransportErrorCodes.TIMEOUT,
+              `Connection to '${target}' timed out after ${this.config.connectTimeout}ms`,
+              { target, timeoutMs: this.config.connectTimeout }
+            )
+          );
+        }
+      }, this.config.connectTimeout);
+      socket.once(connectEvent, () => {
+        if (settled) {
+          socket.destroy();
+          return;
+        }
+        settled = true;
+        clearTimeout(connectTimer);
+        this.setupConnection(target, socket);
+        resolve(socket);
+      });
+      socket.once("error", (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(connectTimer);
+          reject(
+            new TransportError(TransportErrorCodes.CONNECT_FAILED, `Failed to connect to '${target}': ${err.message}`, {
+              target
+            })
+          );
+        }
+      });
+    });
+  }
+  setupConnection(target, socket) {
+    this.connections.set(target, socket);
+    const parser = new FrameParser((frame) => {
+      this.handleIncomingFrame(target, frame);
+    });
+    this.parsers.set(target, parser);
+    socket.on("data", (data) => {
+      try {
+        parser.feed(new Uint8Array(data));
+      } catch (err) {
+        this.handleConnectionError(target, err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    socket.on("error", (err) => {
+      this.handleConnectionError(target, err);
+    });
+    socket.on("close", () => {
+      this.connections.delete(target);
+      this.parsers.delete(target);
+      this.rejectPendingForTarget(
+        target,
+        new TransportError(
+          TransportErrorCodes.PEER_UNAVAILABLE,
+          `Connection to '${target}' closed before a response was received`,
+          { target }
+        )
+      );
+    });
+  }
+  handleIncomingFrame(target, frame) {
+    const pendingKey = `${target}:${frame.requestId}`;
+    if (frame.frameType === FRAME_TYPE_RESPONSE) {
+      const pendingReq = this.pendingRequests.get(pendingKey);
+      if (pendingReq !== void 0) {
+        this.pendingRequests.delete(pendingKey);
+        clearTimeout(pendingReq.timer);
+        try {
+          const message = decodeTransportMessage(frame.data);
+          pendingReq.resolve(message);
+        } catch (err) {
+          pendingReq.reject(
+            new TransportError(
+              TransportErrorCodes.DECODE_FAILED,
+              `Failed to decode response: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+        return;
+      }
+      const pendingStream = this.pendingStreams.get(pendingKey);
+      if (pendingStream !== void 0) {
+        try {
+          const message = decodeTransportMessage(frame.data);
+          pendingStream.handler(message.payload);
+        } catch (err) {
+          this.pendingStreams.delete(pendingKey);
+          clearTimeout(pendingStream.timer);
+          pendingStream.reject(
+            new TransportError(
+              TransportErrorCodes.DECODE_FAILED,
+              `Failed to decode stream frame: ${err instanceof Error ? err.message : String(err)}`,
+              { target, requestId: frame.requestId }
+            )
+          );
+        }
+      }
+      return;
+    }
+    if (frame.frameType === FRAME_TYPE_STREAM_CHUNK) {
+      const pending = this.pendingStreams.get(pendingKey);
+      if (pending !== void 0) {
+        pending.handler(frame.data);
+      }
+      return;
+    }
+    if (frame.frameType === FRAME_TYPE_STREAM_END) {
+      const pending = this.pendingStreams.get(pendingKey);
+      if (pending !== void 0) {
+        this.pendingStreams.delete(pendingKey);
+        clearTimeout(pending.timer);
+        pending.resolve();
+      }
+    }
+  }
+  handleConnectionError(target, err) {
+    const socket = this.connections.get(target);
+    this.connections.delete(target);
+    this.parsers.delete(target);
+    if (socket !== void 0 && !socket.destroyed) {
+      socket.destroy();
+    }
+    this.rejectPendingForTarget(
+      target,
+      new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, `Connection to '${target}' lost: ${err.message}`, {
+        target
+      })
+    );
+  }
+  rejectPendingForTarget(target, error) {
+    for (const [pendingKey, pending] of this.pendingRequests) {
+      if (pending.target !== target) {
+        continue;
+      }
+      clearTimeout(pending.timer);
+      this.pendingRequests.delete(pendingKey);
+      pending.reject(error);
+    }
+    for (const [pendingKey, pending] of this.pendingStreams) {
+      if (pending.target !== target) {
+        continue;
+      }
+      clearTimeout(pending.timer);
+      this.pendingStreams.delete(pendingKey);
+      pending.reject(error);
+    }
+  }
+  getConnection(target) {
+    const conn = this.connections.get(target);
+    if (conn?.destroyed) {
+      this.connections.delete(target);
+      return void 0;
+    }
+    return conn;
+  }
+  async shutdown() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, "Connection pool shutting down"));
+    }
+    this.pendingRequests.clear();
+    for (const [, pending] of this.pendingStreams) {
+      clearTimeout(pending.timer);
+      pending.reject(new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, "Connection pool shutting down"));
+    }
+    this.pendingStreams.clear();
+    const closePromises = [];
+    for (const [target, socket] of this.connections) {
+      closePromises.push(
+        new Promise((resolve) => {
+          socket.once("close", () => resolve());
+          socket.destroy();
+        })
+      );
+      this.connections.delete(target);
+    }
+    this.parsers.clear();
+    await Promise.all(closePromises);
+  }
+};
+function writeAwaitingDrain(socket, frame) {
+  if (socket.write(frame)) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    socket.once("drain", resolve);
+  });
+}
+var TcpServer = class {
+  server = null;
+  clients = /* @__PURE__ */ new Set();
+  config;
+  handler = null;
+  closed = false;
+  boundPort = 0;
+  tlsServer = null;
+  constructor(config) {
+    this.config = config;
+  }
+  getPort() {
+    return this.boundPort;
+  }
+  updateTlsConfig(nextTlsConfig) {
+    this.config = {
+      ...this.config,
+      tls: nextTlsConfig
+    };
+    if (this.server === null) {
+      return;
+    }
+    if (this.tlsServer === null) {
+      throw new TransportError(
+        TransportErrorCodes.PEER_UNAVAILABLE,
+        "Cannot rotate TLS context on a server that was started without TLS"
+      );
+    }
+    this.tlsServer.setSecureContext(toSecureContextOptions(nextTlsConfig));
+  }
+  async start(handler) {
+    if (this.closed) {
+      throw new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, "TCP server has been shut down");
+    }
+    const previousHandler = this.handler;
+    this.handler = handler;
+    if (this.server !== null) {
+      return () => {
+        if (this.handler === handler) {
+          this.handler = previousHandler ?? null;
+        }
+      };
+    }
+    return new Promise((resolve, reject) => {
+      const tlsConfig = this.config.tls;
+      const server = tlsConfig !== void 0 ? createServer(
+        {
+          cert: tlsConfig.cert,
+          key: tlsConfig.key,
+          ca: tlsConfig.ca,
+          requestCert: true,
+          rejectUnauthorized: tlsConfig.rejectUnauthorized ?? true
+        },
+        (clientSocket) => {
+          this.handleClient(clientSocket);
+        }
+      ) : createServer$1((clientSocket) => {
+        this.handleClient(clientSocket);
+      });
+      server.on("error", (err) => {
+        if (this.server === null) {
+          reject(new TransportError(TransportErrorCodes.CONNECT_FAILED, `TCP server failed to start: ${err.message}`));
+        }
+      });
+      server.listen(this.config.port, this.config.host, () => {
+        this.server = server;
+        this.tlsServer = tlsConfig !== void 0 ? server : null;
+        const addr = server.address();
+        if (addr !== null && typeof addr === "object") {
+          this.boundPort = addr.port;
+        }
+        resolve(() => {
+          if (this.handler === handler) {
+            this.handler = previousHandler ?? null;
+          }
+        });
+      });
+    });
+  }
+  handleClient(socket) {
+    if (this.clients.size >= this.config.maxConnections) {
+      socket.destroy();
+      return;
+    }
+    this.clients.add(socket);
+    const parser = new FrameParser((frame) => {
+      if (frame.frameType !== FRAME_TYPE_REQUEST) {
+        return;
+      }
+      if (this.handler === null) {
+        return;
+      }
+      this.processRequest(socket, frame, this.handler);
+    });
+    socket.on("data", (data) => {
+      try {
+        parser.feed(new Uint8Array(data));
+      } catch (_) {
+        socket.destroy();
+      }
+    });
+    socket.on("error", () => {
+      socket.destroy();
+    });
+    socket.on("close", () => {
+      this.clients.delete(socket);
+    });
+  }
+  processRequest(socket, frame, handler) {
+    try {
+      const message = decodeTransportMessage(frame.data);
+      let respondCount = 0;
+      const respond = (response) => {
+        if (socket.destroyed) {
+          return Promise.resolve();
+        }
+        respondCount++;
+        if (respondCount === 1) {
+          const responseBytes = encodeTransportMessage(response);
+          return writeAwaitingDrain(socket, encodeFrame(FRAME_TYPE_RESPONSE, frame.requestId, responseBytes));
+        }
+        return writeAwaitingDrain(socket, encodeFrame(FRAME_TYPE_STREAM_CHUNK, frame.requestId, response.payload));
+      };
+      const result = handler(message, respond);
+      const finalize = () => {
+        if (respondCount > 0 && !socket.destroyed) {
+          const endFrame = encodeFrame(FRAME_TYPE_STREAM_END, frame.requestId, new Uint8Array(0));
+          socket.write(endFrame);
+        }
+      };
+      if (result instanceof Promise) {
+        result.then(finalize, (err) => {
+          this.sendErrorResponse(socket, frame.requestId, err);
+        });
+      } else {
+        finalize();
+      }
+    } catch (err) {
+      this.sendErrorResponse(socket, frame.requestId, err);
+    }
+  }
+  sendErrorResponse(socket, requestId, err) {
+    if (socket.destroyed) {
+      return;
+    }
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const errorResponse = {
+      type: "error",
+      sourceId: "",
+      requestId,
+      payload: new TextEncoder().encode(errorMsg)
+    };
+    const responseBytes = encodeTransportMessage(errorResponse);
+    const responseFrame = encodeFrame(FRAME_TYPE_RESPONSE, requestId, responseBytes);
+    socket.write(responseFrame);
+  }
+  async shutdown() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.handler = null;
+    for (const client of this.clients) {
+      client.destroy();
+    }
+    this.clients.clear();
+    if (this.server !== null) {
+      await new Promise((resolve) => {
+        const server = this.server;
+        if (server === null) {
+          resolve();
+          return;
+        }
+        server.close(() => resolve());
+      });
+      this.server = null;
+      this.tlsServer = null;
+    }
+  }
+};
+function toSecureContextOptions(tlsConfig) {
+  return {
+    cert: tlsConfig.cert,
+    key: tlsConfig.key,
+    ca: tlsConfig.ca
+  };
+}
+
+// src/distribution/transport/tcp/index.ts
+function createTcpTransport(nodeId, config) {
+  const resolvedConfig = {
+    ...DEFAULT_TCP_CONFIG,
+    ...config
+  };
+  const pool = new TcpConnectionPool(resolvedConfig);
+  const server = new TcpServer(resolvedConfig);
+  let isShutdown = false;
+  function assertNotShutdown() {
+    if (isShutdown) {
+      throw new TransportError(
+        TransportErrorCodes.PEER_UNAVAILABLE,
+        `TCP transport for node '${nodeId}' has been shut down`,
+        { nodeId }
+      );
+    }
+  }
+  return {
+    getPort() {
+      return server.getPort();
+    },
+    rotateTlsContext(nextTlsConfig) {
+      assertNotShutdown();
+      pool.updateTlsConfig(nextTlsConfig);
+      server.updateTlsConfig(nextTlsConfig);
+    },
+    async send(target, message) {
+      assertNotShutdown();
+      if (message.payload.byteLength > MAX_MESSAGE_SIZE_BYTES) {
+        throw new TransportError(
+          TransportErrorCodes.MESSAGE_TOO_LARGE,
+          `Message payload (${message.payload.byteLength} bytes) exceeds the ${MAX_MESSAGE_SIZE_BYTES} byte limit`,
+          { target, requestId: message.requestId, payloadSize: message.payload.byteLength }
+        );
+      }
+      return pool.send(target, message);
+    },
+    async stream(target, message, handler) {
+      assertNotShutdown();
+      return pool.stream(target, message, handler);
+    },
+    async listen(handler) {
+      assertNotShutdown();
+      return server.start(handler);
+    },
+    async shutdown() {
+      if (isShutdown) {
+        return;
+      }
+      isShutdown = true;
+      await Promise.all([pool.shutdown(), server.shutdown()]);
+    }
+  };
+}
+
+export { createTcpTransport };