@antzsoft/chat-core 1.4.4 → 1.4.5

package/dist/index.cjs

@@ -134,6 +134,7 @@ __export(src_exports, {
   getSocketStatus: () => getSocketStatus,
   initApiClient: () => initApiClient,
   initAuthStore: () => initAuthStore,
+  isApiClientConfigured: () => isApiClientConfigured,
   isMentionAll: () => isMentionAll,
   isTransitEnvelope: () => isTransitEnvelope,
   messagesApi: () => messagesApi,
@@ -146,9 +147,11 @@ __export(src_exports, {
   refreshSocketAuth: () => refreshSocketAuth,
   renderMentionParts: () => renderMentionParts,
   resetAuthStore: () => resetAuthStore,
+  resetTrackedRooms: () => resetTrackedRooms,
   resolveConfig: () => resolveConfig,
   resolveSystemMessageText: () => resolveSystemMessageText,
   setApiClientInstance: () => setApiClientInstance,
+  setAuthReadyPromise: () => setAuthReadyPromise,
   setTransitSession: () => setTransitSession,
   socketEmit: () => socketEmit,
   storageApi: () => storageApi,
@@ -214,6 +217,7 @@ function resolveConfig(config) {
       compressDocuments: config.compression?.compressDocuments ?? true
     },
     persistStorage: config.persistStorage,
+    onSendError: config.onSendError,
     messagePageSize: config.messagePageSize ?? 40,
     starredMessagePageSize: config.starredMessagePageSize ?? 30,
     searchPageSize: config.searchPageSize ?? 50
@@ -386,7 +390,8 @@ function getState() {
       sessionEverEstablished: false,
       readyResolve: null,
       readyPromise: null,
-      transitConfigured: null
+      transitConfigured: null,
+      readyListeners: /* @__PURE__ */ new Set()
     };
   }
   return g[_KEY];
@@ -399,11 +404,13 @@ function configureTransit(enabled) {
     s.readyResolve = null;
   }
 }
+function configureTransitIfUnset(enabled) {
+  if (getState().transitConfigured === null) configureTransit(enabled);
+}
 function waitForTransitReady() {
   const s = getState();
   if (!s.transitConfigured) return Promise.resolve();
   if (s.session) return Promise.resolve();
-  if (s.sessionEverEstablished) return Promise.resolve();
   if (!s.readyPromise) {
     s.readyPromise = new Promise((resolve) => {
       s.readyResolve = resolve;
@@ -417,6 +424,29 @@ function setTransitSession(session) {
   s.sessionEverEstablished = true;
   s.readyResolve?.();
   s.readyResolve = null;
+  s.readyListeners.forEach((fn) => {
+    try {
+      fn();
+    } catch {
+    }
+  });
+}
+function onTransitReady(listener) {
+  const s = getState();
+  s.readyListeners.add(listener);
+  return () => {
+    s.readyListeners.delete(listener);
+  };
+}
+async function awaitTransitReadyOr(timeoutMs) {
+  const s = getState();
+  if (!s.transitConfigured || s.session) return true;
+  await Promise.race([
+    waitForTransitReady(),
+    new Promise((r) => setTimeout(r, timeoutMs))
+  ]);
+  const now = getState();
+  return Boolean(now.session) || now.transitConfigured !== true;
 }
 function getTransitSession() {
   return getState().session;
@@ -424,12 +454,16 @@ function getTransitSession() {
 function clearTransitSession() {
   const s = getState();
   s.session = null;
+  s.sessionEverEstablished = false;
   s.readyPromise = null;
   s.readyResolve = null;
 }
 function isTransitEnabled() {
   return getState().session?.enabled === true;
 }
+function isTransitRequired() {
+  return getState().transitConfigured === true;
+}
 function getSessionKey() {
   return getState().session?.sessionKey ?? null;
 }
@@ -668,13 +702,52 @@ function normalizeAxiosError(error) {
 }
 
 // src/api/client.ts
+var TRANSIT_GATE_MAX_WAIT_MS = 3e4;
 var _tokenStore = null;
 var _config = null;
 var _avatarSent = false;
 var _transitHandshakePromise = null;
+var _authReadyPromise = null;
 function getTransitHandshakePromise() {
   return _transitHandshakePromise;
 }
+function setAuthReadyPromise(promise) {
+  _authReadyPromise = promise;
+}
+function isApiClientConfigured() {
+  return _config !== null;
+}
+function ensureRestTransitHandshake() {
+  if (!_config?.transitEncryption || getTransitSession() || _transitHandshakePromise) return;
+  const apiUrl = _config.apiUrl;
+  _transitHandshakePromise = (async () => {
+    try {
+      for (let attempt = 0; attempt < 5; attempt++) {
+        if (getTransitSession()) return;
+        try {
+          const keys = await fetchServerKeys(apiUrl);
+          if (!keys?.enabled) {
+            configureTransit(false);
+            return;
+          }
+          const session = await createRestTransitSession(apiUrl);
+          if (session && !getTransitSession()) {
+            const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
+            setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
+            return;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8e3)));
+      }
+      console.error(
+        "[AntzChat] transit handshake could not establish a session after 5 attempts \u2014 chat requests stay gated until one succeeds (server requires transit)."
+      );
+    } finally {
+      _transitHandshakePromise = null;
+    }
+  })();
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -684,24 +757,9 @@ function initApiClient(config, tokenStore) {
     headers: { "Content-Type": "application/json" }
   });
   configureTransit(config.transitEncryption);
-  if (config.transitEncryption && !getTransitSession() && !_transitHandshakePromise) {
-    _transitHandshakePromise = (async () => {
-      try {
-        const session = await createRestTransitSession(config.apiUrl);
-        if (session && !getTransitSession()) {
-          const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
-          setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
-        } else if (!session) {
-          configureTransit(false);
-        }
-      } catch {
-        configureTransit(false);
-      } finally {
-        _transitHandshakePromise = null;
-      }
-    })();
-  }
+  ensureRestTransitHandshake();
   client.interceptors.request.use(async (req) => {
+    if (_authReadyPromise) await _authReadyPromise;
     const token = _tokenStore?.getAccessToken();
     if (token) req.headers["Authorization"] = `Bearer ${token}`;
     if (_config?.userId) req.headers["x-user-id"] = _config.userId;
@@ -711,7 +769,17 @@ function initApiClient(config, tokenStore) {
       else if (_config.avatar.url) req.headers["x-avatar-url"] = _config.avatar.url;
       _avatarSent = true;
     }
-    if (token) await waitForTransitReady();
+    if (_config?.transitEncryption) {
+      if (!getTransitSession()) ensureRestTransitHandshake();
+      const ready = await awaitTransitReadyOr(TRANSIT_GATE_MAX_WAIT_MS);
+      if (!ready) {
+        throw new AntzChatNetworkError(
+          "Secure channel to chat server not established \u2014 request not sent. It will retry automatically.",
+          "TRANSIT_NOT_READY",
+          { url: req.url }
+        );
+      }
+    }
     if (isTransitEnabled()) {
       const sessionId = getSessionId();
       const key = getSessionKey();
@@ -1035,7 +1103,6 @@ var _getToken = null;
 var _userId;
 var _tenantId;
 var _config2 = null;
-var _preservingSession = false;
 function setStatus(s) {
   _status = s;
   _statusListeners.forEach((l) => l(s));
@@ -1054,29 +1121,48 @@ function onSocketStatus(listener) {
   _statusListeners.add(listener);
   return () => _statusListeners.delete(listener);
 }
-async function secureEmit(socket, event, payload, ack) {
-  if (isTransitEnabled()) {
-    const key = getSessionKey();
-    if (key) {
-      const envelope = await encryptPayload(payload, key);
-      if (ack) {
-        socket.emit(event, envelope, async (encryptedResponse) => {
-          if (isTransitEnvelope(encryptedResponse)) {
-            try {
-              const decrypted = await decryptPayload(encryptedResponse, key);
-              ack(decrypted);
-            } catch {
-              ack(encryptedResponse);
-            }
-          } else {
-            ack(encryptedResponse);
-          }
-        });
+var SECURE_EMIT_WAIT_MS = 4e3;
+function emitEncrypted(socket, event, envelope, key, ack) {
+  if (ack) {
+    socket.emit(event, envelope, async (encryptedResponse) => {
+      if (isTransitEnvelope(encryptedResponse)) {
+        try {
+          ack(await decryptPayload(encryptedResponse, key));
+        } catch {
+          ack(encryptedResponse);
+        }
       } else {
-        socket.emit(event, envelope);
+        ack(encryptedResponse);
       }
+    });
+  } else {
+    socket.emit(event, envelope);
+  }
+}
+async function secureEmit(socket, event, payload, ack) {
+  let key = getSessionKey();
+  if (key && isTransitEnabled()) {
+    emitEncrypted(socket, event, await encryptPayload(payload, key), key, ack);
+    return;
+  }
+  if (isTransitRequired()) {
+    try {
+      ensureRestTransitHandshake();
+    } catch {
+    }
+    const ok = await awaitTransitReadyOr(SECURE_EMIT_WAIT_MS);
+    key = getSessionKey();
+    if (ok && key && isTransitEnabled()) {
+      emitEncrypted(socket, event, await encryptPayload(payload, key), key, ack);
       return;
     }
+    if (isTransitRequired()) {
+      throw new AntzChatNetworkError(
+        `Transit encryption required but no session established \u2014 "${event}" not sent`,
+        "TRANSIT_NOT_READY",
+        { event }
+      );
+    }
   }
   if (ack) {
     socket.emit(event, payload, ack);
@@ -1102,6 +1188,28 @@ function secureOn(socket, event, handler) {
     handler(raw);
   });
 }
+var _joinedRooms = /* @__PURE__ */ new Set();
+function trackRoomJoin(conversationId) {
+  _joinedRooms.add(conversationId);
+}
+function trackRoomLeave(conversationId) {
+  _joinedRooms.delete(conversationId);
+}
+function resetTrackedRooms() {
+  _joinedRooms.clear();
+}
+function flushJoinedRooms() {
+  const socket = tryGetSocket();
+  if (!socket || _joinedRooms.size === 0) return;
+  for (const conversationId of _joinedRooms) {
+    void secureEmit(socket, "join_room", { conversationId }).catch(() => {
+    });
+  }
+}
+onTransitReady(flushJoinedRooms);
+onSocketStatus((status) => {
+  if (status === "connected") flushJoinedRooms();
+});
 async function connectSocket(config, getToken) {
   if (_socket && !_socket.disconnected) return _socket;
   if (_connectingPromise) return _connectingPromise;
@@ -1123,6 +1231,7 @@ async function _doConnect(config, getToken) {
     ...config.avatar?.url && { avatarUrl: config.avatar.url },
     ...config.avatar?.base64 && { avatarBase64: config.avatar.base64 }
   };
+  configureTransitIfUnset(config.transitEncryption);
   let boundDeriveSessionKey = null;
   if (config.transitEncryption) {
     const inFlight = getTransitHandshakePromise();
@@ -1187,7 +1296,6 @@ async function _doConnect(config, getToken) {
   _socket.on("connect", () => setStatus("connected"));
   _socket.on("disconnect", () => {
     setStatus("disconnected");
-    if (!_preservingSession) clearTransitSession();
   });
   _socket.on("connect_error", (err) => {
     console.error("[AntzChat] Socket connect_error:", err?.message, err?.data);
@@ -1202,8 +1310,9 @@ async function _doConnect(config, getToken) {
         resolve();
       };
       const timeout = setTimeout(() => {
-        console.warn("[AntzChat] transit_session timeout \u2014 unblocking HTTP without transit encryption");
-        configureTransit(false);
+        console.error(
+          "[AntzChat] transit_session did not arrive within 5s. Transit stays REQUIRED \u2014 chat requests are gated (not downgraded to plaintext) until the handshake succeeds via REST retry or socket reconnect. Persistent failure = check POST /crypto/session (rate limit / 5xx) and the socket transit middleware."
+        );
         done();
       }, 5e3);
       _socket.on("transit_session", async ({ sessionId }) => {
@@ -1290,13 +1399,8 @@ function reconnectSocket(token, userId, tenantId) {
         ...tenantId && { tenantId },
         transitSessionId: existing.sessionId
       };
-      _preservingSession = true;
-      try {
-        if (_socket.connected) _socket.disconnect();
-        _socket.connect();
-      } finally {
-        _preservingSession = false;
-      }
+      if (_socket.connected) _socket.disconnect();
+      _socket.connect();
       return;
     }
     if (_getToken) {
@@ -1341,7 +1445,15 @@ async function drainSendQueue(conversationId) {
       entry.reject(new AntzChatNetworkError("Message dropped: queued too long", "MESSAGE_DROPPED"));
       continue;
     }
-    entry.run().then(entry.resolve).catch(entry.reject);
+    let acked;
+    try {
+      ({ acked } = await emitWithAck("send_message", entry.payload));
+    } catch (err) {
+      entry.reject(err);
+      while (queue.length > 0) queue.shift().reject(err);
+      break;
+    }
+    acked.then(entry.resolve).catch(entry.reject);
   }
   sendQueues.delete(conversationId);
   sendQueueRunning.delete(conversationId);
@@ -1354,7 +1466,7 @@ function queueSendMessage(payload) {
     return Promise.reject(new AntzChatNetworkError("Send queue full: too many messages in flight", "SEND_QUEUE_FULL", { conversationId }));
   }
   return new Promise((resolve, reject) => {
-    queue.push({ run: () => withAck("send_message", payload), resolve, reject, enqueuedAt: Date.now() });
+    queue.push({ payload, resolve, reject, enqueuedAt: Date.now() });
     drainSendQueue(conversationId);
   });
 }
@@ -1377,33 +1489,44 @@ function waitForReconnect() {
     });
   });
 }
-async function withAck(event, payload) {
+async function emitWithAck(event, payload) {
   let socket = tryGetSocket();
   if (!socket) {
     await waitForReconnect();
     socket = tryGetSocket();
   }
-  if (!socket) return Promise.reject(new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { event }));
-  return new Promise((resolve, reject) => {
-    let timer;
-    secureEmit(socket, event, payload, (response) => {
-      clearTimeout(timer);
-      resolve(response);
-    }).then(() => {
-      timer = setTimeout(() => reject(new AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })), ACK_TIMEOUT);
-    }).catch(reject);
+  if (!socket) throw new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { event });
+  let resolveAck;
+  let rejectAck;
+  const acked = new Promise((res, rej) => {
+    resolveAck = res;
+    rejectAck = rej;
   });
+  await secureEmit(socket, event, payload, (response) => resolveAck(response));
+  const timer = setTimeout(
+    () => rejectAck(new AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })),
+    ACK_TIMEOUT
+  );
+  void acked.then(() => clearTimeout(timer), () => clearTimeout(timer));
+  return { acked };
+}
+async function withAck(event, payload) {
+  const { acked } = await emitWithAck(event, payload);
+  return acked;
 }
 function fireAndForget(event, payload) {
   const socket = tryGetSocket();
   if (!socket) return;
-  secureEmit(socket, event, payload);
+  secureEmit(socket, event, payload).catch(() => {
+  });
 }
 var socketEmit = {
   joinRoom(conversationId) {
+    trackRoomJoin(conversationId);
     fireAndForget("join_room", { conversationId });
   },
   leaveRoom(conversationId) {
+    trackRoomLeave(conversationId);
     fireAndForget("leave_room", { conversationId });
   },
   sendMessage(payload) {
@@ -2183,6 +2306,7 @@ var AntzChatClient = class {
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isApiClientConfigured,
   isMentionAll,
   isTransitEnvelope,
   messagesApi,
@@ -2195,9 +2319,11 @@ var AntzChatClient = class {
   refreshSocketAuth,
   renderMentionParts,
   resetAuthStore,
+  resetTrackedRooms,
   resolveConfig,
   resolveSystemMessageText,
   setApiClientInstance,
+  setAuthReadyPromise,
   setTransitSession,
   socketEmit,
   storageApi,