@replit/river 0.23.13 → 0.23.14

package/dist/{chunk-ZUKDZY54.js → chunk-WUL63FR6.js}

@@ -1,16 +1,17 @@
 import {
   ProtocolError,
   Transport
-} from "./chunk-XM656KMN.js";
+} from "./chunk-OTVTKAN6.js";
 import {
   defaultServerTransportOptions
-} from "./chunk-2FNLANTJ.js";
+} from "./chunk-O2AVDJCQ.js";
 import {
   ControlMessageHandshakeRequestSchema,
   PROTOCOL_VERSION,
+  SESSION_STATE_MISMATCH,
   coerceErrorString,
   handshakeResponseMessage
-} from "./chunk-ES4XO2XD.js";
+} from "./chunk-GCCRVSMR.js";
 
 // transport/server.ts
 import { SpanStatusCode } from "@opentelemetry/api";
@@ -134,9 +135,13 @@ var ServerTransport = class extends Transport {
           message: "malformed handshake meta"
         });
         const reason = "received malformed handshake metadata";
-        const responseMsg = handshakeResponseMessage(this.clientId, from, {
-          ok: false,
-          reason
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
         });
         conn.send(this.codec.toBuffer(responseMsg));
         this.log?.warn(`received malformed handshake metadata from ${from}`, {
@@ -160,9 +165,13 @@ var ServerTransport = class extends Transport {
           code: SpanStatusCode.ERROR,
           message: reason
         });
-        const responseMsg = handshakeResponseMessage(this.clientId, from, {
-          ok: false,
-          reason
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
         });
         conn.send(this.codec.toBuffer(responseMsg));
         this.log?.warn(`rejected handshake from ${from}`, {
@@ -194,9 +203,13 @@ var ServerTransport = class extends Transport {
         message: "invalid handshake request"
       });
       const reason = "received invalid handshake msg";
-      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
-        ok: false,
-        reason
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
       });
       conn.send(this.codec.toBuffer(responseMsg2));
       this.log?.warn(reason, {
@@ -222,9 +235,13 @@ var ServerTransport = class extends Transport {
         message: "incorrect protocol version"
       });
       const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
-      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
-        ok: false,
-        reason
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
       });
       conn.send(this.codec.toBuffer(responseMsg2));
       this.log?.warn(
@@ -244,20 +261,67 @@ var ServerTransport = class extends Transport {
     if (parsedMetadata === false) {
       return false;
     }
-    const { session, isTransparentReconnect } = this.getOrCreateSession({
-      to: parsed.from,
-      conn,
-      sessionId: parsed.payload.sessionId,
-      propagationCtx: parsed.tracing
-    });
+    let session;
+    let isTransparentReconnect;
+    if (!parsed.payload.expectedSessionState) {
+      ({ session, isTransparentReconnect } = this.getOrCreateSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      }));
+    } else if (parsed.payload.expectedSessionState.reconnect) {
+      const existingSession = this.getExistingSession({
+        to: parsed.from,
+        sessionId: parsed.payload.sessionId,
+        nextExpectedSeq: parsed.payload.expectedSessionState.nextExpectedSeq
+      });
+      if (existingSession === false) {
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: SESSION_STATE_MISMATCH
+        });
+        const reason = SESSION_STATE_MISMATCH;
+        const responseMsg2 = handshakeResponseMessage({
+          from: this.clientId,
+          to: parsed.from,
+          status: {
+            ok: false,
+            reason
+          }
+        });
+        conn.send(this.codec.toBuffer(responseMsg2));
+        this.log?.warn(
+          `'received handshake msg with incompatible existing session state: ${parsed.payload.sessionId}`,
+          { ...conn.loggingMetadata, clientId: this.clientId }
+        );
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+      session = existingSession;
+      isTransparentReconnect = false;
+    } else {
+      const createdSession = this.createNewSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      });
+      session = createdSession;
+      isTransparentReconnect = false;
+    }
     this.sessionHandshakeMetadata.set(session, parsedMetadata);
     this.log?.debug(
       `handshake from ${parsed.from} ok, responding with handshake success`,
       conn.loggingMetadata
     );
-    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
-      ok: true,
-      sessionId: session.id
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to: parsed.from,
+      status: {
+        ok: true,
+        sessionId: session.id
+      }
     });
     conn.send(this.codec.toBuffer(responseMsg));
     this.onConnect(conn, session, isTransparentReconnect);
@@ -268,4 +332,4 @@ var ServerTransport = class extends Transport {
 export {
   ServerTransport
 };
-//# sourceMappingURL=chunk-ZUKDZY54.js.map
+//# sourceMappingURL=chunk-WUL63FR6.js.map

package/dist/chunk-WUL63FR6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../transport/server.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { ParsedMetadata } from '../router/context';\nimport { ServerHandshakeOptions } from '../router/handshake';\nimport {\n  ControlMessageHandshakeRequestSchema,\n  PROTOCOL_VERSION,\n  SESSION_STATE_MISMATCH,\n  TransportClientId,\n  handshakeResponseMessage,\n} from './message';\nimport {\n  ProvidedServerTransportOptions,\n  ServerTransportOptions,\n  defaultServerTransportOptions,\n} from './options';\nimport { Connection, Session } from './session';\nimport { Transport } from './transport';\nimport { coerceErrorString } from '../util/stringify';\nimport { Static } from '@sinclair/typebox';\nimport { Value } from '@sinclair/typebox/value';\nimport { ProtocolError } from './events';\n\nexport abstract class ServerTransport<\n  ConnType extends Connection,\n> extends Transport<ConnType> {\n  /**\n   * The options for this transport.\n   */\n  protected options: ServerTransportOptions;\n\n  /**\n   * Optional handshake options for the server.\n   */\n  handshakeExtensions?: ServerHandshakeOptions;\n\n  /**\n   * A map of session handshake data for each session.\n   */\n  sessionHandshakeMetadata: WeakMap<Session<ConnType>, ParsedMetadata>;\n\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedServerTransportOptions,\n  ) {\n    super(clientId, providedOptions);\n    this.options = {\n      ...defaultServerTransportOptions,\n      ...providedOptions,\n    };\n    this.sessionHandshakeMetadata = new WeakMap();\n    this.log?.info(`initiated server transport`, {\n      clientId: this.clientId,\n      protocolVersion: PROTOCOL_VERSION,\n    });\n  }\n\n  extendHandshake(options: ServerHandshakeOptions) {\n    this.handshakeExtensions = options;\n  }\n\n  protected handleConnection(conn: ConnType) {\n    if (this.getStatus() !== 'open') return;\n\n    this.log?.info(`new incoming connection`, {\n      ...conn.loggingMetadata,\n      clientId: this.clientId,\n    });\n\n    let session: Session<ConnType> | undefined = undefined;\n    const client = () => session?.to ?? 'unknown';\n\n    // kill the conn after the grace period if we haven't received a handshake\n    const handshakeTimeout = setTimeout(() => {\n      if (!session) {\n        this.log?.warn(\n          `connection to ${client()} timed out waiting for handshake, closing`,\n          {\n            ...conn.loggingMetadata,\n            clientId: this.clientId,\n            connectedTo: client(),\n          },\n        );\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'handshake timeout',\n        });\n        conn.close();\n      }\n    }, this.options.sessionDisconnectGraceMs);\n\n    const buffer: Array<Uint8Array> = [];\n    let receivedHandshakeMessage = false;\n\n    const handshakeHandler = (data: Uint8Array) => {\n      // if we've already received, just buffer the data\n      if (receivedHandshakeMessage) {\n        buffer.push(data);\n        return;\n      }\n\n      receivedHandshakeMessage = true;\n      clearTimeout(handshakeTimeout);\n\n      void this.receiveHandshakeRequestMessage(data, conn).then(\n        (maybeSession) => {\n          if (!maybeSession) {\n            conn.close();\n            return;\n          }\n\n          session = maybeSession;\n\n          // when we are done handshake sequence,\n          // remove handshake listener and use the normal message listener\n          const dataHandler = (data: Uint8Array) => {\n            const parsed = this.parseMsg(data, conn);\n            if (!parsed) {\n              conn.close();\n              return;\n            }\n\n            this.handleMsg(parsed, conn);\n          };\n\n          // process any data we missed\n          for (const data of buffer) {\n            dataHandler(data);\n          }\n\n          conn.removeDataListener(handshakeHandler);\n          conn.addDataListener(dataHandler);\n          buffer.length = 0;\n        },\n      );\n    };\n\n    conn.addDataListener(handshakeHandler);\n    conn.addCloseListener(() => {\n      if (!session) return;\n      this.log?.info(`connection to ${client()} disconnected`, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n      });\n      this.onDisconnect(conn, session);\n    });\n\n    conn.addErrorListener((err) => {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'connection error',\n      });\n      if (!session) return;\n      this.log?.warn(\n        `connection to ${client()} got an error: ${coerceErrorString(err)}`,\n        { ...conn.loggingMetadata, clientId: this.clientId },\n      );\n    });\n  }\n\n  private async validateHandshakeMetadata(\n    conn: ConnType,\n    session: Session<ConnType> | undefined,\n    rawMetadata: Static<\n      typeof ControlMessageHandshakeRequestSchema\n    >['metadata'],\n    from: TransportClientId,\n  ): Promise<ParsedMetadata | false> {\n    let parsedMetadata: ParsedMetadata = {};\n    if (this.handshakeExtensions) {\n      // check that the metadata that was sent is the correct shape\n      if (!Value.Check(this.handshakeExtensions.schema, rawMetadata)) {\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'malformed handshake meta',\n        });\n        const reason = 'received malformed handshake metadata';\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(`received malformed handshake metadata from ${from}`, {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n          validationErrors: [\n            ...Value.Errors(this.handshakeExtensions.schema, rawMetadata),\n          ],\n        });\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n\n      const previousParsedMetadata = session\n        ? this.sessionHandshakeMetadata.get(session)\n        : undefined;\n\n      parsedMetadata = await this.handshakeExtensions.validate(\n        rawMetadata,\n        previousParsedMetadata,\n      );\n\n      // handler rejected the connection\n      if (parsedMetadata === false) {\n        const reason = 'rejected by handshake handler';\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: reason,\n        });\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(`rejected handshake from ${from}`, {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n        });\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n    }\n\n    return parsedMetadata;\n  }\n\n  async receiveHandshakeRequestMessage(\n    data: Uint8Array,\n    conn: ConnType,\n  ): Promise<Session<ConnType> | false> {\n    const parsed = this.parseMsg(data, conn);\n    if (!parsed) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'non-transport message',\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'received non-transport message',\n      );\n      return false;\n    }\n\n    if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'invalid handshake request',\n      });\n      const reason = 'received invalid handshake msg';\n      const responseMsg = handshakeResponseMessage({\n        from: this.clientId,\n        to: parsed.from,\n        status: {\n          ok: false,\n          reason,\n        },\n      });\n      conn.send(this.codec.toBuffer(responseMsg));\n      this.log?.warn(reason, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n        // safe to this.log metadata here as we remove the payload\n        // before passing it to user-land\n        transportMessage: parsed,\n        validationErrors: [\n          ...Value.Errors(ControlMessageHandshakeRequestSchema, parsed.payload),\n        ],\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'invalid handshake request',\n      );\n      return false;\n    }\n\n    // double check protocol version here\n    const gotVersion = parsed.payload.protocolVersion;\n    if (gotVersion !== PROTOCOL_VERSION) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'incorrect protocol version',\n      });\n\n      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;\n      const responseMsg = handshakeResponseMessage({\n        from: this.clientId,\n        to: parsed.from,\n        status: {\n          ok: false,\n          reason,\n        },\n      });\n      conn.send(this.codec.toBuffer(responseMsg));\n      this.log?.warn(\n        `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,\n        { ...conn.loggingMetadata, clientId: this.clientId },\n      );\n      this.protocolError(ProtocolError.HandshakeFailed, reason);\n      return false;\n    }\n\n    const oldSession = this.sessions.get(parsed.from);\n    const parsedMetadata = await this.validateHandshakeMetadata(\n      conn,\n      oldSession,\n      parsed.payload.metadata,\n      parsed.from,\n    );\n\n    if (parsedMetadata === false) {\n      return false;\n    }\n\n    let session: Session<ConnType>;\n    let isTransparentReconnect: boolean;\n    if (!parsed.payload.expectedSessionState) {\n      // TODO: remove once we have upgraded all clients.\n      ({ session, isTransparentReconnect } = this.getOrCreateSession({\n        to: parsed.from,\n        conn,\n        sessionId: parsed.payload.sessionId,\n        propagationCtx: parsed.tracing,\n      }));\n    } else if (parsed.payload.expectedSessionState.reconnect) {\n      // this has to be an existing session. if it doesn't match what we expect, reject the\n      // handshake\n      const existingSession = this.getExistingSession({\n        to: parsed.from,\n        sessionId: parsed.payload.sessionId,\n        nextExpectedSeq: parsed.payload.expectedSessionState.nextExpectedSeq,\n      });\n      if (existingSession === false) {\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: SESSION_STATE_MISMATCH,\n        });\n\n        const reason = SESSION_STATE_MISMATCH;\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: parsed.from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(\n          `'received handshake msg with incompatible existing session state: ${parsed.payload.sessionId}`,\n          { ...conn.loggingMetadata, clientId: this.clientId },\n        );\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n      session = existingSession;\n      isTransparentReconnect = false;\n    } else {\n      // this has to be a new session. if one already exists, it will be replaced silently\n      const createdSession = this.createNewSession({\n        to: parsed.from,\n        conn,\n        sessionId: parsed.payload.sessionId,\n        propagationCtx: parsed.tracing,\n      });\n      session = createdSession;\n      isTransparentReconnect = false;\n    }\n\n    this.sessionHandshakeMetadata.set(session, parsedMetadata);\n\n    this.log?.debug(\n      `handshake from ${parsed.from} ok, responding with handshake success`,\n      conn.loggingMetadata,\n    );\n    const responseMsg = handshakeResponseMessage({\n      from: this.clientId,\n      to: parsed.from,\n      status: {\n        ok: true,\n        sessionId: session.id,\n      },\n    });\n    conn.send(this.codec.toBuffer(responseMsg));\n    this.onConnect(conn, session, isTransparentReconnect);\n\n    return session;\n  }\n}\n"],"mappings":"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","names":["data","responseMsg"]}

package/dist/{chunk-4QZOW4DH.js → chunk-YCLZWES2.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-2FNLANTJ.js";
+} from "./chunk-O2AVDJCQ.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";
@@ -103,4 +103,4 @@ var UdsConnection = class extends Connection {
 export {
   UdsConnection
 };
-//# sourceMappingURL=chunk-4QZOW4DH.js.map
+//# sourceMappingURL=chunk-YCLZWES2.js.map

package/dist/{client-dd5c9dd0.d.ts → client-e13979ac.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection, T as Transport, j as ClientTransportOptions, L as LeakyBucketRateLimit, k as ClientHandshakeOptions, b as ProvidedClientTransportOptions, S as Session } from './handshake-e428d1c8.js';
+import { C as Connection, T as Transport, j as ClientTransportOptions, L as LeakyBucketRateLimit, k as ClientHandshakeOptions, b as ProvidedClientTransportOptions, S as Session } from './handshake-5665ffd3.js';
 import { c as TransportClientId } from './index-ea74cdbb.js';
 
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {

package/dist/{connection-39816c00.d.ts → connection-5d0978ce.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './handshake-e428d1c8.js';
+import { C as Connection } from './handshake-5665ffd3.js';
 import { W as WsLike } from './wslike-e0b32dd5.js';
 
 declare class WebSocketConnection extends Connection {

package/dist/{connection-40318f22.d.ts → connection-e57e98ea.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './handshake-e428d1c8.js';
+import { C as Connection } from './handshake-5665ffd3.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
 

package/dist/{handshake-e428d1c8.d.ts → handshake-5665ffd3.d.ts}

@@ -151,7 +151,9 @@ declare class Session<ConnType extends Connection> {
     closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
     close(): void;
     get connected(): boolean;
+    get nextExpectedAck(): number;
     get nextExpectedSeq(): number;
+    advanceAckForTesting(by: number): void;
     constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
     inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
 }
@@ -341,6 +343,17 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     protected onConnect(conn: ConnType, session: Session<ConnType>, isTransparentReconnect: boolean): void;
     protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
+    protected createNewSession({ to, conn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn: ConnType;
+        sessionId: string;
+        propagationCtx?: PropagationContext;
+    }): Session<ConnType>;
+    protected getExistingSession({ to, sessionId, nextExpectedSeq, }: {
+        to: TransportClientId;
+        sessionId: string;
+        nextExpectedSeq: number;
+    }): false | Session<ConnType>;
     protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
         to: TransportClientId;
         conn?: ConnType;

package/dist/router/index.cjs

@@ -1104,6 +1104,21 @@ var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox3.Type.String(),
   sessionId: import_typebox3.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox3.Type.Optional(
+    import_typebox3.Type.Object({
+      /**
+       * reconnect is set to true if the client explicitly wants to reestablish an existing
+       * connection.
+       */
+      reconnect: import_typebox3.Type.Boolean(),
+      nextExpectedSeq: import_typebox3.Type.Integer()
+    })
+  ),
   metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
@@ -1172,7 +1187,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.13";
+var version = "0.23.14";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {