@antzsoft/chat-core 1.2.4 → 1.2.5

package/dist/index.cjs

@@ -105,18 +105,27 @@ __export(src_exports, {
   connectSocket: () => connectSocket,
   conversationsApi: () => conversationsApi,
   createAuthStore: () => createAuthStore,
+  createRestTransitSession: () => createRestTransitSession,
+  decryptPayload: () => decryptPayload,
   devicesApi: () => devicesApi,
   disconnectSocket: () => disconnectSocket,
+  encryptPayload: () => encryptPayload,
+  fetchServerKeys: () => fetchServerKeys,
+  generateEphemeralKey: () => generateEphemeralKey,
   getApiClient: () => getApiClient,
   getAuthStore: () => getAuthStore,
   getCompressionStrategy: () => getCompressionStrategy,
+  getSessionId: () => getSessionId,
+  getSessionKey: () => getSessionKey,
   getSocket: () => getSocket,
   getSocketStatus: () => getSocketStatus,
   initApiClient: () => initApiClient,
   initAuthStore: () => initAuthStore,
+  isTransitEnvelope: () => isTransitEnvelope,
   messagesApi: () => messagesApi,
   normalizeConversation: () => normalizeConversation,
   onSocketStatus: () => onSocketStatus,
+  performHandshake: () => performHandshake,
   reconnectSocket: () => reconnectSocket,
   refreshSocketAuth: () => refreshSocketAuth,
   resetAuthStore: () => resetAuthStore,
@@ -391,6 +400,9 @@ function setTransitSession(session) {
   s.readyResolve?.();
   s.readyResolve = null;
 }
+function getTransitSession() {
+  return getState().session;
+}
 function clearTransitSession() {
   const s = getState();
   s.session = null;
@@ -407,10 +419,156 @@ function getSessionId() {
   return getState().session?.sessionId ?? null;
 }
 
+// src/crypto/detect.ts
+var _cached = null;
+async function detectTransitAlgo() {
+  if (_cached) return _cached;
+  try {
+    await globalThis.crypto.subtle.generateKey(
+      { name: "X25519" },
+      false,
+      ["deriveKey"]
+    );
+    _cached = "x25519";
+  } catch {
+    _cached = "p256";
+  }
+  return _cached;
+}
+function resetAlgoCache() {
+  _cached = null;
+}
+
+// src/crypto/handshake.ts
+function hasWebCrypto2() {
+  return typeof globalThis.crypto?.subtle !== "undefined";
+}
+async function fetchServerKeys(apiUrl) {
+  const res = await fetch(`${apiUrl}/crypto/pubkey`);
+  if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
+  const body = await res.json();
+  return body?.data ?? body;
+}
+async function generateEphemeralKey(algo, serverKeys) {
+  if (hasWebCrypto2()) {
+    return generateWebCryptoEphemeralKey(algo, serverKeys);
+  }
+  return generateNobleEphemeralKey(serverKeys);
+}
+async function createRestTransitSession(apiUrl) {
+  try {
+    const serverKeys = await fetchServerKeys(apiUrl);
+    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" },
+      body: JSON.stringify({ ephemeralPub: ephemeralPubB64, algo })
+    });
+    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 {
+    return null;
+  }
+}
+async function performHandshake(algo, serverKeys, socketHandshakeAuth) {
+  const { ephemeralPubB64, deriveSessionKey } = await generateEphemeralKey(algo, serverKeys);
+  socketHandshakeAuth["transitEphemeralPub"] = ephemeralPubB64;
+  socketHandshakeAuth["transitAlgo"] = algo;
+  return deriveSessionKey;
+}
+async function generateWebCryptoEphemeralKey(algo, serverKeys) {
+  const ephemeral = await globalThis.crypto.subtle.generateKey(
+    algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" },
+    false,
+    ["deriveBits"]
+  );
+  const pubRaw = await globalThis.crypto.subtle.exportKey("raw", ephemeral.publicKey);
+  const ephemeralPriv = ephemeral.privateKey;
+  return {
+    ephemeralPubB64: bufToB642(pubRaw),
+    deriveSessionKey: (sessionId) => deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId)
+  };
+}
+async function deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId) {
+  const serverPubRaw = b64ToBuf2(algo === "x25519" ? serverKeys.x25519 : serverKeys.p256);
+  const keyAlgoParams = algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" };
+  const serverPubKey = await globalThis.crypto.subtle.importKey("raw", serverPubRaw, keyAlgoParams, false, []);
+  const sharedBits = await globalThis.crypto.subtle.deriveBits(
+    { name: algo === "x25519" ? "X25519" : "ECDH", public: serverPubKey },
+    ephemeralPriv,
+    256
+  );
+  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", sharedBits, "HKDF", false, ["deriveKey"]);
+  const salt = new TextEncoder().encode(sessionId);
+  const info = new TextEncoder().encode("antz-transit-v1");
+  return globalThis.crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info },
+    hkdfKey,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function generateNobleEphemeralKey(serverKeys) {
+  const { x25519 } = await import("@noble/curves/ed25519");
+  const { hkdf } = await import("@noble/hashes/hkdf");
+  const { sha256 } = await import("@noble/hashes/sha256");
+  const { randomBytes } = await import("@noble/hashes/utils");
+  const ephemeralPriv = randomBytes(32);
+  const ephemeralPub = x25519.getPublicKey(ephemeralPriv);
+  const serverPubBytes = base64ToUint82(serverKeys.x25519);
+  return {
+    ephemeralPubB64: uint8ToBase64(ephemeralPub),
+    deriveSessionKey: (sessionId) => {
+      const sharedSecret = x25519.getSharedSecret(ephemeralPriv, serverPubBytes);
+      const salt = new TextEncoder().encode(sessionId);
+      const info = new TextEncoder().encode("antz-transit-v1");
+      return Promise.resolve(hkdf(sha256, sharedSecret, salt, info, 32));
+    }
+  };
+}
+function bufToB642(buf) {
+  const bytes = new Uint8Array(buf);
+  let str = "";
+  bytes.forEach((b) => {
+    str += String.fromCharCode(b);
+  });
+  return btoa(str);
+}
+function b64ToBuf2(b64) {
+  const bin = atob(b64);
+  const buf = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+  return buf.buffer;
+}
+function uint8ToBase64(bytes) {
+  let str = "";
+  bytes.forEach((b) => {
+    str += String.fromCharCode(b);
+  });
+  return btoa(str);
+}
+function base64ToUint82(b64) {
+  const bin = atob(b64);
+  const buf = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+  return buf;
+}
+
 // src/api/client.ts
 var _tokenStore = null;
 var _config = null;
 var _avatarSent = false;
+var _transitHandshakePromise = null;
+function getTransitHandshakePromise() {
+  return _transitHandshakePromise;
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -420,6 +578,23 @@ 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;
+      }
+    })();
+  }
   client.interceptors.request.use(async (req) => {
     const token = _tokenStore?.getAccessToken();
     if (token) req.headers["Authorization"] = `Bearer ${token}`;
@@ -827,7 +1002,8 @@ function normalizeLastMessage(lastMsg) {
     isEdited: false,
     sentAt: lastMsg.sentAt ?? "",
     createdAt: lastMsg.sentAt ?? "",
-    ...lastMsg.senderName && { senderName: lastMsg.senderName }
+    ...lastMsg.senderName && { senderName: lastMsg.senderName },
+    ...lastMsg.attachmentType && { attachmentType: lastMsg.attachmentType }
   };
 }
 function normalizeConversation(conv) {
@@ -1191,122 +1367,6 @@ var usersApi = {
 
 // src/socket/socket.ts
 var import_socket = require("socket.io-client");
-
-// src/crypto/detect.ts
-var _cached = null;
-async function detectTransitAlgo() {
-  if (_cached) return _cached;
-  try {
-    await globalThis.crypto.subtle.generateKey(
-      { name: "X25519" },
-      false,
-      ["deriveKey"]
-    );
-    _cached = "x25519";
-  } catch {
-    _cached = "p256";
-  }
-  return _cached;
-}
-function resetAlgoCache() {
-  _cached = null;
-}
-
-// src/crypto/handshake.ts
-function hasWebCrypto2() {
-  return typeof globalThis.crypto?.subtle !== "undefined";
-}
-async function fetchServerKeys(apiUrl) {
-  const res = await fetch(`${apiUrl}/crypto/pubkey`);
-  if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
-  const body = await res.json();
-  return body?.data ?? body;
-}
-async function performHandshake(algo, serverKeys, socketHandshakeAuth) {
-  if (hasWebCrypto2()) {
-    return performWebCryptoHandshake(algo, serverKeys, socketHandshakeAuth);
-  }
-  return performNobleHandshake(serverKeys, socketHandshakeAuth);
-}
-async function performWebCryptoHandshake(algo, serverKeys, socketHandshakeAuth) {
-  const ephemeral = await globalThis.crypto.subtle.generateKey(
-    algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" },
-    false,
-    ["deriveBits"]
-  );
-  const pubRaw = await globalThis.crypto.subtle.exportKey("raw", ephemeral.publicKey);
-  socketHandshakeAuth["transitEphemeralPub"] = bufToB642(pubRaw);
-  socketHandshakeAuth["transitAlgo"] = algo;
-  const ephemeralPriv = ephemeral.privateKey;
-  return (sessionId) => deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId);
-}
-async function deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId) {
-  const serverPubRaw = b64ToBuf2(algo === "x25519" ? serverKeys.x25519 : serverKeys.p256);
-  const keyAlgoParams = algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" };
-  const serverPubKey = await globalThis.crypto.subtle.importKey("raw", serverPubRaw, keyAlgoParams, false, []);
-  const sharedBits = await globalThis.crypto.subtle.deriveBits(
-    { name: algo === "x25519" ? "X25519" : "ECDH", public: serverPubKey },
-    ephemeralPriv,
-    256
-  );
-  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", sharedBits, "HKDF", false, ["deriveKey"]);
-  const salt = new TextEncoder().encode(sessionId);
-  const info = new TextEncoder().encode("antz-transit-v1");
-  return globalThis.crypto.subtle.deriveKey(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-async function performNobleHandshake(serverKeys, socketHandshakeAuth) {
-  const { x25519 } = await import("@noble/curves/ed25519");
-  const { hkdf } = await import("@noble/hashes/hkdf");
-  const { sha256 } = await import("@noble/hashes/sha256");
-  const { randomBytes } = await import("@noble/hashes/utils");
-  const ephemeralPriv = randomBytes(32);
-  const ephemeralPub = x25519.getPublicKey(ephemeralPriv);
-  const serverPubBytes = base64ToUint82(serverKeys.x25519);
-  socketHandshakeAuth["transitEphemeralPub"] = uint8ToBase64(ephemeralPub);
-  socketHandshakeAuth["transitAlgo"] = "x25519";
-  return (sessionId) => {
-    const sharedSecret = x25519.getSharedSecret(ephemeralPriv, serverPubBytes);
-    const salt = new TextEncoder().encode(sessionId);
-    const info = new TextEncoder().encode("antz-transit-v1");
-    const sessionKey = hkdf(sha256, sharedSecret, salt, info, 32);
-    return Promise.resolve(sessionKey);
-  };
-}
-function bufToB642(buf) {
-  const bytes = new Uint8Array(buf);
-  let str = "";
-  bytes.forEach((b) => {
-    str += String.fromCharCode(b);
-  });
-  return btoa(str);
-}
-function b64ToBuf2(b64) {
-  const bin = atob(b64);
-  const buf = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
-  return buf.buffer;
-}
-function uint8ToBase64(bytes) {
-  let str = "";
-  bytes.forEach((b) => {
-    str += String.fromCharCode(b);
-  });
-  return btoa(str);
-}
-function base64ToUint82(b64) {
-  const bin = atob(b64);
-  const buf = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
-  return buf;
-}
-
-// src/socket/socket.ts
 var _socket = null;
 var _socketProxy = null;
 var _connectingPromise = null;
@@ -1403,17 +1463,35 @@ async function _doConnect(config, getToken) {
   };
   let boundDeriveSessionKey = null;
   if (config.transitEncryption) {
-    try {
-      const serverKeys = await fetchServerKeys(config.apiUrl);
-      if (!serverKeys.enabled) {
-        throw new Error(
-          "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=true but server has TRANSIT_ENCRYPTION_ENABLED=false. Align the config on both sides."
-        );
+    const inFlight = getTransitHandshakePromise();
+    if (inFlight) await inFlight;
+    const existingSession = getTransitSession();
+    let httpsSession = null;
+    if (existingSession?.enabled && existingSession.sessionId) {
+      httpsSession = { sessionId: existingSession.sessionId, sessionKey: existingSession.sessionKey };
+    } else {
+      httpsSession = await createRestTransitSession(config.apiUrl);
+      if (httpsSession) {
+        const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
+        setTransitSession({ sessionKey: httpsSession.sessionKey, algo, sessionId: httpsSession.sessionId, enabled: true });
+      }
+    }
+    if (httpsSession) {
+      socketHandshakeAuth["transitSessionId"] = httpsSession.sessionId;
+      boundDeriveSessionKey = null;
+    } else {
+      try {
+        const serverKeys = await fetchServerKeys(config.apiUrl);
+        if (!serverKeys.enabled) {
+          throw new Error(
+            "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=true but server has TRANSIT_ENCRYPTION_ENABLED=false. Align the config on both sides."
+          );
+        }
+        const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
+        boundDeriveSessionKey = await performHandshake(algo, serverKeys, socketHandshakeAuth);
+      } catch (err) {
+        throw err;
       }
-      const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
-      boundDeriveSessionKey = await performHandshake(algo, serverKeys, socketHandshakeAuth);
-    } catch (err) {
-      throw err;
     }
   } else {
     try {
@@ -1571,11 +1649,7 @@ async function drainSendQueue(conversationId) {
       entry.reject(new Error("[AntzChat] Message dropped: queued too long"));
       continue;
     }
-    try {
-      entry.resolve(await entry.run());
-    } catch (e) {
-      entry.reject(e);
-    }
+    entry.run().then(entry.resolve).catch(entry.reject);
   }
   sendQueues.delete(conversationId);
   sendQueueRunning.delete(conversationId);
@@ -1619,11 +1693,13 @@ async function withAck(event, payload) {
   }
   if (!socket) return Promise.reject(new Error(`[AntzChat] Socket not connected (event: ${event})`));
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`Socket ack timeout: ${event}`)), ACK_TIMEOUT);
+    let timer;
     secureEmit(socket, event, payload, (response) => {
       clearTimeout(timer);
       resolve(response);
-    });
+    }).then(() => {
+      timer = setTimeout(() => reject(new Error(`Socket ack timeout: ${event}`)), ACK_TIMEOUT);
+    }).catch(reject);
   });
 }
 function fireAndForget(event, payload) {
@@ -1673,7 +1749,7 @@ var socketEmit = {
     const socket = tryGetSocket();
     if (!socket) return Promise.resolve([]);
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("get_online_users timeout")), ACK_TIMEOUT);
+      let timer;
       secureEmit(socket, "get_online_users", { userIds }, (response) => {
         clearTimeout(timer);
         if (response && typeof response === "object" && "onlineStatus" in response) {
@@ -1684,7 +1760,9 @@ var socketEmit = {
         } else {
           resolve([]);
         }
-      });
+      }).then(() => {
+        timer = setTimeout(() => reject(new Error("get_online_users timeout")), ACK_TIMEOUT);
+      }).catch(reject);
     });
   },
   getTypingUsers(conversationId) {
@@ -1752,18 +1830,27 @@ var AntzChatClient = class {
   connectSocket,
   conversationsApi,
   createAuthStore,
+  createRestTransitSession,
+  decryptPayload,
   devicesApi,
   disconnectSocket,
+  encryptPayload,
+  fetchServerKeys,
+  generateEphemeralKey,
   getApiClient,
   getAuthStore,
   getCompressionStrategy,
+  getSessionId,
+  getSessionKey,
   getSocket,
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isTransitEnvelope,
   messagesApi,
   normalizeConversation,
   onSocketStatus,
+  performHandshake,
   reconnectSocket,
   refreshSocketAuth,
   resetAuthStore,