@neta-art/cohub 8.10.1 → 8.10.2

package/dist/chunks/websocket.d.ts

@@ -18,6 +18,7 @@ type WebsocketClientOptions = {
   autoReconnect?: boolean;
   reconnectBaseDelayMs?: number;
   reconnectMaxDelayMs?: number;
+  connectTimeoutMs?: number;
   pingIntervalMs?: number;
   pongTimeoutMs?: number;
   debug?: boolean;
@@ -99,6 +100,7 @@ declare class WebsocketClient {
   private readonly autoReconnect;
   private readonly reconnectBaseDelayMs;
   private readonly reconnectMaxDelayMs;
+  private readonly connectTimeoutMs;
   private readonly pingIntervalMs;
   private readonly pongTimeoutMs;
   private readonly debug;
@@ -114,6 +116,7 @@ declare class WebsocketClient {
   private retryAuthClose;
   private manuallyClosed;
   private connectPromise;
+  private pendingConnectReject;
   private authWaiter;
   private awaitingPong;
   private lastPingRequestId;

package/dist/chunks/websocket.js

@@ -61,11 +61,16 @@ const normalizeOptions = (options = {}) => ({
 	autoReconnect: options.autoReconnect !== false,
 	reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1e3,
 	reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15e3,
+	connectTimeoutMs: normalizeConnectTimeoutMs(options.connectTimeoutMs ?? 15e3),
 	pingIntervalMs: options.pingIntervalMs ?? 2e4,
 	pongTimeoutMs: options.pongTimeoutMs ?? 15e3,
 	debug: options.debug === true
 });
 const formatCloseMessage = (code, reason) => `WebSocket closed: ${code ?? 0} ${reason || ""}`.trim();
+const normalizeConnectTimeoutMs = (value) => {
+	if (!Number.isInteger(value) || value < 1 || value > 2147483647) throw new Error("connectTimeoutMs must be an integer between 1 and 2147483647");
+	return value;
+};
 const AUTH_CLOSE_CODE = 4003;
 const AUTH_CLOSE_REASON = "authentication failed";
 const isRetryableCloseCode = (code) => {
@@ -135,6 +140,7 @@ var WebsocketClient = class {
 	autoReconnect;
 	reconnectBaseDelayMs;
 	reconnectMaxDelayMs;
+	connectTimeoutMs;
 	pingIntervalMs;
 	pongTimeoutMs;
 	debug;
@@ -150,6 +156,7 @@ var WebsocketClient = class {
 	retryAuthClose = false;
 	manuallyClosed = false;
 	connectPromise = null;
+	pendingConnectReject = null;
 	authWaiter = null;
 	awaitingPong = false;
 	lastPingRequestId = null;
@@ -170,6 +177,7 @@ var WebsocketClient = class {
 		this.autoReconnect = normalized.autoReconnect;
 		this.reconnectBaseDelayMs = normalized.reconnectBaseDelayMs;
 		this.reconnectMaxDelayMs = normalized.reconnectMaxDelayMs;
+		this.connectTimeoutMs = normalized.connectTimeoutMs;
 		this.pingIntervalMs = normalized.pingIntervalMs;
 		this.pongTimeoutMs = normalized.pongTimeoutMs;
 		this.debug = normalized.debug;
@@ -204,19 +212,70 @@ var WebsocketClient = class {
 			const ws = new this.WebSocketImpl(this.url);
 			this.ws = ws;
 			let settled = false;
+			let closed = false;
+			let connectTimer = null;
+			const clearConnectTimer = () => {
+				if (connectTimer === null) return;
+				clearTimeout(connectTimer);
+				connectTimer = null;
+			};
 			const rejectOnce = (error) => {
 				if (settled) return;
+				clearConnectTimer();
 				settled = true;
 				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
 				reject(error);
 			};
 			const resolveOnce = () => {
 				if (settled) return;
+				clearConnectTimer();
 				settled = true;
 				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
 				resolve();
 			};
+			const isCurrentConnection = () => this.ws === ws && !closed;
+			const cleanupSocket = () => {
+				ws.onopen = null;
+				ws.onmessage = null;
+				ws.onerror = null;
+				ws.onclose = null;
+			};
+			const handleClose = (event) => {
+				if (closed || this.ws !== ws) return;
+				closed = true;
+				clearConnectTimer();
+				this.stopPingLoop();
+				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
+				this.state = "closed";
+				this.ws = null;
+				this.compactStreamContexts.clear();
+				this.patchStreamBuffers.clear();
+				this.resetRoomSubscriptions();
+				const closeError = new Error(formatCloseMessage(event.code, event.reason));
+				this.rejectAuthWaiter(closeError);
+				const retryAuthClose = event.code === AUTH_CLOSE_CODE && this.retryAuthClose;
+				this.retryAuthClose = false;
+				const willReconnect = !this.manuallyClosed && this.autoReconnect && (retryAuthClose || isRetryableCloseCode(event.code));
+				this.log("closed", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect,
+					wasConnecting
+				});
+				this.emit("close", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect
+				});
+				cleanupSocket();
+				if (wasConnecting) rejectOnce(closeError);
+				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+			};
 			ws.onopen = async () => {
+				if (!isCurrentConnection()) return;
+				clearConnectTimer();
 				try {
 					this.log("connected", {
 						url: this.url,
@@ -225,12 +284,14 @@ var WebsocketClient = class {
 					});
 					this.startPingLoop();
 					await this.authenticate();
+					if (!isCurrentConnection()) return;
 					this.state = "open";
 					this.restoreRoomSubscriptions();
 					this.reconnectAttempt = 0;
 					this.emit("open", { connectionId: this.connectionId });
 					resolveOnce();
 				} catch (error) {
+					if (!isCurrentConnection()) return;
 					const authError = error instanceof Error ? error : /* @__PURE__ */ new Error("authentication failed");
 					const recoverable = Boolean(this.getAccessToken && this.autoReconnect && !this.manuallyClosed && !this.authReconnectAttempted);
 					this.retryAuthClose = recoverable;
@@ -247,41 +308,37 @@ var WebsocketClient = class {
 				}
 			};
 			ws.onmessage = (event) => {
+				if (!isCurrentConnection()) return;
 				this.handleMessage(event.data);
 			};
 			ws.onerror = (error) => {
+				if (!isCurrentConnection()) return;
 				this.emit("error", {
 					error,
 					recoverable: !this.manuallyClosed
 				});
 			};
 			ws.onclose = (event) => {
-				this.stopPingLoop();
-				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
-				this.state = "closed";
-				this.ws = null;
-				this.compactStreamContexts.clear();
-				this.patchStreamBuffers.clear();
-				this.resetRoomSubscriptions();
-				const closeError = new Error(formatCloseMessage(event.code, event.reason));
-				this.rejectAuthWaiter(closeError);
-				const retryAuthClose = event.code === AUTH_CLOSE_CODE && this.retryAuthClose;
-				this.retryAuthClose = false;
-				const willReconnect = !this.manuallyClosed && this.autoReconnect && (retryAuthClose || isRetryableCloseCode(event.code));
-				this.log("closed", {
-					code: event.code,
-					reason: event.reason,
-					willReconnect,
-					wasConnecting
-				});
-				this.emit("close", {
-					code: event.code,
-					reason: event.reason,
-					willReconnect
-				});
-				if (wasConnecting) rejectOnce(closeError);
-				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+				handleClose(event);
 			};
+			this.pendingConnectReject = rejectOnce;
+			connectTimer = setTimeout(() => {
+				if (!isCurrentConnection() || settled) return;
+				const reason = "connect timeout";
+				const error = /* @__PURE__ */ new Error(`WebSocket ${reason} after ${this.connectTimeoutMs}ms`);
+				this.emit("error", {
+					error,
+					recoverable: !this.manuallyClosed && this.autoReconnect
+				});
+				try {
+					ws.close(4002, reason);
+				} finally {
+					handleClose({
+						code: 4002,
+						reason
+					});
+				}
+			}, this.connectTimeoutMs);
 		});
 		return this.connectPromise;
 	}
@@ -291,9 +348,23 @@ var WebsocketClient = class {
 		this.stopPingLoop();
 		this.state = "closed";
 		this.rejectAuthWaiter(/* @__PURE__ */ new Error("disconnected"));
-		this.ws?.close(code, reason);
+		const ws = this.ws;
 		this.ws = null;
+		ws?.close(code, reason);
+		this.pendingConnectReject?.(/* @__PURE__ */ new Error(`WebSocket disconnected: ${reason}`));
+		this.pendingConnectReject = null;
 		this.connectPromise = null;
+		if (ws) {
+			ws.onopen = null;
+			ws.onmessage = null;
+			ws.onerror = null;
+			ws.onclose = null;
+			this.emit("close", {
+				code,
+				reason,
+				willReconnect: false
+			});
+		}
 		this.authReconnectAttempted = false;
 		this.forceRefreshOnNextAuth = false;
 		this.retryAuthClose = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "8.10.1",
+  "version": "8.10.2",
   "description": "Cohub SDK for spaces, sessions, boards, and realtime agent collaboration.",
   "license": "Apache-2.0",
   "private": false,