@antzsoft/chat-core 1.4.4 → 1.4.6

package/dist/index.cjs

@@ -111,6 +111,7 @@ __export(src_exports, {
   HIGHLY_FORWARDED_DEPTH_THRESHOLD: () => HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS: () => MAX_FORWARD_TARGETS,
   MENTION_ALL_ID: () => MENTION_ALL_ID,
+  TransitRateLimitedError: () => TransitRateLimitedError,
   appConfigApi: () => appConfigApi,
   authApi: () => authApi,
   buildMentionText: () => buildMentionText,
@@ -134,6 +135,7 @@ __export(src_exports, {
   getSocketStatus: () => getSocketStatus,
   initApiClient: () => initApiClient,
   initAuthStore: () => initAuthStore,
+  isApiClientConfigured: () => isApiClientConfigured,
   isMentionAll: () => isMentionAll,
   isTransitEnvelope: () => isTransitEnvelope,
   messagesApi: () => messagesApi,
@@ -142,13 +144,16 @@ __export(src_exports, {
   onSocketStatus: () => onSocketStatus,
   parseMentions: () => parseMentions,
   performHandshake: () => performHandshake,
+  readRetryAfterMs: () => readRetryAfterMs,
   reconnectSocket: () => reconnectSocket,
   refreshSocketAuth: () => refreshSocketAuth,
   renderMentionParts: () => renderMentionParts,
   resetAuthStore: () => resetAuthStore,
+  resetTrackedRooms: () => resetTrackedRooms,
   resolveConfig: () => resolveConfig,
   resolveSystemMessageText: () => resolveSystemMessageText,
   setApiClientInstance: () => setApiClientInstance,
+  setAuthReadyPromise: () => setAuthReadyPromise,
   setTransitSession: () => setTransitSession,
   socketEmit: () => socketEmit,
   storageApi: () => storageApi,
@@ -214,6 +219,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 +392,8 @@ function getState() {
       sessionEverEstablished: false,
       readyResolve: null,
       readyPromise: null,
-      transitConfigured: null
+      transitConfigured: null,
+      readyListeners: /* @__PURE__ */ new Set()
     };
   }
   return g[_KEY];
@@ -399,11 +406,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 +426,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 +456,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;
 }
@@ -458,11 +494,36 @@ function resetAlgoCache() {
 }
 
 // src/crypto/handshake.ts
+function readRetryAfterMs(headers) {
+  const parse = (raw) => {
+    if (!raw) return void 0;
+    const secs = Number(raw);
+    if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+    const when = Date.parse(raw);
+    return Number.isNaN(when) ? void 0 : Math.max(0, when - Date.now());
+  };
+  const found = ["Retry-After-identity", "Retry-After-ip", "Retry-After"].map((name) => parse(headers.get(name))).filter((ms) => ms != null);
+  return found.length > 0 ? Math.max(...found) : void 0;
+}
+var TransitRateLimitedError = class extends Error {
+  constructor(retryAfterMs) {
+    super("[AntzChat] transit handshake rate-limited (429)");
+    this.name = "TransitRateLimitedError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+function identityHeaders(identity) {
+  const headers = {};
+  if (identity?.userId) headers["x-user-id"] = identity.userId;
+  if (identity?.tenantId) headers["X-Tenant-ID"] = identity.tenantId;
+  return headers;
+}
 function hasWebCrypto2() {
   return typeof globalThis.crypto?.subtle !== "undefined";
 }
-async function fetchServerKeys(apiUrl) {
-  const res = await fetch(`${apiUrl}/crypto/pubkey`);
+async function fetchServerKeys(apiUrl, identity) {
+  const res = await fetch(`${apiUrl}/crypto/pubkey`, { headers: identityHeaders(identity) });
+  if (res.status === 429) throw new TransitRateLimitedError(readRetryAfterMs(res.headers));
   if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
   const body = await res.json();
   return body?.data ?? body;
@@ -473,24 +534,26 @@ async function generateEphemeralKey(algo, serverKeys) {
   }
   return generateNobleEphemeralKey(serverKeys);
 }
-async function createRestTransitSession(apiUrl) {
+async function createRestTransitSession(apiUrl, identity) {
   try {
-    const serverKeys = await fetchServerKeys(apiUrl);
+    const serverKeys = await fetchServerKeys(apiUrl, identity);
     if (!serverKeys.enabled) return null;
     const algo = hasWebCrypto2() ? await detectTransitAlgo() : "x25519";
     const { ephemeralPubB64, deriveSessionKey } = await generateEphemeralKey(algo, serverKeys);
     const res = await fetch(`${apiUrl}/crypto/session`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", ...identityHeaders(identity) },
       body: JSON.stringify({ ephemeralPub: ephemeralPubB64, algo })
     });
+    if (res.status === 429) throw new TransitRateLimitedError(readRetryAfterMs(res.headers));
     if (!res.ok) return null;
     const body = await res.json();
     const sessionId = (body?.data ?? body)?.sessionId ?? body?.sessionId;
     if (!sessionId) return null;
     const sessionKey = await deriveSessionKey(sessionId);
     return { sessionId, sessionKey };
-  } catch {
+  } catch (err) {
+    if (err instanceof TransitRateLimitedError) throw err;
     return null;
   }
 }
@@ -668,13 +731,72 @@ 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 {
+      const MAX_FAILURES = 5;
+      const BACKSTOP_MS = 2 * 6e4;
+      const deadline = Date.now() + BACKSTOP_MS;
+      let failures = 0;
+      let rateLimitHits = 0;
+      while (failures < MAX_FAILURES && Date.now() < deadline) {
+        if (getTransitSession()) return;
+        let waitMs;
+        try {
+          const identity = { userId: _config?.userId, tenantId: _config?.tenantId };
+          const keys = await fetchServerKeys(apiUrl, identity);
+          if (!keys?.enabled) {
+            configureTransit(false);
+            return;
+          }
+          const session = await createRestTransitSession(apiUrl, identity);
+          if (session && !getTransitSession()) {
+            const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
+            setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
+            return;
+          }
+          failures++;
+          waitMs = Math.min(500 * 2 ** failures, 8e3);
+        } catch (err) {
+          if (err instanceof TransitRateLimitedError) {
+            const blind = Math.min(15e3 * 2 ** rateLimitHits, 6e4);
+            waitMs = err.retryAfterMs != null ? Math.min(Math.max(err.retryAfterMs, 1e3), 6e4) : blind;
+            rateLimitHits++;
+            console.warn(
+              `[AntzChat] transit handshake rate-limited (429) \u2014 retrying in ${Math.round(waitMs / 1e3)}s${err.retryAfterMs != null ? " (per Retry-After)" : ""}.`
+            );
+          } else {
+            failures++;
+            waitMs = Math.min(500 * 2 ** failures, 8e3);
+          }
+        }
+        await new Promise((r) => setTimeout(r, waitMs));
+      }
+      console.error(
+        "[AntzChat] transit handshake could not establish a session \u2014 chat requests stay gated until one succeeds (server requires transit)."
+      );
+    } finally {
+      _transitHandshakePromise = null;
+    }
+  })();
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -684,24 +806,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 +818,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 +1152,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 +1170,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 +1237,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 +1280,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();
@@ -1132,7 +1290,7 @@ async function _doConnect(config, getToken) {
     if (existingSession?.enabled && existingSession.sessionId) {
       httpsSession = { sessionId: existingSession.sessionId, sessionKey: existingSession.sessionKey };
     } else {
-      httpsSession = await createRestTransitSession(config.apiUrl);
+      httpsSession = await createRestTransitSession(config.apiUrl, { userId: config.userId, tenantId: config.tenantId });
       if (httpsSession) {
         const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
         setTransitSession({ sessionKey: httpsSession.sessionKey, algo, sessionId: httpsSession.sessionId, enabled: true });
@@ -1143,7 +1301,7 @@ async function _doConnect(config, getToken) {
       boundDeriveSessionKey = null;
     } else {
       try {
-        const serverKeys = await fetchServerKeys(config.apiUrl);
+        const serverKeys = await fetchServerKeys(config.apiUrl, { userId: config.userId, tenantId: config.tenantId });
         if (!serverKeys.enabled) {
           throw new AntzChatError(
             "TRANSIT_MISMATCH",
@@ -1160,7 +1318,7 @@ async function _doConnect(config, getToken) {
     }
   } else {
     try {
-      const serverKeys = await fetchServerKeys(config.apiUrl);
+      const serverKeys = await fetchServerKeys(config.apiUrl, { userId: config.userId, tenantId: config.tenantId });
       if (serverKeys.enabled) {
         throw new AntzChatError(
           "TRANSIT_MISMATCH",
@@ -1187,7 +1345,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 +1359,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 +1448,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 +1494,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 +1515,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 +1538,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) {
@@ -2160,6 +2332,7 @@ var AntzChatClient = class {
   HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS,
   MENTION_ALL_ID,
+  TransitRateLimitedError,
   appConfigApi,
   authApi,
   buildMentionText,
@@ -2183,6 +2356,7 @@ var AntzChatClient = class {
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isApiClientConfigured,
   isMentionAll,
   isTransitEnvelope,
   messagesApi,
@@ -2191,13 +2365,16 @@ var AntzChatClient = class {
   onSocketStatus,
   parseMentions,
   performHandshake,
+  readRetryAfterMs,
   reconnectSocket,
   refreshSocketAuth,
   renderMentionParts,
   resetAuthStore,
+  resetTrackedRooms,
   resolveConfig,
   resolveSystemMessageText,
   setApiClientInstance,
+  setAuthReadyPromise,
   setTransitSession,
   socketEmit,
   storageApi,