@floegence/flowersec-core 0.2.0 → 0.2.1

package/dist/client-connect/connectCore.js

@@ -12,8 +12,6 @@ import { isTunnelAttachCloseReason } from "./tunnelAttachCloseReason.js";
 export async function connectCore(args) {
     const observer = normalizeObserver(args.opts.observer);
     const signal = args.opts.signal;
-    const connectTimeoutMs = args.opts.connectTimeoutMs ?? 10_000;
-    const handshakeTimeoutMs = args.opts.handshakeTimeoutMs ?? 10_000;
     const connectStart = nowSeconds();
     const origin = args.opts.origin;
     if (origin == null || origin === "") {
@@ -23,6 +21,41 @@ export async function connectCore(args) {
         const code = args.path === "tunnel" ? "missing_tunnel_url" : "missing_ws_url";
         throw new FlowersecError({ path: args.path, stage: "validate", code, message: "missing websocket url" });
     }
+    const invalidOption = (message) => {
+        throw new FlowersecError({ path: args.path, stage: "validate", code: "invalid_option", message });
+    };
+    const connectTimeoutMs = args.opts.connectTimeoutMs ?? 10_000;
+    if (!Number.isFinite(connectTimeoutMs) || connectTimeoutMs < 0) {
+        invalidOption("connectTimeoutMs must be a non-negative number");
+    }
+    const handshakeTimeoutMs = args.opts.handshakeTimeoutMs ?? 10_000;
+    if (!Number.isFinite(handshakeTimeoutMs) || handshakeTimeoutMs < 0) {
+        invalidOption("handshakeTimeoutMs must be a non-negative number");
+    }
+    const keepaliveIntervalMs = args.opts.keepaliveIntervalMs ?? 0;
+    if (!Number.isFinite(keepaliveIntervalMs) || keepaliveIntervalMs < 0) {
+        invalidOption("keepaliveIntervalMs must be a non-negative number");
+    }
+    const clientFeatures = args.opts.clientFeatures ?? 0;
+    if (!Number.isSafeInteger(clientFeatures) || clientFeatures < 0 || clientFeatures > 0xffffffff) {
+        invalidOption("clientFeatures must be a uint32");
+    }
+    const maxHandshakePayload = args.opts.maxHandshakePayload ?? 0;
+    if (!Number.isSafeInteger(maxHandshakePayload) || maxHandshakePayload < 0) {
+        invalidOption("maxHandshakePayload must be a non-negative integer");
+    }
+    const maxRecordBytes = args.opts.maxRecordBytes ?? 0;
+    if (!Number.isSafeInteger(maxRecordBytes) || maxRecordBytes < 0) {
+        invalidOption("maxRecordBytes must be a non-negative integer");
+    }
+    const maxBufferedBytes = args.opts.maxBufferedBytes ?? 0;
+    if (!Number.isSafeInteger(maxBufferedBytes) || maxBufferedBytes < 0) {
+        invalidOption("maxBufferedBytes must be a non-negative integer");
+    }
+    const maxWsQueuedBytes = args.opts.maxWsQueuedBytes ?? 0;
+    if (!Number.isSafeInteger(maxWsQueuedBytes) || maxWsQueuedBytes < 0) {
+        invalidOption("maxWsQueuedBytes must be a non-negative integer");
+    }
     let ws;
     try {
         ws = createWebSocket(args.wsUrl, origin, args.opts.wsFactory);
@@ -39,7 +72,7 @@ export async function connectCore(args) {
     // Install close/error/message listeners before waiting for "open" to avoid a gap where a peer close
     // (for example a tunnel attach rejection with a reason token) can be missed and misclassified as a handshake timeout.
     const transport = new WebSocketBinaryTransport(ws, {
-        ...(args.opts.maxWsQueuedBytes != null && args.opts.maxWsQueuedBytes > 0 ? { maxQueuedBytes: args.opts.maxWsQueuedBytes } : {}),
+        ...(maxWsQueuedBytes > 0 ? { maxQueuedBytes: maxWsQueuedBytes } : {}),
         observer,
     });
     try {
@@ -116,14 +149,11 @@ export async function connectCore(args) {
         const handshakeStart = nowSeconds();
         let secure;
         try {
-            const maxHandshakePayload = args.opts.maxHandshakePayload ?? 0;
-            const maxRecordBytes = args.opts.maxRecordBytes ?? 0;
-            const maxBufferedBytes = args.opts.maxBufferedBytes ?? 0;
             secure = await withAbortAndTimeout(clientHandshake(transport, {
                 channelId: args.channelId,
                 suite,
                 psk,
-                clientFeatures: args.opts.clientFeatures ?? 0,
+                clientFeatures,
                 maxHandshakePayload: maxHandshakePayload > 0 ? maxHandshakePayload : 8 * 1024,
                 maxRecordBytes: maxRecordBytes > 0 ? maxRecordBytes : (1 << 20),
                 ...(maxBufferedBytes > 0 ? { maxBufferedBytes } : {}),
@@ -209,7 +239,6 @@ export async function connectCore(args) {
                 throw new FlowersecError({ path: args.path, stage: "secure", code: "ping_failed", message: "ping failed", cause: e });
             }
         };
-        const keepaliveIntervalMs = Math.max(0, args.opts.keepaliveIntervalMs ?? 0);
         let keepaliveTimer;
         let keepaliveInFlight = false;
         const stopKeepalive = () => {
@@ -218,6 +247,27 @@ export async function connectCore(args) {
             clearInterval(keepaliveTimer);
             keepaliveTimer = undefined;
         };
+        const closeAll = () => {
+            stopKeepalive();
+            try {
+                rpc.close();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                mux.close();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                secure.close();
+            }
+            catch {
+                // ignore
+            }
+        };
         if (keepaliveIntervalMs > 0) {
             keepaliveTimer = setInterval(() => {
                 if (keepaliveInFlight)
@@ -225,12 +275,7 @@ export async function connectCore(args) {
                 keepaliveInFlight = true;
                 ping()
                     .catch(() => {
-                    try {
-                        ws.close();
-                    }
-                    catch {
-                        // ignore
-                    }
+                    closeAll();
                 })
                     .finally(() => {
                     keepaliveInFlight = false;
@@ -343,12 +388,7 @@ export async function connectCore(args) {
                 }
                 return s;
             },
-            close: () => {
-                stopKeepalive();
-                rpc.close();
-                mux.close();
-                secure.close();
-            },
+            close: closeAll,
         };
     }
     catch (e) {

package/dist/tunnel-client/connect.js

@@ -105,7 +105,7 @@ export async function connectTunnel(grant, opts) {
         endpoint_instance_id: endpointInstanceId
     };
     const attachJson = JSON.stringify(attach);
-    const keepaliveIntervalMs = opts.keepaliveIntervalMs !== undefined ? Math.max(0, opts.keepaliveIntervalMs) : defaultKeepaliveIntervalMs(idleTimeoutSeconds);
+    const keepaliveIntervalMs = opts.keepaliveIntervalMs ?? defaultKeepaliveIntervalMs(idleTimeoutSeconds);
     return await connectCore({
         path: "tunnel",
         wsUrl: checkedGrant.tunnel_url,
@@ -119,7 +119,13 @@ export async function connectTunnel(grant, opts) {
 function defaultKeepaliveIntervalMs(idleTimeoutSeconds) {
     if (!Number.isFinite(idleTimeoutSeconds) || idleTimeoutSeconds <= 0)
         return 0;
-    const idleMs = idleTimeoutSeconds * 1000;
-    const half = Math.floor(idleMs / 2);
-    return Math.max(500, half);
+    const idleMs = Math.floor(idleTimeoutSeconds * 1000);
+    if (idleMs <= 0)
+        return 0;
+    let interval = Math.floor(idleMs / 2);
+    if (interval < 500)
+        interval = 500;
+    if (interval >= idleMs)
+        interval = Math.floor(idleMs / 2);
+    return interval;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {