@dropgate/core 2.0.0-beta.2 → 2.2.0-beta.1

package/dist/p2p/index.js

@@ -66,11 +66,11 @@ function isSecureContextForP2P(hostname, isSecureContext) {
   return Boolean(isSecureContext) || isLocalhostHostname(hostname || "");
 }
 function generateP2PCode(cryptoObj) {
-  const crypto = cryptoObj || getDefaultCrypto();
+  const crypto2 = cryptoObj || getDefaultCrypto();
   const letters = "ABCDEFGHJKLMNPQRSTUVWXYZ";
-  if (crypto) {
+  if (crypto2) {
     const randomBytes = new Uint8Array(8);
-    crypto.getRandomValues(randomBytes);
+    crypto2.getRandomValues(randomBytes);
     let letterPart = "";
     for (let i = 0; i < 4; i++) {
       letterPart += letters[randomBytes[i] % letters.length];
@@ -96,8 +96,14 @@ function isP2PCodeLike(code) {
 }
 
 // src/p2p/helpers.ts
-function buildPeerOptions(opts = {}) {
-  const { host, port, peerjsPath = "/peerjs", secure = false, iceServers = [] } = opts;
+function resolvePeerConfig(userConfig, serverCaps) {
+  return {
+    path: userConfig.peerjsPath ?? serverCaps?.peerjsPath ?? "/peerjs",
+    iceServers: userConfig.iceServers ?? serverCaps?.iceServers ?? []
+  };
+}
+function buildPeerOptions(config = {}) {
+  const { host, port, peerjsPath = "/peerjs", secure = false, iceServers = [] } = config;
   const peerOpts = {
     host,
     path: peerjsPath,
@@ -139,6 +145,12 @@ async function createPeerWithRetries(opts) {
 }
 
 // src/p2p/send.ts
+function generateSessionId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
 async function startP2PSend(opts) {
   const {
     file,
@@ -153,15 +165,17 @@ async function startP2PSend(opts) {
     cryptoObj,
     maxAttempts = 4,
     chunkSize = 256 * 1024,
-    readyTimeoutMs = 8e3,
     endAckTimeoutMs = 15e3,
     bufferHighWaterMark = 8 * 1024 * 1024,
     bufferLowWaterMark = 2 * 1024 * 1024,
+    heartbeatIntervalMs = 5e3,
     onCode,
     onStatus,
     onProgress,
     onComplete,
-    onError
+    onError,
+    onDisconnect,
+    onCancel
   } = opts;
   if (!file) {
     throw new DropgateValidationError("File is missing.");
@@ -175,8 +189,10 @@ async function startP2PSend(opts) {
   if (serverInfo && !p2pCaps?.enabled) {
     throw new DropgateValidationError("Direct transfer is disabled on this server.");
   }
-  const finalPath = peerjsPath ?? p2pCaps?.peerjsPath ?? "/peerjs";
-  const finalIceServers = iceServers ?? p2pCaps?.iceServers ?? [];
+  const { path: finalPath, iceServers: finalIceServers } = resolvePeerConfig(
+    { peerjsPath, iceServers },
+    p2pCaps
+  );
   const peerOpts = buildPeerOptions({
     host,
     port,
@@ -193,18 +209,37 @@ async function startP2PSend(opts) {
     buildPeer,
     onCode
   });
-  let stopped = false;
+  const sessionId = generateSessionId();
+  let state = "listening";
   let activeConn = null;
-  let transferActive = false;
-  let transferCompleted = false;
+  let sentBytes = 0;
+  let heartbeatTimer = null;
   const reportProgress = (data) => {
     const safeTotal = Number.isFinite(data.total) && data.total > 0 ? data.total : file.size;
     const safeReceived = Math.min(Number(data.received) || 0, safeTotal || 0);
     const percent = safeTotal ? safeReceived / safeTotal * 100 : 0;
-    onProgress?.({ sent: safeReceived, total: safeTotal, percent });
+    onProgress?.({ processedBytes: safeReceived, totalBytes: safeTotal, percent });
   };
-  const stop = () => {
-    stopped = true;
+  const safeError = (err) => {
+    if (state === "closed" || state === "completed" || state === "cancelled") return;
+    state = "closed";
+    onError?.(err);
+    cleanup();
+  };
+  const safeComplete = () => {
+    if (state !== "finishing") return;
+    state = "completed";
+    onComplete?.();
+    cleanup();
+  };
+  const cleanup = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("beforeunload", handleUnload);
+    }
     try {
       activeConn?.close();
     } catch {
@@ -214,21 +249,69 @@ async function startP2PSend(opts) {
     } catch {
     }
   };
+  const handleUnload = () => {
+    try {
+      activeConn?.send({ t: "error", message: "Sender closed the connection." });
+    } catch {
+    }
+    stop();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("beforeunload", handleUnload);
+  }
+  const stop = () => {
+    if (state === "closed" || state === "cancelled") return;
+    const wasActive = state === "transferring" || state === "finishing";
+    state = "cancelled";
+    try {
+      if (activeConn && activeConn.open) {
+        activeConn.send({ t: "cancelled", message: "Sender cancelled the transfer." });
+      }
+    } catch {
+    }
+    if (wasActive && onCancel) {
+      onCancel({ cancelledBy: "sender" });
+    }
+    cleanup();
+  };
+  const isStopped = () => state === "closed" || state === "cancelled";
   peer.on("connection", (conn) => {
-    if (stopped) return;
+    if (state === "closed") return;
     if (activeConn) {
-      try {
-        conn.send({ t: "error", message: "Another receiver is already connected." });
-      } catch {
-      }
-      try {
-        conn.close();
-      } catch {
+      const isOldConnOpen = activeConn.open !== false;
+      if (isOldConnOpen && state === "transferring") {
+        try {
+          conn.send({ t: "error", message: "Transfer already in progress." });
+        } catch {
+        }
+        try {
+          conn.close();
+        } catch {
+        }
+        return;
+      } else if (!isOldConnOpen) {
+        try {
+          activeConn.close();
+        } catch {
+        }
+        activeConn = null;
+        state = "listening";
+        sentBytes = 0;
+      } else {
+        try {
+          conn.send({ t: "error", message: "Another receiver is already connected." });
+        } catch {
+        }
+        try {
+          conn.close();
+        } catch {
+        }
+        return;
       }
-      return;
     }
     activeConn = conn;
-    onStatus?.({ phase: "connected", message: "Connected. Starting transfer..." });
+    state = "negotiating";
+    onStatus?.({ phase: "waiting", message: "Connected. Waiting for receiver to accept..." });
     let readyResolve = null;
     let ackResolve = null;
     const readyPromise = new Promise((resolve) => {
@@ -244,6 +327,7 @@ async function startP2PSend(opts) {
       const msg = data;
       if (!msg.t) return;
       if (msg.t === "ready") {
+        onStatus?.({ phase: "transferring", message: "Receiver accepted. Starting transfer..." });
         readyResolve?.();
         return;
       }
@@ -255,22 +339,30 @@ async function startP2PSend(opts) {
         ackResolve?.(msg);
         return;
       }
+      if (msg.t === "pong") {
+        return;
+      }
       if (msg.t === "error") {
-        onError?.(new DropgateNetworkError(msg.message || "Receiver reported an error."));
-        stop();
+        safeError(new DropgateNetworkError(msg.message || "Receiver reported an error."));
+        return;
+      }
+      if (msg.t === "cancelled") {
+        if (state === "cancelled" || state === "closed" || state === "completed") return;
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "receiver", message: msg.message });
+        cleanup();
       }
     });
     conn.on("open", async () => {
       try {
-        transferActive = true;
-        if (stopped) return;
+        if (isStopped()) return;
         conn.send({
           t: "meta",
+          sessionId,
           name: file.name,
           size: file.size,
           mime: file.type || "application/octet-stream"
         });
-        let sent = 0;
         const total = file.size;
         const dc = conn._dc;
         if (dc && Number.isFinite(bufferLowWaterMark)) {
@@ -279,13 +371,26 @@ async function startP2PSend(opts) {
           } catch {
           }
         }
-        await Promise.race([readyPromise, sleep(readyTimeoutMs).catch(() => null)]);
+        await readyPromise;
+        if (isStopped()) return;
+        if (heartbeatIntervalMs > 0) {
+          heartbeatTimer = setInterval(() => {
+            if (state === "transferring" || state === "finishing") {
+              try {
+                conn.send({ t: "ping" });
+              } catch {
+              }
+            }
+          }, heartbeatIntervalMs);
+        }
+        state = "transferring";
         for (let offset = 0; offset < total; offset += chunkSize) {
-          if (stopped) return;
+          if (isStopped()) return;
           const slice = file.slice(offset, offset + chunkSize);
           const buf = await slice.arrayBuffer();
+          if (isStopped()) return;
           conn.send(buf);
-          sent += buf.byteLength;
+          sentBytes += buf.byteLength;
           if (dc) {
             while (dc.bufferedAmount > bufferHighWaterMark) {
               await new Promise((resolve) => {
@@ -305,13 +410,15 @@ async function startP2PSend(opts) {
             }
           }
         }
-        if (stopped) return;
+        if (isStopped()) return;
+        state = "finishing";
         conn.send({ t: "end" });
         const ackTimeoutMs = Number.isFinite(endAckTimeoutMs) ? Math.max(endAckTimeoutMs, Math.ceil(file.size / (1024 * 1024)) * 1e3) : null;
         const ackResult = await Promise.race([
           ackPromise,
           sleep(ackTimeoutMs || 15e3).catch(() => null)
         ]);
+        if (isStopped()) return;
         if (!ackResult || typeof ackResult !== "object") {
           throw new DropgateNetworkError("Receiver did not confirm completion.");
         }
@@ -322,29 +429,43 @@ async function startP2PSend(opts) {
           throw new DropgateNetworkError("Receiver reported an incomplete transfer.");
         }
         reportProgress({ received: ackReceived || ackTotal, total: ackTotal });
-        transferCompleted = true;
-        transferActive = false;
-        onComplete?.();
-        stop();
+        safeComplete();
       } catch (err) {
-        onError?.(err);
-        stop();
+        safeError(err);
       }
     });
     conn.on("error", (err) => {
-      onError?.(err);
-      stop();
+      safeError(err);
     });
     conn.on("close", () => {
-      if (!transferCompleted && transferActive && !stopped) {
-        onError?.(
-          new DropgateNetworkError("Receiver disconnected before transfer completed.")
-        );
+      if (state === "closed" || state === "completed" || state === "cancelled") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring" || state === "finishing") {
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "receiver" });
+        cleanup();
+      } else {
+        activeConn = null;
+        state = "listening";
+        sentBytes = 0;
+        onDisconnect?.();
       }
-      stop();
     });
   });
-  return { peer, code, stop };
+  return {
+    peer,
+    code,
+    sessionId,
+    stop,
+    getStatus: () => state,
+    getBytesSent: () => sentBytes,
+    getConnectedPeerId: () => {
+      if (!activeConn) return null;
+      return activeConn.peer || null;
+    }
+  };
 }
 
 // src/p2p/receive.ts
@@ -358,13 +479,16 @@ async function startP2PReceive(opts) {
     peerjsPath,
     secure = false,
     iceServers,
+    autoReady = true,
+    watchdogTimeoutMs = 15e3,
     onStatus,
     onMeta,
     onData,
     onProgress,
     onComplete,
     onError,
-    onDisconnect
+    onDisconnect,
+    onCancel
   } = opts;
   if (!code) {
     throw new DropgateValidationError("No sharing code was provided.");
@@ -382,8 +506,10 @@ async function startP2PReceive(opts) {
   if (!isP2PCodeLike(normalizedCode)) {
     throw new DropgateValidationError("Invalid direct transfer code.");
   }
-  const finalPath = peerjsPath ?? p2pCaps?.peerjsPath ?? "/peerjs";
-  const finalIceServers = iceServers ?? p2pCaps?.iceServers ?? [];
+  const { path: finalPath, iceServers: finalIceServers } = resolvePeerConfig(
+    { peerjsPath, iceServers },
+    p2pCaps
+  );
   const peerOpts = buildPeerOptions({
     host,
     port,
@@ -392,44 +518,137 @@ async function startP2PReceive(opts) {
     iceServers: finalIceServers
   });
   const peer = new Peer(void 0, peerOpts);
+  let state = "initializing";
   let total = 0;
   let received = 0;
+  let currentSessionId = null;
   let lastProgressSentAt = 0;
   const progressIntervalMs = 120;
   let writeQueue = Promise.resolve();
-  const stop = () => {
+  let watchdogTimer = null;
+  let activeConn = null;
+  const resetWatchdog = () => {
+    if (watchdogTimeoutMs <= 0) return;
+    if (watchdogTimer) {
+      clearTimeout(watchdogTimer);
+    }
+    watchdogTimer = setTimeout(() => {
+      if (state === "transferring") {
+        safeError(new DropgateNetworkError("Connection timed out (no data received)."));
+      }
+    }, watchdogTimeoutMs);
+  };
+  const clearWatchdog = () => {
+    if (watchdogTimer) {
+      clearTimeout(watchdogTimer);
+      watchdogTimer = null;
+    }
+  };
+  const safeError = (err) => {
+    if (state === "closed" || state === "completed" || state === "cancelled") return;
+    state = "closed";
+    onError?.(err);
+    cleanup();
+  };
+  const safeComplete = (completeData) => {
+    if (state !== "transferring") return;
+    state = "completed";
+    onComplete?.(completeData);
+    cleanup();
+  };
+  const cleanup = () => {
+    clearWatchdog();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("beforeunload", handleUnload);
+    }
     try {
       peer.destroy();
     } catch {
     }
   };
-  peer.on("error", (err) => {
-    onError?.(err);
+  const handleUnload = () => {
+    try {
+      activeConn?.send({ t: "error", message: "Receiver closed the connection." });
+    } catch {
+    }
     stop();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("beforeunload", handleUnload);
+  }
+  const stop = () => {
+    if (state === "closed" || state === "cancelled") return;
+    const wasActive = state === "transferring";
+    state = "cancelled";
+    try {
+      if (activeConn && activeConn.open) {
+        activeConn.send({ t: "cancelled", message: "Receiver cancelled the transfer." });
+      }
+    } catch {
+    }
+    if (wasActive && onCancel) {
+      onCancel({ cancelledBy: "receiver" });
+    }
+    cleanup();
+  };
+  peer.on("error", (err) => {
+    safeError(err);
   });
   peer.on("open", () => {
+    state = "connecting";
     const conn = peer.connect(normalizedCode, { reliable: true });
+    activeConn = conn;
     conn.on("open", () => {
+      state = "negotiating";
       onStatus?.({ phase: "connected", message: "Waiting for file details..." });
     });
     conn.on("data", async (data) => {
       try {
+        resetWatchdog();
         if (data && typeof data === "object" && !(data instanceof ArrayBuffer) && !ArrayBuffer.isView(data)) {
           const msg = data;
           if (msg.t === "meta") {
+            if (currentSessionId && msg.sessionId && msg.sessionId !== currentSessionId) {
+              try {
+                conn.send({ t: "error", message: "Busy with another session." });
+              } catch {
+              }
+              return;
+            }
+            if (msg.sessionId) {
+              currentSessionId = msg.sessionId;
+            }
             const name = String(msg.name || "file");
             total = Number(msg.size) || 0;
             received = 0;
             writeQueue = Promise.resolve();
-            onMeta?.({ name, total });
-            onProgress?.({ received, total, percent: 0 });
+            const sendReady = () => {
+              state = "transferring";
+              resetWatchdog();
+              try {
+                conn.send({ t: "ready" });
+              } catch {
+              }
+            };
+            if (autoReady) {
+              onMeta?.({ name, total });
+              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              sendReady();
+            } else {
+              onMeta?.({ name, total, sendReady });
+              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+            }
+            return;
+          }
+          if (msg.t === "ping") {
             try {
-              conn.send({ t: "ready" });
+              conn.send({ t: "pong" });
             } catch {
             }
             return;
           }
           if (msg.t === "end") {
+            clearWatchdog();
             await writeQueue;
             if (total && received < total) {
               const err = new DropgateNetworkError(
@@ -441,16 +660,23 @@ async function startP2PReceive(opts) {
               }
               throw err;
             }
-            onComplete?.({ received, total });
             try {
               conn.send({ t: "ack", phase: "end", received, total });
             } catch {
             }
+            safeComplete({ received, total });
             return;
           }
           if (msg.t === "error") {
             throw new DropgateNetworkError(msg.message || "Sender reported an error.");
           }
+          if (msg.t === "cancelled") {
+            if (state === "cancelled" || state === "closed" || state === "completed") return;
+            state = "cancelled";
+            onCancel?.({ cancelledBy: "sender", message: msg.message });
+            cleanup();
+            return;
+          }
           return;
         }
         let bufPromise;
@@ -472,7 +698,7 @@ async function startP2PReceive(opts) {
           }
           received += buf.byteLength;
           const percent = total ? Math.min(100, received / total * 100) : 0;
-          onProgress?.({ received, total, percent });
+          onProgress?.({ processedBytes: received, totalBytes: total, percent });
           const now = Date.now();
           if (received === total || now - lastProgressSentAt >= progressIntervalMs) {
             lastProgressSentAt = now;
@@ -489,21 +715,38 @@ async function startP2PReceive(opts) {
             });
           } catch {
           }
-          onError?.(err);
-          stop();
+          safeError(err);
         });
       } catch (err) {
-        onError?.(err);
-        stop();
+        safeError(err);
       }
     });
     conn.on("close", () => {
-      if (received > 0 && total > 0 && received < total) {
+      if (state === "closed" || state === "completed" || state === "cancelled") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring") {
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "sender" });
+        cleanup();
+      } else if (state === "negotiating") {
+        state = "closed";
+        cleanup();
         onDisconnect?.();
+      } else {
+        safeError(new DropgateNetworkError("Sender disconnected before file details were received."));
       }
     });
   });
-  return { peer, stop };
+  return {
+    peer,
+    stop,
+    getStatus: () => state,
+    getBytesReceived: () => received,
+    getTotalBytes: () => total,
+    getSessionId: () => currentSessionId
+  };
 }
 export {
   buildPeerOptions,
@@ -512,6 +755,7 @@ export {
   isLocalhostHostname,
   isP2PCodeLike,
   isSecureContextForP2P,
+  resolvePeerConfig,
   startP2PReceive,
   startP2PSend
 };