@replit/river 0.18.5 → 0.19.2

package/dist/{chunk-VH3NGOXQ.js → chunk-D5PVGZPQ.js}

@@ -23,7 +23,8 @@ var PROTOCOL_VERSION = "v1.1";
 var ControlMessageHandshakeRequestSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: Type.String(),
-  sessionId: Type.String()
+  sessionId: Type.String(),
+  metadata: Type.Optional(Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_RESP"),
@@ -47,7 +48,7 @@ var ControlMessagePayloadSchema = Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   Type.Unknown()
 );
-function handshakeRequestMessage(from, to, sessionId) {
+function handshakeRequestMessage(from, to, sessionId, metadata) {
   return {
     id: nanoid(),
     from,
@@ -59,7 +60,8 @@ function handshakeRequestMessage(from, to, sessionId) {
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
-      sessionId
+      sessionId,
+      metadata
     }
   };
 }

package/dist/{chunk-K7CUSLWL.js → chunk-JH275HID.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-UABIFWM7.js";
+} from "./chunk-YFPVQTWL.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {

package/dist/{chunk-WER2DWCP.js → chunk-NBE3D667.js}

@@ -51,10 +51,6 @@ var jsonLogger = (msg, ctx, level) => {
 };
 var log = void 0;
 function bindLogger(fn, level) {
-  if (!fn) {
-    log = void 0;
-    return;
-  }
   if (typeof fn === "function") {
     log = new BaseLogger(fn, level);
     return log;

package/dist/{chunk-6Q3MSICL.js → chunk-SR4DBLJ6.js}

@@ -3,10 +3,10 @@ import {
   coerceErrorString,
   isStreamClose,
   isStreamOpen
-} from "./chunk-VH3NGOXQ.js";
+} from "./chunk-D5PVGZPQ.js";
 import {
   log
-} from "./chunk-WER2DWCP.js";
+} from "./chunk-NBE3D667.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -1065,6 +1065,13 @@ var RiverServer = class {
         })
       );
     };
+    if (session.metadata === void 0) {
+      log?.error(
+        `(invariant violation) session doesn't have handshake metadata`,
+        session.loggingMetadata
+      );
+      return;
+    }
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
     const serviceContextWithTransportInfo = {
@@ -1072,6 +1079,7 @@ var RiverServer = class {
       to: message.to,
       from: message.from,
       streamId: message.streamId,
+      // we've already validated that the session has handshake metadata
       session
     };
     switch (procedure.type) {
@@ -1247,7 +1255,7 @@ function createServer(transport, services, extendedContext) {
 }
 
 // package.json
-var version = "0.18.5";
+var version = "0.19.2";
 
 export {
   serializeSchema,

package/dist/{chunk-UABIFWM7.js → chunk-YFPVQTWL.js}

@@ -7,48 +7,14 @@ import {
   handshakeRequestMessage,
   handshakeResponseMessage,
   isAck
-} from "./chunk-VH3NGOXQ.js";
+} from "./chunk-D5PVGZPQ.js";
 import {
   log
-} from "./chunk-WER2DWCP.js";
+} from "./chunk-NBE3D667.js";
 import {
   NaiveJsonCodec
 } from "./chunk-GZ7HCLLM.js";
 
-// transport/events.ts
-var ProtocolError = {
-  RetriesExceeded: "conn_retry_exceeded",
-  HandshakeFailed: "handshake_failed",
-  UseAfterDestroy: "use_after_destroy",
-  MessageOrderingViolated: "message_ordering_violated"
-};
-var EventDispatcher = class {
-  eventListeners = {};
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(event);
-      }
-    }
-  }
-};
-
 // transport/session.ts
 import { customAlphabet } from "nanoid";
 var nanoid = customAlphabet("1234567890abcdefghijklmnopqrstuvxyz", 6);
@@ -81,6 +47,12 @@ var Session = class {
    * for this session.
    */
   advertisedSessionId;
+  /**
+   * The metadata for this session, as parsed from the handshake.
+   *
+   * Will only ever be populated on the server side.
+   */
+  metadata;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -183,27 +155,24 @@ var Session = class {
     this.seq = 0;
     this.ack = 0;
   }
-  sendBufferedMessages() {
-    if (!this.connection) {
-      const msg = `tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
-      log?.error(msg, this.loggingMetadata);
-      throw new Error(msg);
-    }
-    log?.info(
-      `resending ${this.sendBuffer.length} buffered messages`,
-      this.loggingMetadata
-    );
+  sendBufferedMessages(conn) {
+    log?.info(`resending ${this.sendBuffer.length} buffered messages`, {
+      ...this.loggingMetadata,
+      connId: conn.debugId
+    });
     for (const msg of this.sendBuffer) {
       log?.debug(`resending msg`, {
         ...this.loggingMetadata,
-        fullTransportMessage: msg
+        fullTransportMessage: msg,
+        connId: conn.debugId
       });
-      const ok = this.connection.send(this.codec.toBuffer(msg));
+      const ok = conn.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const errMsg = `failed to send buffered message to ${this.to} (if you hit this code path something is seriously wrong)`;
+        const errMsg = `failed to send buffered message to ${this.to} (sus, this is a fresh connection)`;
         log?.error(errMsg, {
           ...this.loggingMetadata,
-          fullTransportMessage: msg
+          fullTransportMessage: msg,
+          connId: conn.debugId
         });
         throw new Error(errMsg);
       }
@@ -234,6 +203,7 @@ var Session = class {
     this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
+    this.sendBufferedMessages(newConn);
   }
   beginGrace(cb) {
     log?.info(
@@ -283,6 +253,40 @@ var Session = class {
   }
 };
 
+// transport/events.ts
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  UseAfterDestroy: "use_after_destroy",
+  MessageOrderingViolated: "message_ordering_violated"
+};
+var EventDispatcher = class {
+  eventListeners = {};
+  numberOfListeners(eventType) {
+    return this.eventListeners[eventType]?.size ?? 0;
+  }
+  addEventListener(eventType, handler) {
+    if (!this.eventListeners[eventType]) {
+      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
+    }
+    this.eventListeners[eventType]?.add(handler);
+  }
+  removeEventListener(eventType, handler) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      this.eventListeners[eventType]?.delete(handler);
+    }
+  }
+  dispatchEvent(eventType, event) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(event);
+      }
+    }
+  }
+};
+
 // transport/transport.ts
 import { Value } from "@sinclair/typebox/value";
 
@@ -375,6 +379,9 @@ var defaultClientTransportOptions = {
   ...defaultTransportOptions,
   ...defaultConnectionRetryOptions
 };
+var defaultServerTransportOptions = {
+  ...defaultTransportOptions
+};
 var Transport = class {
   /**
    * A flag indicating whether the transport has been destroyed.
@@ -428,37 +435,15 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, connectedTo, advertisedSessionId) {
+  onConnect(conn, connectedTo, session, isReconnect) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
-    let oldSession = this.sessions.get(connectedTo);
-    if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
-      log?.warn(
-        `connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), killing old session and starting a new one`,
-        oldSession.loggingMetadata
-      );
-      this.deleteSession(oldSession);
-      oldSession = void 0;
-    }
-    if (oldSession === void 0) {
-      const newSession = this.createSession(connectedTo, conn);
-      newSession.advertisedSessionId = advertisedSessionId;
-      log?.info(
-        `new connection for new session to ${connectedTo}`,
-        newSession.loggingMetadata
-      );
-      return newSession;
+    if (isReconnect) {
+      session.replaceWithNewConnection(conn);
+      log?.info(`reconnected to ${connectedTo}`, session.loggingMetadata);
     }
-    oldSession.replaceWithNewConnection(conn);
-    oldSession.sendBufferedMessages();
-    oldSession.advertisedSessionId = advertisedSessionId;
-    log?.info(
-      `new connection for existing session to ${connectedTo}`,
-      oldSession.loggingMetadata
-    );
-    return oldSession;
   }
   createSession(to, conn) {
     const session = new Session(
@@ -474,8 +459,18 @@ var Transport = class {
     });
     return session;
   }
-  getOrCreateSession(to, conn) {
+  getOrCreateSession(to, conn, sessionId) {
     let session = this.sessions.get(to);
+    let isReconnect = session !== void 0;
+    if (session?.advertisedSessionId !== void 0 && sessionId !== void 0 && session.advertisedSessionId !== sessionId) {
+      log?.warn(
+        `session for ${to} already exists but has a different session id (expected: ${session.advertisedSessionId}, got: ${sessionId}), creating a new one`,
+        session.loggingMetadata
+      );
+      this.deleteSession(session);
+      isReconnect = false;
+      session = void 0;
+    }
     if (!session) {
       session = this.createSession(to, conn);
       log?.info(
@@ -483,7 +478,10 @@ var Transport = class {
         session.loggingMetadata
       );
     }
-    return session;
+    if (sessionId !== void 0) {
+      session.advertisedSessionId = sessionId;
+    }
+    return { session, isReconnect };
   }
   deleteSession(session) {
     session.close();
@@ -618,7 +616,7 @@ var Transport = class {
       });
       return void 0;
     }
-    return this.getOrCreateSession(to).send(msg);
+    return this.getOrCreateSession(to).session.send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -777,11 +775,12 @@ var ClientTransport = class extends Transport {
       connectedTo: parsed.from,
       fullTransportMessage: parsed
     });
-    const session = this.onConnect(
-      conn,
+    const { session, isReconnect } = this.getOrCreateSession(
       parsed.from,
+      conn,
       parsed.payload.status.sessionId
     );
+    this.onConnect(conn, parsed.from, session, isReconnect);
     this.retryBudget.startRestoringBudget(parsed.from);
     return session;
   }
@@ -834,8 +833,13 @@ var ClientTransport = class extends Transport {
           conn.close();
           throw new Error("transport state is no longer open");
         }
-        this.sendHandshake(to, conn);
-        return conn;
+        return this.sendHandshake(to, conn).then((ok) => {
+          if (!ok) {
+            conn.close();
+            throw new Error("failed to send handshake");
+          }
+          return conn;
+        });
       });
       this.inflightConnectionPromises.set(to, reconnectPromise);
     } else {
@@ -867,14 +871,35 @@ var ClientTransport = class extends Transport {
     this.inflightConnectionPromises.delete(session.to);
     super.deleteSession(session);
   }
-  sendHandshake(to, conn) {
-    const session = this.getOrCreateSession(to, conn);
-    const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
+  async sendHandshake(to, conn) {
+    let metadata;
+    if (this.options.handshake) {
+      metadata = await this.options.handshake.get();
+      if (!Value.Check(this.options.handshake.schema, metadata)) {
+        log?.error(`handshake metadata did not match schema`, {
+          clientId: this.clientId,
+          connectedTo: to
+        });
+        this.protocolError(
+          ProtocolError.HandshakeFailed,
+          "handshake metadata did not match schema"
+        );
+        return false;
+      }
+    }
+    const { session } = this.getOrCreateSession(to, conn);
+    const requestMsg = handshakeRequestMessage(
+      this.clientId,
+      to,
+      session.id,
+      metadata
+    );
     log?.debug(`sending handshake request to ${to}`, {
       clientId: this.clientId,
       connectedTo: to
     });
     conn.send(this.codec.toBuffer(requestMsg));
+    return true;
   }
   close() {
     this.retryBudget.close();
@@ -882,8 +907,16 @@ var ClientTransport = class extends Transport {
   }
 };
 var ServerTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
+    this.options = {
+      ...defaultServerTransportOptions,
+      ...providedOptions
+    };
     log?.info(`initiated server transport`, {
       clientId: this.clientId,
       protocolVersion: PROTOCOL_VERSION
@@ -911,24 +944,38 @@ var ServerTransport = class extends Transport {
         conn.close();
       }
     }, this.options.sessionDisconnectGraceMs);
+    const buffer = [];
+    let receivedHandshakeMessage = false;
     const handshakeHandler = (data) => {
-      const maybeSession = this.receiveHandshakeRequestMessage(data, conn);
-      if (!maybeSession) {
-        conn.close();
+      if (receivedHandshakeMessage) {
+        buffer.push(data);
         return;
-      } else {
-        session = maybeSession;
-        clearTimeout(handshakeTimeout);
       }
-      conn.removeDataListener(handshakeHandler);
-      conn.addDataListener((data2) => {
-        const parsed = this.parseMsg(data2);
-        if (!parsed) {
-          conn.close();
-          return;
+      receivedHandshakeMessage = true;
+      clearTimeout(handshakeTimeout);
+      void this.receiveHandshakeRequestMessage(data, conn).then(
+        (maybeSession) => {
+          if (!maybeSession) {
+            conn.close();
+            return;
+          }
+          session = maybeSession;
+          const dataHandler = (data2) => {
+            const parsed = this.parseMsg(data2);
+            if (!parsed) {
+              conn.close();
+              return;
+            }
+            this.handleMsg(parsed);
+          };
+          conn.removeDataListener(handshakeHandler);
+          conn.addDataListener(dataHandler);
+          for (const data2 of buffer) {
+            dataHandler(data2);
+          }
+          buffer.length = 0;
         }
-        this.handleMsg(parsed);
-      });
+      );
     };
     conn.addDataListener(handshakeHandler);
     conn.addCloseListener(() => {
@@ -949,7 +996,7 @@ var ServerTransport = class extends Transport {
       );
     });
   }
-  receiveHandshakeRequestMessage(data, conn) {
+  async receiveHandshakeRequestMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
@@ -965,7 +1012,8 @@ var ServerTransport = class extends Transport {
         reason
       });
       conn.send(this.codec.toBuffer(responseMsg2));
-      log?.warn(`${reason}: ${JSON.stringify(parsed)}`, {
+      const logData = typeof parsed.payload === "object" ? { ...parsed, payload: { ...parsed.payload, metadata: "redacted" } } : { ...parsed };
+      log?.warn(`${reason}: ${JSON.stringify(logData)}`, {
         clientId: this.clientId,
         connId: conn.debugId
       });
@@ -990,7 +1038,73 @@ var ServerTransport = class extends Transport {
       this.protocolError(ProtocolError.HandshakeFailed, reason);
       return false;
     }
-    const session = this.getOrCreateSession(parsed.from, conn);
+    const { session, isReconnect } = this.getOrCreateSession(
+      parsed.from,
+      conn,
+      parsed.payload.sessionId
+    );
+    let handshakeMetadata;
+    if (this.options.handshake) {
+      if (!Value.Check(
+        this.options.handshake.requestSchema,
+        parsed.payload.metadata
+      )) {
+        const reason = "received malformed handshake metadata";
+        const responseMsg2 = handshakeResponseMessage(
+          this.clientId,
+          parsed.from,
+          { ok: false, reason }
+        );
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.warn(`received malformed handshake metadata from ${parsed.from}`, {
+          clientId: this.clientId,
+          connId: conn.debugId
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
+      }
+      const parsedMetadata = await this.options.handshake.parse(
+        parsed.payload.metadata,
+        session,
+        isReconnect
+      );
+      if (parsedMetadata === false) {
+        const reason = "rejected by server";
+        const responseMsg2 = handshakeResponseMessage(
+          this.clientId,
+          parsed.from,
+          { ok: false, reason }
+        );
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.warn(`rejected handshake from ${parsed.from}`, {
+          clientId: this.clientId,
+          connId: conn.debugId
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
+      }
+      if (!Value.Check(this.options.handshake.parsedSchema, parsedMetadata)) {
+        const reason = "failed to parse handshake metadata";
+        const responseMsg2 = handshakeResponseMessage(
+          this.clientId,
+          parsed.from,
+          { ok: false, reason }
+        );
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.error(`failed to parse handshake metadata`, {
+          clientId: this.clientId,
+          connId: conn.debugId
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
+      }
+      handshakeMetadata = parsedMetadata;
+    }
+    handshakeMetadata ??= {};
+    session.metadata = handshakeMetadata;
     log?.debug(
       `handshake from ${parsed.from} ok, responding with handshake success`,
       { clientId: this.clientId, connId: conn.debugId }
@@ -1000,14 +1114,15 @@ var ServerTransport = class extends Transport {
       sessionId: session.id
     });
     conn.send(this.codec.toBuffer(responseMsg));
-    return this.onConnect(conn, parsed.from, parsed.payload.sessionId);
+    this.onConnect(conn, parsed.from, session, isReconnect);
+    return session;
   }
 };
 
 export {
-  ProtocolError,
   Connection,
   Session,
+  ProtocolError,
   defaultTransportOptions,
   Transport,
   ClientTransport,

package/dist/{chunk-PUX3U2SZ.js → chunk-ZWPEZS27.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-UABIFWM7.js";
+} from "./chunk-YFPVQTWL.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";

package/dist/{connection-893bd769.d.ts → connection-aa0ea000.d.ts}

@@ -1,5 +1,5 @@
 import WebSocket from 'isomorphic-ws';
-import { C as Connection } from './index-d412ca83.js';
+import { C as Connection } from './index-e2513701.js';
 
 declare class WebSocketConnection extends Connection {
     ws: WebSocket;

package/dist/{connection-89918b74.d.ts → connection-cfec12e6.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './index-d412ca83.js';
+import { C as Connection } from './index-e2513701.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';