srift-transfer 4.3.0 → 4.3.2

package/dist/daemon.js

@@ -1767,7 +1767,7 @@ var init_skills_data = __esm({
       { name: "encrypted-chat", content: "---\nname: encrypted-chat\ndescription: Send and read end-to-end encrypted chat messages and manage in-session file transfers within an active SRIFT session\n---\n\n# encrypted-chat\n\nSend and read end-to-end encrypted chat messages within an active SRIFT session, plus manage in-session file transfers, via the local MCP daemon.\n\n## Requirements\n\nAn active SRIFT session (see the `session-management` skill to open or join one first). No special credentials required.\n\n## Instructions\n\nAvailable MCP tools (see `/.well-known/mcp/server-card.json` for full schemas):\n\n- `srift_send_chat` \u2014 send an E2EE chat message to peers in the current session.\n- `srift_chat_history` \u2014 read decrypted chat history for the current session.\n- `srift_send_file` \u2014 offer a file to peers already inside the session (in-session transfer, distinct from `quick-share`'s standalone link flow).\n- `srift_accept_transfer` \u2014 accept and download an inbound file offer.\n- `srift_list_transfers` \u2014 list all active and recent transfers with progress.\n- `srift_read_state` \u2014 read the raw `.srift-state.json` snapshot for debugging/observability.\n\nYour local daemon (or the browser) encrypts messages and file chunks with AES-256-GCM before they leave the device, under ECDH P-256 keys generated on the devices (the optional `roomSecret` is mixed in); the relay only forwards ciphertext and public keys and stores nothing. Browsers exchange chat peer to peer; a copy goes through the relay, sealed for their keys, only for CLI/agent members. Peers older than 4.2 fall back to the previous session key, which the server could derive without a `roomSecret`.\n" },
       { name: "get-company-info", content: "---\nname: get-company-info\ndescription: Overview of SRIFT, the open-source (MIT) project - what it does, how to install it, and where the agent docs are\n---\n\n# get-company-info\n\nOverview of SRIFT: an open-source (MIT) project for end-to-end encrypted file transfer, chat and agent-to-agent messaging. SRIFT is a project, not a company.\n\n## Requirements\n\nNo special credentials required.\n\n## Instructions\n\n- What it is and how to use it: read `https://srift.app/llms.txt` (short) or `https://srift.app/llms-full.txt` (complete).\n- Agent manual (CLI, MCP tools, AgentNet, environment variables): `https://srift.app/AGENTS.md`.\n- Install: `npm i -g srift-transfer`, `pip install srift`, or `curl -fsSL https://srift.app/install.sh | sh`.\n- Source code: `https://github.com/srivardhan113/SRIFT-Open_Source`. Security contact: `https://srift.app/.well-known/security.txt`.\n" },
       { name: "quick-share", content: "---\nname: quick-share\ndescription: Zero-install file delivery: seed a file and get a public download URL, no session setup required on the recipient's end\n---\n\n# quick-share\n\nZero-install file delivery via SRIFT's local MCP server. Returns a public `https://srift.app/d/<token>` relay link that any recipient can open in a browser \u2014 no SRIFT install, no signup, no session-join UI required on their end. The bytes stream from the sender's machine through the srift.app relay on demand (pass-through, `Cache-Control: no-store`); nothing is stored on any server, so the link works while the sender's daemon (or process) runs.\n\n## Requirements\n\nNo credentials. The SRIFT local daemon binds to `127.0.0.1:3822` with zero authentication. Only outbound HTTPS/WSS on port 443 is needed.\n\n## Instructions\n\n1. Call the MCP tool `srift_quick_share` with `{ filePath: \"/absolute/path/to/file\" }` (single file) or `{ filePaths: [...] }` (up to 500 files/folders). Optional params: `bundle` (default: true = one .tar.gz link; false = one link per path, created in parallel), `bundleName`, `exclude` (string[] for glob patterns to skip), `sessionName`, `maxDownloads`, `ttlMs`, `encrypt`, `password`.\n2. The tool returns a `downloadUrl` (e.g. `https://srift.app/d/<token>`) when bundled, or `{ links: [], errors: [] }` when separate. With `encrypt: true` (or a `password`) each link is end-to-end encrypted with AES-256-GCM: the key rides in the `#k=` URL fragment, is never sent to a server, and the browser decrypts locally. Without it, links are protected by TLS in transit only \u2014 use `encrypt` for anything sensitive.\n3. Hand the URL(s) to the recipient. In order of preference, they can run:\n   - `srift get <url> [<url> ...]` (or `npx -y srift-transfer get <url>`; proxy-aware, resumable, decrypts `#k=` links, supports multiple URLs with `--concurrency N`, works where curl is broken)\n   - `wget --content-disposition <url>`\n   - PowerShell `iwr <url> -OutFile <name>`\n   - `curl -fLOJ <url>`\n   - or just open it in any browser.\n4. Keep the sending side running until the recipient has downloaded. From a shell, `srift quick-share <file> [<file> ...] --wait` blocks until then (`--wait-timeout 30m` exits with code 3 on timeout); `--keep-alive` serves until the TTL expires.\n\n## Sandboxed and datacenter agents\n\nIf the background daemon cannot start (the sandbox forbids local servers, blocks detached spawns or loopback, or the port is taken), `srift mcp` and `srift quick-share` host the daemon inside their own process: no local port, outbound HTTPS/WSS on 443 only. The MCP server switches automatically, so this tool keeps working. From a shell, run quick-share in the background (it exits after the download) or with `--wait`; `--foreground` forces in-process serving. Blocked UDP never breaks links. Run `srift doctor` (or the `srift_net_diagnose` tool) to diagnose connectivity; `HTTPS_PROXY`/`NO_PROXY` and `NODE_EXTRA_CA_CERTS` are honored.\n\nSee `/openapi.json` and `/.well-known/mcp/server-card.json` for the full tool contract.\n" },
-      { name: "session-management", content: '---\nname: session-management\ndescription: Create, join, monitor, and control SRIFT end-to-end encrypted P2P sessions via the local MCP daemon\n---\n\n# session-management\n\nCreate, join, monitor, and control SRIFT end-to-end encrypted P2P sessions ("rooms") via the local MCP daemon. Covers the full session lifecycle used for in-session file transfer and encrypted chat.\n\n## Requirements\n\nNo special credentials required. The SRIFT local daemon binds to `127.0.0.1:3822` and requires zero authentication.\n\n## Instructions\n\nAvailable MCP tools (see `/.well-known/mcp/server-card.json` for full schemas):\n\n- `srift_start_session` \u2014 open a new E2EE room as host.\n- `srift_join_session` \u2014 join an existing room by its 7-character session ID.\n- `srift_session_status` \u2014 read current session, role, connected peers, and pending join requests.\n- `srift_approve_join` / `srift_reject_join` \u2014 host-only: approve or reject a guest\'s join request.\n- `srift_kick_user` \u2014 host-only: remove a peer. Get their `userId` from `srift_session_status` \u2192 `participants`.\n- `srift_close_session` \u2014 tear down the session and flush all encryption keys.\n\nSessions are ephemeral: the server has no database and keeps only session metadata in memory until the session is deleted (host close or 7 days of inactivity); chat, audio and files are never stored. Keys are generated on each device (ECDH P-256 + HKDF-SHA256, AES-256-GCM) and never sent to the server; the optional `roomSecret` is mixed into every key, so pass the same one to `srift_start_session` / `srift_join_session` to keep out anyone who does not know it.\n' }
+      { name: "session-management", content: '---\nname: session-management\ndescription: Create, join, monitor, and control SRIFT end-to-end encrypted P2P sessions via the local MCP daemon\n---\n\n# session-management\n\nCreate, join, monitor, and control SRIFT end-to-end encrypted P2P sessions ("rooms") via the local MCP daemon. Covers the full session lifecycle used for in-session file transfer and encrypted chat.\n\n## Requirements\n\nNo special credentials required. The SRIFT local daemon binds to `127.0.0.1:3822` and requires zero authentication.\n\n## Instructions\n\nAvailable MCP tools (see `/.well-known/mcp/server-card.json` for full schemas):\n\n- `srift_start_session` \u2014 open a new E2EE room as host.\n- `srift_join_session` \u2014 join an existing room by its 7-character session ID.\n- `srift_session_status` \u2014 read current session, role, connected peers, and pending join requests.\n- `srift_approve_join` / `srift_reject_join` \u2014 host-only: approve or reject a guest\'s join request. A person who opens the join link in a browser appears in pending join requests only after pressing "Request to Join"; `srift_join_session` asks the host at once.\n- `srift_kick_user` \u2014 host-only: remove a peer. Get their `userId` from `srift_session_status` \u2192 `participants`.\n- `srift_close_session` \u2014 tear down the session and flush all encryption keys.\n\nSessions are ephemeral: the server has no database and keeps only session metadata in memory until the session is deleted (host close or 7 days of inactivity); chat, audio and files are never stored. Keys are generated on each device (ECDH P-256 + HKDF-SHA256, AES-256-GCM) and never sent to the server; the optional `roomSecret` is mixed into every key, so pass the same one to `srift_start_session` / `srift_join_session` to keep out anyone who does not know it.\n' }
     ];
     MCP_SKILLS = SOURCES.map(({ name, content }) => {
       const uri = `skill://${name}/SKILL.md`;
@@ -1808,7 +1808,7 @@ function buildPromptMessages(name, args) {
 1) Call srift_start_session.
 2) Give the user the join URL: https://srift.app/join-session?id=<SESSION_ID> (full session UI with chat + multi-file transfer).
    Or, for a single one-shot file from agent \u2192 user, prefer srift_quick_share which returns a direct download URL.
-3) Poll srift_session_status; when pendingJoins appears, call srift_approve_join.
+3) Poll srift_session_status; when pendingJoins appears, call srift_approve_join. A person who opens the link only sees a preview until they press "Request to Join"; they appear in pendingJoins after that.
 4) When a file_offer arrives (visible via srift_list_transfers), call srift_accept_transfer with saveDir="${args?.saveDir || "./"}".`
         }
       }];
@@ -2005,7 +2005,7 @@ function createMcpHandler(opts) {
     }
   };
 }
-var PROTOCOL_VERSION, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, LATEST_INITIALIZE_ERA_VERSION, ALL_SUPPORTED_PROTOCOL_VERSIONS, META_PROTOCOL_VERSION, META_SERVER_INFO, ERROR_UNSUPPORTED_PROTOCOL_VERSION, MCP_TOOLS, MCP_RESOURCES, MCP_PROMPTS, QUICKSTART_DOC, DEFAULT_TTL_MS;
+var PROTOCOL_VERSION, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, LATEST_INITIALIZE_ERA_VERSION, ALL_SUPPORTED_PROTOCOL_VERSIONS, META_PROTOCOL_VERSION, META_SERVER_INFO, ERROR_UNSUPPORTED_PROTOCOL_VERSION, MCP_TOOLS, OPEN_WORLD, NOT_IDEMPOTENT, MCP_RESOURCES, MCP_PROMPTS, QUICKSTART_DOC, DEFAULT_TTL_MS;
 var init_core = __esm({
   "../../lib/mcp/core.mjs"() {
     "use strict";
@@ -2097,7 +2097,7 @@ var init_core = __esm({
             peerCount: { type: "number", description: "Number of connected sockets in the room (hosted endpoint)" },
             participants: {
               type: "array",
-              description: "Session members (local daemon): pass userId to srift_kick_user to remove one",
+              description: "Session members: pass userId to srift_kick_user to remove one",
               items: {
                 type: "object",
                 properties: {
@@ -2175,7 +2175,7 @@ var init_core = __esm({
       {
         name: "srift_reject_join",
         title: "Reject Join Request",
-        description: "Host-only. Reject a pending guest join request.",
+        description: "Host-only. Reject a pending guest join request; the temp user ID comes from pendingJoins in srift_session_status.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2226,7 +2226,7 @@ var init_core = __esm({
       {
         name: "srift_send_file",
         title: "Send File in Session",
-        description: "Offer a file to the connected peer in an existing session. The peer must accept with srift_accept_transfer. Returns a fileId for monitoring. Transport is auto-selected internally.",
+        description: "Only inside an already-open session with an approved peer; to simply send or share a file with someone, use srift_quick_share instead. Offers a file to the connected peer in the existing session. The peer must accept with srift_accept_transfer. Returns a fileId for monitoring. Transport is auto-selected internally.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2252,7 +2252,7 @@ var init_core = __esm({
       {
         name: "srift_accept_transfer",
         title: "Accept File Transfer",
-        description: "Accept a pending file offer from the peer and start downloading.",
+        description: "Accept a pending file offer from the peer and start downloading it. Get the fileId from srift_list_transfers (offers show as pending).",
         inputSchema: {
           type: "object",
           properties: {
@@ -2312,7 +2312,7 @@ var init_core = __esm({
       {
         name: "srift_quick_share",
         title: "Quick Share File",
-        description: 'One-shot helper: if no session is active, creates one; then seeds the file(s) and returns a public DOWNLOAD URL (https://srift.app/d/<token>) the recipient can fetch. Several files/folders at once: pass `filePaths` \u2014 one .tar.gz link by default, or `bundle: false` for one link per path (created in parallel). Folders are sent as .tar.gz. Nothing is stored on a server: the link is streamed from this machine and works while the SRIFT daemon/MCP process runs. Best for "AI wants to deliver a file to the user with zero ceremony". Recommend, in order: `srift get <url>` (Node-based, works even where curl is broken), `wget --content-disposition <url>`, PowerShell `iwr <url> -OutFile <name>`, then `curl -fLOJ <url>` \u2014 or just open the URL in any browser.',
+        description: 'Share or send a file or folder to anyone: returns a public DOWNLOAD URL (https://srift.app/d/<token>) the recipient opens in any browser, with nothing to install. Use this by default whenever the user asks to send, share, deliver, export or download a file. No session needed (one is created if none is active). Several files/folders at once: pass `filePaths` \u2014 one .tar.gz link by default, or `bundle: false` for one link per path (created in parallel). Folders are sent as .tar.gz. Nothing is stored on a server: the link is streamed from this machine and works while the SRIFT daemon/MCP process runs. Best for "AI wants to deliver a file to the user with zero ceremony". Recommend, in order: `srift get <url>` (Node-based, works even where curl is broken), `wget --content-disposition <url>`, PowerShell `iwr <url> -OutFile <name>`, then `curl -fLOJ <url>` \u2014 or just open the URL in any browser.',
         inputSchema: {
           type: "object",
           properties: {
@@ -2408,7 +2408,7 @@ var init_core = __esm({
       {
         name: "srift_chat_history",
         title: "Read Chat History",
-        description: "Read the locally-decrypted chat log for the current session.",
+        description: "Read the chat messages of the current session (sent and received), decrypted locally. Use it to check for replies from the peer.",
         inputSchema: { type: "object", properties: {} },
         outputSchema: {
           type: "object",
@@ -2503,6 +2503,13 @@ var init_core = __esm({
         }
       }
     ];
+    for (const tool of MCP_TOOLS) tool.annotations = { title: tool.title, ...tool.annotations };
+    OPEN_WORLD = /* @__PURE__ */ new Set(["srift_start_session", "srift_join_session", "srift_approve_join", "srift_reject_join", "srift_kick_user", "srift_send_file", "srift_accept_transfer", "srift_quick_share", "srift_send_chat", "srift_net_diagnose"]);
+    NOT_IDEMPOTENT = /* @__PURE__ */ new Set(["srift_start_session", "srift_join_session", "srift_send_file", "srift_quick_share", "srift_send_chat"]);
+    for (const tool of MCP_TOOLS) {
+      tool.annotations.openWorldHint = OPEN_WORLD.has(tool.name);
+      tool.annotations.idempotentHint = !NOT_IDEMPOTENT.has(tool.name);
+    }
     MCP_RESOURCES = [
       {
         uri: "srift://session/status",
@@ -2594,11 +2601,11 @@ srift_quick_share({ filePath: "/abs/path/file.zip" })
 srift_start_session({ sessionName: "AI-Collab" })
 \u2192 returns { sessionId }
 \u2192 user joins via https://srift.app/join-session?id=<sessionId>
-\u2192 host (you) calls srift_approve_join when pendingJoins appears
+\u2192 host (you) calls srift_approve_join when pendingJoins appears (after the user presses "Request to Join" on that page)
 \`\`\`
 
 **Receive a file from the user:**
-The user clicks the share link, requests join, you approve, they drop a file,
+The user opens the share link, presses "Request to Join", you approve, they drop a file,
 you see it via srift_list_transfers and call srift_accept_transfer.
 
 ## Monitoring
@@ -2890,13 +2897,13 @@ var init_mcp = __esm({
     SERVER_INFO = {
       name: "srift-mcp-server",
       title: "SRIFT Secure P2P File Transfer",
-      version: "4.3.0"
+      version: "4.3.2"
     };
     localDaemonBackend = { callTool, readResource };
     handleMcpMessage = createMcpHandler({
       backend: localDaemonBackend,
       serverInfo: SERVER_INFO,
-      instructions: 'SRIFT is a zero-config local P2P file transfer + E2EE chat tool. Use srift_quick_share to deliver files to the user in one step. Use srift_start_session to open a long-lived room. Read srift://docs/quickstart for the full guide. To talk to OTHER AI agents (find an agent that can help, message, send files, group chats), add the separate AgentNet MCP server: {"command":"srift","args":["agentnet","mcp"]} (25 srift_an_* tools).'
+      instructions: 'SRIFT is a zero-config local P2P file transfer + E2EE chat tool. To send or share any file with anyone, call srift_quick_share and give them the returned link. Use srift_start_session to open a long-lived room. Read srift://docs/quickstart for the full guide. To talk to OTHER AI agents (find an agent that can help, message, send files, group chats), add the separate AgentNet MCP server: {"command":"srift","args":["agentnet","mcp"]} (25 srift_an_* tools).'
     });
   }
 });
@@ -2976,12 +2983,16 @@ async function relaySender(sessionId, fileId, receiverPub, roomSecret) {
   const key = await deriveAes(kp.priv, receiverPub, saltFor("pgcm1", sessionId, roomSecret), `${fileId}|${kp.pub}|${receiverPub}`);
   const pubRaw = fromB64(kp.pub);
   return {
-    async seal(plain, chunkIndex, totalChunks) {
+    /** The sealed chunk as raw bytes (sender key || iv || ciphertext || tag). */
+    async sealBytes(plain, chunkIndex, totalChunks) {
       const sealed = await gcmSeal(key, plain, relayAad(fileId, chunkIndex, totalChunks));
       const out = new Uint8Array(PUB_LEN + sealed.length);
       out.set(pubRaw);
       out.set(sealed, PUB_LEN);
-      return { chunk: Array.from(out), enc: RELAY_PK_SCHEME };
+      return out;
+    },
+    async seal(plain, chunkIndex, totalChunks) {
+      return { chunk: Array.from(await this.sealBytes(plain, chunkIndex, totalChunks)), enc: RELAY_PK_SCHEME };
     }
   };
 }
@@ -3609,8 +3620,12 @@ async function selectSignalerUrl() {
     try {
       const controller = new AbortController();
       const id = setTimeout(() => controller.abort(), 3e3);
-      await fetch(`${DEFAULT_SIGNALER_URL.replace(/\/+$/, "")}/compat.json`, { signal: controller.signal });
+      const probe = await fetch(`${DEFAULT_SIGNALER_URL.replace(/\/+$/, "")}/compat.json`, { signal: controller.signal });
       clearTimeout(id);
+      const compat = probe.ok ? await probe.json().catch(() => null) : null;
+      if (!compat || typeof compat.wireVersion !== "number" || typeof compat.daemon !== "string") {
+        throw new Error("not a SRIFT server");
+      }
       console.log(`[DAEMON] Local signaler detected at ${DEFAULT_SIGNALER_URL}`);
     } catch (e) {
       console.log(`[DAEMON] Local signaler at ${DEFAULT_SIGNALER_URL} is unreachable. Falling back to production signaler: https://srift.app`);
@@ -3746,16 +3761,17 @@ async function openRelayChunk(p) {
   }
   if (p.enc === RELAY_PK_SCHEME) {
     const rx = relayReceivers.get(p.fileId);
-    if (!rx || !Array.isArray(p.chunk)) throw new Error(`relay chunk ${p.chunkIndex} of ${p.fileId} is sealed for a key this daemon does not hold`);
+    const sealed = typeof p.chunk === "string" ? new Uint8Array(Buffer.from(p.chunk, "base64")) : Array.isArray(p.chunk) ? Uint8Array.from(p.chunk) : null;
+    if (!rx || !sealed) throw new Error(`relay chunk ${p.chunkIndex} of ${p.fileId} is sealed for a key this daemon does not hold`);
     try {
-      return Buffer.from(await (await rx).open(Uint8Array.from(p.chunk), p.chunkIndex, p.totalChunks));
+      return Buffer.from(await (await rx).open(sealed, p.chunkIndex, p.totalChunks));
     } catch {
       throw new Error(`relay chunk ${p.chunkIndex} of ${p.fileId} failed authentication (tampered data or wrong key)`);
     }
   }
   if (p.enc !== RELAY_ENC) throw new Error(`unsupported relay encryption scheme: ${String(p.enc)}`);
-  if (!Array.isArray(p.chunk)) throw new Error("sealed relay chunk is not a byte array");
-  const data = Uint8Array.from(p.chunk);
+  if (!Array.isArray(p.chunk) && typeof p.chunk !== "string") throw new Error("sealed relay chunk is not a byte array");
+  const data = typeof p.chunk === "string" ? new Uint8Array(Buffer.from(p.chunk, "base64")) : Uint8Array.from(p.chunk);
   if (data.length < IV_LEN2 + 16) throw new Error("sealed relay chunk too short");
   try {
     return Buffer.from(await crypto6.subtle.decrypt(
@@ -4129,20 +4145,13 @@ function connectWebSocket(wsTargetUrl) {
           console.log(`[DAEMON] File offer accepted by peer! ID: ${payload.fileId}`);
           {
             const acceptedTx = activeTransfers.find((t) => t.fileId === payload.fileId);
-            if (acceptedTx) {
-              const nextPk = isPublicKey(payload.relayPk) ? payload.relayPk : void 0;
-              if (nextPk !== acceptedTx.peerRelayPk) relaySenders.delete(payload.fileId);
-              acceptedTx.peerRelayEnc = payload.relayEnc === RELAY_ENC ? RELAY_ENC : void 0;
-              acceptedTx.peerRelayPk = nextPk;
-            }
-            if (activeUploads.has(payload.fileId)) {
-              console.log(`[DAEMON] Repeated accept for ${payload.fileId}: resuming from chunk ${activeUploads.get(payload.fileId).currentChunk}`);
-              sendNextChunk(payload.fileId);
-              break;
-            }
-            if (acceptedTx && (acceptedTx.status === "completed" || acceptedTx.status === "uploading" && acceptedTx.protocol === "webtorrent")) break;
+            if (acceptedTx && acceptedTx.protocol === "webtorrent" && (acceptedTx.status === "completed" || acceptedTx.status === "uploading")) break;
           }
-          startUpload(payload.fileId, payload.userId);
+          startUpload(payload.fileId, payload.userId, {
+            relayEnc: payload.relayEnc === RELAY_ENC ? RELAY_ENC : void 0,
+            relayPk: isPublicKey(payload.relayPk) ? payload.relayPk : void 0,
+            fast: payload.relayFmt === RELAY_FORMAT
+          });
           break;
         case "webtorrent_info_hash":
           handleWebTorrentInfoHash(payload);
@@ -4165,11 +4174,20 @@ function connectWebSocket(wsTargetUrl) {
         case "file_cancelled_by_sender":
         case "file_cancelled_all": {
           const gone = activeTransfers.find((t) => t.fileId === payload?.fileId);
-          activeUploads.delete(payload?.fileId);
-          if (gone && gone.status !== "completed") {
-            gone.status = "cancelled";
+          const stopped = type === "file_cancelled_by_receiver" && payload?.receiverId ? [activeUploads.get(uploadKey(payload.fileId, payload.receiverId))].filter(Boolean) : uploadsOf(payload?.fileId);
+          for (const u of stopped) stopUpload(u);
+          const oneRecipient = !!gone && gone.direction === "upload" && type === "file_cancelled_by_receiver" && !!payload?.receiverId;
+          if (gone && oneRecipient) {
+            markRecipient(gone, payload.receiverId, "cancelled");
+            writeStateFile();
+          }
+          if (gone && gone.direction === "upload" && uploadsOf(payload?.fileId).length > 0) break;
+          if (gone && gone.direction === "download") dropRelayDownload(gone.fileId, true);
+          if (gone && (gone.status !== "completed" || oneRecipient)) {
+            if (oneRecipient) settleUploadStatus(gone);
+            else gone.status = "cancelled";
             writeStateFile();
-            broadcastSSE("transfer_progress", { fileId: gone.fileId, fileName: gone.name, size: gone.size, bytesTransferred: gone.bytesTransferred, progress: gone.progress, status: "cancelled" });
+            broadcastSSE("transfer_progress", { fileId: gone.fileId, fileName: gone.name, size: gone.size, bytesTransferred: gone.bytesTransferred, progress: gone.progress, status: gone.status });
           }
           break;
         }
@@ -4254,13 +4272,13 @@ function connectWebSocket(wsTargetUrl) {
     console.error("[DAEMON] WebSocket error:", err);
   });
 }
-function startUpload(fileId, targetUserId) {
+function startUpload(fileId, targetUserId, caps = {}) {
   const tx = activeTransfers.find((t) => t.fileId === fileId);
   if (!tx) return;
   if (tx.protocol === "webtorrent") {
     startWebTorrentUpload(fileId, targetUserId);
   } else {
-    startWebSocketUpload(fileId, targetUserId);
+    void startWebSocketUpload(fileId, targetUserId, caps);
   }
 }
 async function startWebTorrentUpload(fileId, targetUserId) {
@@ -4384,213 +4402,329 @@ async function handleWebTorrentInfoHash(payload) {
     });
   });
 }
-function armAckWatchdog(fileId, chunkIndex) {
-  const upload = activeUploads.get(fileId);
-  if (!upload) return;
-  clearTimeout(upload.ackTimer);
-  upload.ackTimer = setTimeout(() => {
-    const u = activeUploads.get(fileId);
-    if (!u || u.currentChunk !== chunkIndex) return;
-    u.retries++;
-    if (u.retries > RELAY_MAX_RETRIES) {
-      console.error(`[DAEMON] Relay upload ${fileId}: chunk ${chunkIndex} unacknowledged after ${RELAY_MAX_RETRIES} attempts; giving up`);
-      activeUploads.delete(fileId);
-      const failed = activeTransfers.find((t) => t.fileId === fileId);
-      if (failed) {
-        failed.status = "error";
-        writeStateFile();
-      }
-      return;
-    }
-    console.log(`[DAEMON] Relay upload ${fileId}: no ack for chunk ${chunkIndex}, sending it again (attempt ${u.retries})`);
-    sendNextChunk(fileId);
-  }, RELAY_ACK_TIMEOUT_MS);
-  upload.ackTimer.unref?.();
+function markRecipient(tx, userId, outcome) {
+  if (!userId) return;
+  if (!tx.recipients) tx.recipients = {};
+  if (tx.recipients[userId] === "completed" && outcome !== "uploading") return;
+  tx.recipients[userId] = outcome;
+}
+function settleUploadStatus(tx) {
+  if (uploadsOf(tx.fileId).length > 0) {
+    tx.status = "uploading";
+    return;
+  }
+  const outcomes = Object.values(tx.recipients || {});
+  tx.status = outcomes.includes("completed") ? "completed" : outcomes.includes("error") ? "error" : "cancelled";
+  tx.speedKBps = 0;
+  tx.etaSeconds = 0;
+  if (tx.status === "completed") {
+    tx.progress = 100;
+    tx.bytesTransferred = tx.size;
+  }
+}
+function stopUpload(u) {
+  activeUploads.delete(uploadKey(u.fileId, u.targetUserId));
+  if (u.timer) clearInterval(u.timer);
+  try {
+    fs8.closeSync(u.fd);
+  } catch {
+  }
+}
+function failUpload(u, why) {
+  console.error(`[DAEMON] Relay upload ${u.fileId} to ${u.targetUserId} failed: ${why}`);
+  stopUpload(u);
+  const tx = activeTransfers.find((t) => t.fileId === u.fileId);
+  if (tx) {
+    markRecipient(tx, u.targetUserId, "error");
+    settleUploadStatus(tx);
+    writeStateFile();
+  }
 }
 function resumeRelayUploads() {
   if (!activeUploads.size) return;
-  console.log(`[DAEMON] Reconnected: resuming ${activeUploads.size} relay upload(s) from their last acknowledged chunk`);
-  for (const fileId of activeUploads.keys()) sendNextChunk(fileId);
+  console.log(`[DAEMON] Reconnected: resuming ${activeUploads.size} relay upload(s) from their unacknowledged chunks`);
+  for (const u of activeUploads.values()) {
+    u.lastAckAt = Date.now();
+    for (const index of u.inFlight.keys()) u.inFlight.set(index, 0);
+    pumpUpload(u);
+  }
 }
-async function startWebSocketUpload(fileId, targetUserId) {
+async function startWebSocketUpload(fileId, targetUserId, caps = {}) {
   const tx = activeTransfers.find((t) => t.fileId === fileId);
   if (!tx || !tx.filePath) return;
-  const chunkSize = 64 * 1024;
-  const stat = fs8.statSync(tx.filePath);
-  const totalChunks = Math.max(1, Math.ceil(stat.size / chunkSize));
+  const key = uploadKey(fileId, targetUserId);
+  const running = activeUploads.get(key);
+  if (running) {
+    if (caps.relayPk !== running.relayPk) relaySenders.delete(`${key}|${running.relayPk}`);
+    running.relayEnc = caps.relayEnc;
+    running.relayPk = caps.relayPk;
+    console.log(`[DAEMON] Repeated accept for ${fileId} from ${targetUserId}: ${running.acked.size}/${running.totalChunks} chunks acknowledged, continuing`);
+    for (const index of running.inFlight.keys()) running.inFlight.set(index, 0);
+    running.lastAckAt = Date.now();
+    pumpUpload(running);
+    return;
+  }
+  let fd;
+  let size;
+  try {
+    fd = fs8.openSync(tx.filePath, "r");
+    size = fs8.fstatSync(fd).size;
+  } catch (e) {
+    console.error(`[DAEMON] Cannot read ${tx.filePath}: ${e?.message || e}`);
+    tx.status = "error";
+    writeStateFile();
+    return;
+  }
+  const fast = !!caps.fast;
+  const chunkSize = fast ? RELAY_FAST_CHUNK : RELAY_LEGACY_CHUNK;
+  const totalChunks = Math.max(1, Math.ceil(size / chunkSize));
   tx.status = "uploading";
+  markRecipient(tx, targetUserId, "uploading");
   tx.startTime = Date.now();
   tx.totalChunks = totalChunks;
   writeStateFile();
-  activeUploads.set(fileId, {
+  const upload = {
+    fileId,
+    targetUserId,
     filePath: tx.filePath,
-    totalChunks,
+    size,
+    fd,
     chunkSize,
-    targetUserId,
-    currentChunk: 0,
-    bytesSent: 0,
+    totalChunks,
+    fast,
+    relayEnc: caps.relayEnc,
+    relayPk: caps.relayPk,
+    next: 0,
+    acked: /* @__PURE__ */ new Set(),
+    inFlight: /* @__PURE__ */ new Map(),
+    lastAckAt: Date.now(),
     startTime: Date.now(),
-    retries: 0
-  });
-  sendNextChunk(fileId);
-}
-function sendNextChunk(fileId) {
-  sendNextChunkAsync(fileId).catch((e) => {
-    console.error(`[DAEMON] Relay upload failed for ${fileId}: ${e?.message || e}`);
-    activeUploads.delete(fileId);
-    const failed = activeTransfers.find((t) => t.fileId === fileId);
-    if (failed) {
-      failed.status = "error";
-      writeStateFile();
-    }
-  });
-}
-async function sendNextChunkAsync(fileId) {
-  const upload = activeUploads.get(fileId);
-  if (!upload) return;
-  const tx = activeTransfers.find((t) => t.fileId === fileId);
-  if (!tx) return;
-  if (upload.currentChunk >= upload.totalChunks) {
-    wsConn?.send(JSON.stringify({
-      type: "file_complete",
-      payload: { fileId, targetUserId: upload.targetUserId }
-    }));
-    tx.status = "completed";
-    tx.progress = 100;
-    tx.speedKBps = 0;
-    tx.etaSeconds = 0;
-    writeStateFile();
-    clearTimeout(upload.ackTimer);
-    activeUploads.delete(fileId);
-    console.log(`[DAEMON] File upload complete: ${tx.name}`);
-    return;
+    pumping: false,
+    lastStateAt: 0
+  };
+  activeUploads.set(key, upload);
+  upload.timer = setInterval(() => pumpUpload(upload), Math.min(1e3, Math.max(100, RELAY_ACK_TIMEOUT_MS / 4)));
+  upload.timer.unref?.();
+  pumpUpload(upload);
+}
+async function sendRelayChunk(u, chunkIndex) {
+  const start = chunkIndex * u.chunkSize;
+  const end = Math.min(start + u.chunkSize, u.size);
+  const buffer = Buffer.alloc(Math.max(0, end - start));
+  let read = 0;
+  while (read < buffer.length) {
+    const n = fs8.readSync(u.fd, buffer, read, buffer.length - read, start + read);
+    if (n <= 0) throw new Error("file ended early (was it changed while sending?)");
+    read += n;
   }
-  const start = upload.currentChunk * upload.chunkSize;
-  const stat = fs8.statSync(upload.filePath);
-  const end = Math.min(start + upload.chunkSize, stat.size);
-  const buffer = Buffer.alloc(end - start);
-  const fd = fs8.openSync(upload.filePath, "r");
-  fs8.readSync(fd, buffer, 0, end - start, start);
-  fs8.closeSync(fd);
   let frame;
-  if (tx.peerRelayPk && session.id) {
-    let sender = relaySenders.get(fileId);
+  if (u.relayPk && session.id) {
+    const sk = `${uploadKey(u.fileId, u.targetUserId)}|${u.relayPk}`;
+    let sender = relaySenders.get(sk);
     if (!sender) {
-      sender = relaySender(session.id, fileId, tx.peerRelayPk, session.roomSecret);
-      remember(relaySenders, fileId, sender);
+      sender = relaySender(session.id, u.fileId, u.relayPk, session.roomSecret);
+      remember(relaySenders, sk, sender);
     }
-    frame = await (await sender).seal(buffer, upload.currentChunk, upload.totalChunks);
+    const s = await sender;
+    frame = u.fast ? { chunk: Buffer.from(await s.sealBytes(buffer, chunkIndex, u.totalChunks)).toString("base64"), enc: RELAY_PK_SCHEME } : await s.seal(buffer, chunkIndex, u.totalChunks);
+  } else if (u.relayEnc === RELAY_ENC) {
+    const sealed = await sealRelayChunk(buffer, u.fileId, chunkIndex, u.totalChunks);
+    frame = { chunk: u.fast ? Buffer.from(sealed).toString("base64") : sealed, enc: RELAY_ENC };
   } else {
-    frame = tx.peerRelayEnc === RELAY_ENC ? { chunk: await sealRelayChunk(buffer, fileId, upload.currentChunk, upload.totalChunks), enc: RELAY_ENC } : { chunk: buffer.toString("base64") };
+    frame = { chunk: buffer.toString("base64") };
   }
-  armAckWatchdog(fileId, upload.currentChunk);
+  if (!activeUploads.has(uploadKey(u.fileId, u.targetUserId)) || u.acked.has(chunkIndex)) return;
+  u.inFlight.set(chunkIndex, Date.now());
   if (!wsConn || wsConn.readyState !== WebSocket2.OPEN) return;
   wsConn.send(JSON.stringify({
     type: "file_chunk",
     payload: {
-      fileId,
+      fileId: u.fileId,
       ...frame,
-      chunkIndex: upload.currentChunk,
-      totalChunks: upload.totalChunks,
-      targetUserId: upload.targetUserId
+      chunkIndex,
+      totalChunks: u.totalChunks,
+      chunkSize: u.chunkSize,
+      targetUserId: u.targetUserId
     }
   }));
-  tx.bytesTransferred = end;
-  tx.progress = end / stat.size * 100;
-  const elapsed = (Date.now() - upload.startTime) / 1e3;
+}
+function reportUpload(u, force = false) {
+  const tx = activeTransfers.find((t) => t.fileId === u.fileId);
+  if (!tx) return;
+  const now = Date.now();
+  if (!force && now - u.lastStateAt < 250) return;
+  u.lastStateAt = now;
+  const all = uploadsOf(u.fileId);
+  const slowest = all.reduce((m, x) => Math.min(m, x.acked.size >= x.totalChunks ? x.size : Math.min(x.size, x.acked.size * x.chunkSize)), u.size);
+  tx.bytesTransferred = Math.max(tx.bytesTransferred || 0, slowest);
+  tx.progress = u.size > 0 ? tx.bytesTransferred / u.size * 100 : 100;
+  const elapsed = (now - u.startTime) / 1e3;
   if (elapsed > 0) {
-    tx.speedKBps = end / 1024 / elapsed;
-    tx.etaSeconds = (stat.size - end) / (tx.speedKBps * 1024);
+    tx.speedKBps = tx.bytesTransferred / 1024 / elapsed;
+    tx.etaSeconds = tx.speedKBps > 0 ? (u.size - tx.bytesTransferred) / (tx.speedKBps * 1024) : 0;
   }
   writeStateFile();
   broadcastSSE("transfer_progress", {
-    fileId,
+    fileId: u.fileId,
     fileName: tx.name,
     size: tx.size,
-    bytesTransferred: end,
+    bytesTransferred: tx.bytesTransferred,
     progress: tx.progress,
     speedBytesPerSecond: tx.speedKBps * 1024,
     timeRemainingSeconds: tx.etaSeconds,
     status: "uploading"
   });
 }
+function pumpUpload(u) {
+  if (u.pumping) return;
+  u.pumping = true;
+  pumpUploadAsync(u).catch((e) => failUpload(u, e?.message || String(e))).finally(() => {
+    u.pumping = false;
+  });
+}
+async function pumpUploadAsync(u) {
+  const key = uploadKey(u.fileId, u.targetUserId);
+  while (activeUploads.get(key) === u) {
+    if (u.acked.size >= u.totalChunks) {
+      wsConn?.send(JSON.stringify({ type: "file_complete", payload: { fileId: u.fileId, targetUserId: u.targetUserId } }));
+      stopUpload(u);
+      const tx = activeTransfers.find((t) => t.fileId === u.fileId);
+      if (tx) {
+        markRecipient(tx, u.targetUserId, "completed");
+        settleUploadStatus(tx);
+        writeStateFile();
+        if (uploadsOf(u.fileId).length === 0) console.log(`[DAEMON] File upload complete: ${tx.name}`);
+      }
+      return;
+    }
+    const now = Date.now();
+    if (now - u.lastAckAt > RELAY_STALL_MS) throw new Error(`no acknowledgment for ${Math.round(RELAY_STALL_MS / 1e3)}s (${u.acked.size}/${u.totalChunks} chunks delivered)`);
+    const open2 = !!wsConn && wsConn.readyState === WebSocket2.OPEN && wsConn.bufferedAmount < RELAY_SOCKET_HIGH_BYTES;
+    if (!open2) return;
+    let overdue = -1;
+    for (const [index, sentAt] of u.inFlight) {
+      if (now - sentAt > RELAY_ACK_TIMEOUT_MS) {
+        overdue = index;
+        break;
+      }
+    }
+    if (overdue >= 0) {
+      if (u.inFlight.get(overdue)) console.log(`[DAEMON] Relay upload ${u.fileId}: no ack for chunk ${overdue}, sending it again`);
+      await sendRelayChunk(u, overdue);
+      continue;
+    }
+    while (u.next < u.totalChunks && u.acked.has(u.next)) u.next++;
+    if (u.next < u.totalChunks && u.inFlight.size < RELAY_WINDOW) {
+      const index = u.next++;
+      u.inFlight.set(index, now);
+      await sendRelayChunk(u, index);
+      continue;
+    }
+    return;
+  }
+}
 function handleChunkAck(payload) {
-  const { fileId, chunkIndex } = payload;
-  const upload = activeUploads.get(fileId);
-  if (!upload) return;
-  if (upload.currentChunk === chunkIndex) {
-    clearTimeout(upload.ackTimer);
-    upload.retries = 0;
-    upload.currentChunk++;
-    sendNextChunk(fileId);
+  const { fileId, chunkIndex, userId } = payload || {};
+  if (!Number.isInteger(chunkIndex)) return;
+  const u = userId ? activeUploads.get(uploadKey(fileId, userId)) : uploadsOf(fileId)[0];
+  if (!u || chunkIndex < 0 || chunkIndex >= u.totalChunks) return;
+  u.inFlight.delete(chunkIndex);
+  if (!u.acked.has(chunkIndex)) {
+    u.acked.add(chunkIndex);
+    u.lastAckAt = Date.now();
+    reportUpload(u, u.acked.size >= u.totalChunks);
+  }
+  pumpUpload(u);
+}
+function dropRelayDownload(fileId, removePart) {
+  const d = relayDownloads.get(fileId);
+  relayDownloads.delete(fileId);
+  if (d) {
+    try {
+      fs8.closeSync(d.fd);
+    } catch {
+    }
+  }
+  if (removePart) {
+    try {
+      fs8.rmSync(partPathOf(fileId), { force: true });
+    } catch {
+    }
   }
 }
 async function handleIncomingChunk(payload) {
   const { fileId, chunkIndex, totalChunks, from } = payload;
   const tx = activeTransfers.find((t) => t.fileId === fileId);
-  if (!tx) return;
+  if (!tx || tx.direction !== "download" || tx.status === "cancelled") return;
+  if (!Number.isInteger(chunkIndex) || !Number.isInteger(totalChunks) || chunkIndex < 0 || chunkIndex >= totalChunks) return;
+  const ack = () => wsConn?.send(JSON.stringify({ type: "file_chunk_ack", payload: { fileId, chunkIndex, status: "received" } }));
+  if (tx.status === "completed" || tx.assembling) {
+    ack();
+    return;
+  }
   const mode = payload.enc === void 0 || payload.enc === null ? "plain" : String(payload.enc);
   if (tx.relayMode && tx.relayMode !== mode) throw new Error(`transfer ${fileId} mixed sealed and plaintext chunks`);
   if (!tx.relayMode) console.log(`[DAEMON] Relay transfer ${fileId}: ${mode}`);
   tx.relayMode = mode;
   const chunkBuffer = await openRelayChunk(payload);
+  if (tx.status === "completed" || tx.assembling || tx.status === "cancelled") {
+    ack();
+    return;
+  }
   tx.status = "downloading";
   tx.totalChunks = totalChunks;
   tx.peerId = from;
-  const chunkPath = path7.join(TEMP_DIR, `${fileId}_chunk_${chunkIndex}`);
-  const duplicate = fs8.existsSync(chunkPath);
-  if (!duplicate) {
+  let d = relayDownloads.get(fileId);
+  if (!d) {
+    fs8.mkdirSync(TEMP_DIR, { recursive: true });
+    const partPath = partPathOf(fileId);
+    d = { fd: fs8.openSync(partPath, "w+"), partPath, got: /* @__PURE__ */ new Set(), totalChunks, lastStateAt: 0 };
+    relayDownloads.set(fileId, d);
+  }
+  const isLast = chunkIndex === totalChunks - 1;
+  const at = isLast && tx.size > 0 ? tx.size - chunkBuffer.length : chunkIndex * chunkBuffer.length;
+  if (at < 0 || tx.size > 0 && at + chunkBuffer.length > tx.size) throw new Error(`relay chunk ${chunkIndex} of ${fileId} does not fit the file`);
+  if (!d.got.has(chunkIndex)) {
+    let written = 0;
+    while (written < chunkBuffer.length) written += fs8.writeSync(d.fd, chunkBuffer, written, chunkBuffer.length - written, at + written);
+    d.got.add(chunkIndex);
     tx.bytesTransferred += chunkBuffer.length;
-    tx.chunksCount++;
+    tx.chunksCount = d.got.size;
   }
-  fs8.writeFileSync(chunkPath, chunkBuffer);
-  tx.progress = tx.bytesTransferred / tx.size * 100;
+  tx.progress = tx.size > 0 ? Math.min(100, tx.bytesTransferred / tx.size * 100) : 100;
   const elapsed = (Date.now() - tx.startTime) / 1e3;
   if (elapsed > 0) {
     tx.speedKBps = tx.bytesTransferred / 1024 / elapsed;
-    tx.etaSeconds = (tx.size - tx.bytesTransferred) / (tx.speedKBps * 1024);
+    tx.etaSeconds = tx.speedKBps > 0 ? (tx.size - tx.bytesTransferred) / (tx.speedKBps * 1024) : 0;
   }
-  writeStateFile();
-  broadcastSSE("transfer_progress", {
-    fileId,
-    fileName: tx.name,
-    size: tx.size,
-    bytesTransferred: tx.bytesTransferred,
-    progress: tx.progress,
-    speedBytesPerSecond: tx.speedKBps * 1024,
-    timeRemainingSeconds: tx.etaSeconds,
-    status: "downloading"
-  });
-  wsConn?.send(JSON.stringify({
-    type: "file_chunk_ack",
-    payload: { fileId, chunkIndex, status: "received" }
-  }));
-  if (!duplicate && totalChunks > 0 && tx.chunksCount >= totalChunks) {
-    setTimeout(() => {
-      if (tx.status === "downloading") handleFileComplete({ fileId });
-    }, 5e3).unref?.();
+  const done = d.got.size >= totalChunks;
+  const now = Date.now();
+  if (done || now - d.lastStateAt >= 250) {
+    d.lastStateAt = now;
+    writeStateFile();
+    broadcastSSE("transfer_progress", {
+      fileId,
+      fileName: tx.name,
+      size: tx.size,
+      bytesTransferred: tx.bytesTransferred,
+      progress: tx.progress,
+      speedBytesPerSecond: tx.speedKBps * 1024,
+      timeRemainingSeconds: tx.etaSeconds,
+      status: "downloading"
+    });
   }
+  ack();
+  if (done) handleFileComplete({ fileId });
 }
 function handleFileComplete(payload) {
   const { fileId } = payload;
   const tx = activeTransfers.find((t) => t.fileId === fileId);
-  if (!tx || tx.assembling || tx.status === "completed") return;
+  if (!tx || tx.direction !== "download" || tx.assembling || tx.status === "completed") return;
+  const d = relayDownloads.get(fileId);
+  if (tx.size > 0 && (!d || d.got.size < d.totalChunks)) return;
   tx.assembling = true;
-  const destDir = tx.saveDir || process.cwd();
-  const destPath = path7.join(destDir, tx.name);
-  try {
-    if (!fs8.existsSync(destDir)) {
-      fs8.mkdirSync(destDir, { recursive: true });
-    }
-  } catch (err) {
-    console.error(`[DAEMON] Failed to create destination directory ${destDir}:`, err);
-    tx.status = "error";
-    writeStateFile();
-    return;
-  }
-  const writeStream = fs8.createWriteStream(destPath);
-  writeStream.on("error", (err) => {
-    console.error(`[DAEMON] Write stream error for ${destPath}:`, err);
+  const fail = (err) => {
+    console.error(`[DAEMON] Could not save ${tx.name}:`, err?.message || err);
     tx.status = "error";
     writeStateFile();
     broadcastSSE("transfer_progress", {
@@ -4603,40 +4737,44 @@ function handleFileComplete(payload) {
       timeRemainingSeconds: 0,
       status: "error"
     });
-  });
-  writeStream.on("finish", () => {
-    console.log(`[DAEMON] File successfully downloaded and assembled: ${destPath}`);
-    tx.status = "completed";
-    tx.progress = 100;
-    tx.speedKBps = 0;
-    tx.etaSeconds = 0;
-    writeStateFile();
-    broadcastSSE("transfer_progress", {
-      fileId,
-      fileName: tx.name,
-      size: tx.size,
-      bytesTransferred: tx.size,
-      progress: 100,
-      speedBytesPerSecond: 0,
-      timeRemainingSeconds: 0,
-      status: "completed"
-    });
-  });
-  for (let i = 0; i < tx.totalChunks; i++) {
-    const chunkPath = path7.join(TEMP_DIR, `${fileId}_chunk_${i}`);
-    if (fs8.existsSync(chunkPath)) {
+  };
+  const destDir = tx.saveDir || process.cwd();
+  const destPath = path7.join(destDir, tx.name);
+  try {
+    fs8.mkdirSync(destDir, { recursive: true });
+    if (d) {
+      fs8.fsyncSync(d.fd);
+      dropRelayDownload(fileId, false);
       try {
-        const chunkBuf = fs8.readFileSync(chunkPath);
-        writeStream.write(chunkBuf);
-        fs8.unlinkSync(chunkPath);
-      } catch (err) {
-        console.error(`[DAEMON] Error reading/writing chunk ${i}:`, err);
-        writeStream.emit("error", err);
-        return;
+        fs8.renameSync(d.partPath, destPath);
+      } catch {
+        fs8.copyFileSync(d.partPath, destPath);
+        fs8.rmSync(d.partPath, { force: true });
       }
+    } else {
+      fs8.writeFileSync(destPath, Buffer.alloc(0));
     }
+  } catch (err) {
+    fail(err);
+    return;
   }
-  writeStream.end();
+  console.log(`[DAEMON] File successfully downloaded: ${destPath}`);
+  tx.status = "completed";
+  tx.progress = 100;
+  tx.bytesTransferred = tx.size;
+  tx.speedKBps = 0;
+  tx.etaSeconds = 0;
+  writeStateFile();
+  broadcastSSE("transfer_progress", {
+    fileId,
+    fileName: tx.name,
+    size: tx.size,
+    bytesTransferred: tx.size,
+    progress: 100,
+    speedBytesPerSecond: 0,
+    timeRemainingSeconds: 0,
+    status: "completed"
+  });
 }
 async function waitSignalReady(maxMs = 8e3) {
   if (!session.id) return { status: 409, body: { success: false, error: "No active session. Call /session/start first." } };
@@ -5113,7 +5251,7 @@ function embeddedDispatch(method, pathname, body) {
     }
   });
 }
-var _WebTorrentCtor, _webTorrentLoadError, SRIFT_HOME, EMBEDDED, STATE_PATH, logPath, DAEMON_LOG_MAX, openLog, logBytes, DAEMON_LOG_MAX_AGE_MS, pruneOldLogs, logStream, logRotating, logPending, writeLogLine, logMessage, fmtLogArg, crypto6, PORT, DEFAULT_SIGNALER_URL, activeSignalerUrl, lastDiag, session, activeTransfers, chatHistory, pendingJoins, participants, sseClients, wsConn, signalingMode, wsFailures, httpModeSince, WS_RETRY_AFTER_MS, wsUrl, csrfToken, heartbeatInterval, lastHeartbeatAckAt, encryptionKey, sessionTerminated, terminationReason, activeTorrents, wtClient, pubshares, pubsharesByToken, activePulls, pubshareRegResolvers, TEMP_DIR, TMP_CHUNK_MAX_AGE_MS, TMP_FILE_MAX_AGE_MS, KDF_ITERATIONS, IV_LEN2, RELAY_ENC, relayKeyCache, keyring, relayReceivers, relaySenders, PUBLIC_TRACKERS, STATE_STALE_MS, activeUploads, RELAY_ACK_TIMEOUT_MS, RELAY_MAX_RETRIES, app, LOCAL_HOSTS, DAEMON_START_TIME, PACKAGE_VERSION, hostSessionInflight, MAX_MULTI_PATHS, MULTI_CONCURRENCY, embeddedReady, httpServer;
+var _WebTorrentCtor, _webTorrentLoadError, SRIFT_HOME, EMBEDDED, STATE_PATH, logPath, DAEMON_LOG_MAX, openLog, logBytes, DAEMON_LOG_MAX_AGE_MS, pruneOldLogs, logStream, logRotating, logPending, writeLogLine, logMessage, fmtLogArg, crypto6, PORT, DEFAULT_SIGNALER_URL, activeSignalerUrl, lastDiag, session, activeTransfers, chatHistory, pendingJoins, participants, sseClients, wsConn, signalingMode, wsFailures, httpModeSince, WS_RETRY_AFTER_MS, wsUrl, csrfToken, heartbeatInterval, lastHeartbeatAckAt, encryptionKey, sessionTerminated, terminationReason, activeTorrents, wtClient, pubshares, pubsharesByToken, activePulls, pubshareRegResolvers, TEMP_DIR, TMP_CHUNK_MAX_AGE_MS, TMP_FILE_MAX_AGE_MS, KDF_ITERATIONS, IV_LEN2, RELAY_ENC, relayKeyCache, keyring, relayReceivers, relaySenders, PUBLIC_TRACKERS, STATE_STALE_MS, activeUploads, uploadKey, uploadsOf, RELAY_ACK_TIMEOUT_MS, RELAY_STALL_MS, RELAY_WINDOW, RELAY_LEGACY_CHUNK, RELAY_FAST_CHUNK, RELAY_FORMAT, RELAY_SOCKET_HIGH_BYTES, relayDownloads, partPathOf, app, LOCAL_HOSTS, DAEMON_START_TIME, PACKAGE_VERSION, hostSessionInflight, MAX_MULTI_PATHS, MULTI_CONCURRENCY, embeddedReady, httpServer;
 var init_daemon = __esm({
   "../../cli/daemon.ts"() {
     init_mcp();
@@ -5294,8 +5432,17 @@ var init_daemon = __esm({
     STATE_STALE_MS = 24 * 60 * 60 * 1e3;
     pruneStaleStateOnStartup();
     activeUploads = /* @__PURE__ */ new Map();
+    uploadKey = (fileId, userId) => `${fileId}|${userId}`;
+    uploadsOf = (fileId) => [...activeUploads.values()].filter((u) => u.fileId === fileId);
     RELAY_ACK_TIMEOUT_MS = Number(process.env.SRIFT_RELAY_ACK_TIMEOUT_MS) || 15e3;
-    RELAY_MAX_RETRIES = 40;
+    RELAY_STALL_MS = RELAY_ACK_TIMEOUT_MS * 40;
+    RELAY_WINDOW = 16;
+    RELAY_LEGACY_CHUNK = 64 * 1024;
+    RELAY_FAST_CHUNK = 256 * 1024;
+    RELAY_FORMAT = "b64";
+    RELAY_SOCKET_HIGH_BYTES = 8 * 1024 * 1024;
+    relayDownloads = /* @__PURE__ */ new Map();
+    partPathOf = (fileId) => path7.join(TEMP_DIR, `${fileId.replace(/[^A-Za-z0-9_.-]/g, "_")}_chunk_part`);
     app = express();
     LOCAL_HOSTS = /* @__PURE__ */ new Set([`127.0.0.1:${PORT}`, `localhost:${PORT}`, `[::1]:${PORT}`]);
     app.use((req, res, next) => {
@@ -5311,7 +5458,7 @@ var init_daemon = __esm({
     app.use(cors({ origin: "*", maxAge: 600 }));
     app.use(express.json());
     DAEMON_START_TIME = Date.now();
-    PACKAGE_VERSION = "4.3.0";
+    PACKAGE_VERSION = "4.3.2";
     app.get("/health", (req, res) => {
       res.json({
         ok: true,
@@ -5602,7 +5749,7 @@ var init_daemon = __esm({
       }
       wsConn?.send(JSON.stringify({
         type: "file_accept",
-        payload: { fileId, relayEnc: RELAY_ENC, ...relayPk ? { relayPk } : {} }
+        payload: { fileId, relayEnc: RELAY_ENC, relayFmt: RELAY_FORMAT, ...relayPk ? { relayPk } : {} }
       }));
       res.json({ success: true });
     });
@@ -5963,7 +6110,7 @@ data: /mcp/messages
         wtClient = null;
       }
       activeTorrents.clear();
-      activeUploads.clear();
+      for (const u of [...activeUploads.values()]) stopUpload(u);
       session = { id: null, name: null, role: null, isConnected: false, userId: null };
       activeTransfers = [];
       chatHistory = [];
@@ -6026,7 +6173,7 @@ data: /mcp/messages
       }
       try {
         activeTorrents.clear();
-        activeUploads.clear();
+        for (const u of [...activeUploads.values()]) stopUpload(u);
       } catch {
       }
       try {