@elefunc/send 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elefunc/send",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Browser-compatible file transfer CLI and TUI powered by Bun, WebRTC, and Rezi.",
   "license": "MIT",
   "type": "module",

package/src/core/files.ts

@@ -1,4 +1,4 @@
-import { access, mkdir, stat } from "node:fs/promises"
+import { access, mkdir, open, rm, stat, type FileHandle } from "node:fs/promises"
 import { basename, extname, join, resolve } from "node:path"
 import { resolveUserPath } from "./paths"
 
@@ -8,16 +8,16 @@ export interface LocalFile {
   size: number
   type: string
   lastModified: number
-  blob: Blob
+  reader?: FileHandle
 }
 
-export type LocalFileInfo = Omit<LocalFile, "blob">
+export type LocalFileInfo = Omit<LocalFile, "reader">
 export interface LocalPathIssue {
   path: string
   error: string
 }
 
-const exists = async (path: string) => access(path).then(() => true, () => false)
+export const pathExists = async (path: string) => access(path).then(() => true, () => false)
 
 export const inspectLocalFile = async (path: string): Promise<LocalFileInfo> => {
   const absolute = resolveUserPath(path)
@@ -52,23 +52,52 @@ export const inspectLocalPaths = async (paths: string[]) => {
 
 export const loadLocalFile = async (path: string): Promise<LocalFile> => {
   const info = await inspectLocalFile(path)
-  return {
-    ...info,
-    blob: Bun.file(info.path),
-  }
+  return { ...info }
 }
 
 export const loadLocalFiles = (paths: string[]) => Promise.all(paths.map(loadLocalFile))
 
-export const readFileChunk = async (file: LocalFile, offset: number, size: number) => Buffer.from(await file.blob.slice(offset, offset + size).arrayBuffer())
+const readHandleChunk = async (handle: FileHandle, offset: number, size: number) => {
+  const chunk = Buffer.allocUnsafe(size)
+  let bytesReadTotal = 0
+  while (bytesReadTotal < size) {
+    const { bytesRead } = await handle.read(chunk, bytesReadTotal, size - bytesReadTotal, offset + bytesReadTotal)
+    if (!bytesRead) break
+    bytesReadTotal += bytesRead
+  }
+  return bytesReadTotal === size ? chunk : chunk.subarray(0, bytesReadTotal)
+}
 
-export const uniqueOutputPath = async (directory: string, fileName: string) => {
+export const readFileChunk = async (file: LocalFile, offset: number, size: number) => {
+  file.reader ||= await open(file.path, "r")
+  return readHandleChunk(file.reader, offset, size)
+}
+
+export const closeLocalFile = async (file?: LocalFile) => {
+  if (!file?.reader) return
+  const reader = file.reader
+  file.reader = undefined
+  await reader.close()
+}
+
+export const writeFileChunk = async (handle: FileHandle, data: Buffer, offset: number) => {
+  let bytesWrittenTotal = 0
+  while (bytesWrittenTotal < data.byteLength) {
+    const { bytesWritten } = await handle.write(data, bytesWrittenTotal, data.byteLength - bytesWrittenTotal, offset + bytesWrittenTotal)
+    if (!bytesWritten) throw new Error("short write")
+    bytesWrittenTotal += bytesWritten
+  }
+  return bytesWrittenTotal
+}
+
+export const uniqueOutputPath = async (directory: string, fileName: string, reservedPaths: ReadonlySet<string> = new Set()) => {
   await mkdir(directory, { recursive: true })
   const extension = extname(fileName)
   const stem = extension ? fileName.slice(0, -extension.length) : fileName
   for (let index = 0; ; index += 1) {
     const candidate = join(directory, index ? `${stem} (${index})${extension}` : fileName)
-    if (!await exists(candidate)) return candidate
+    if (reservedPaths.has(candidate)) continue
+    if (!await pathExists(candidate)) return candidate
   }
 }
 
@@ -77,3 +106,7 @@ export const saveIncomingFile = async (directory: string, fileName: string, data
   await Bun.write(path, data)
   return path
 }
+
+export const removePath = async (path: string) => {
+  await rm(path, { force: true }).catch(() => {})
+}

package/src/core/session.ts

@@ -1,7 +1,8 @@
+import { open, rename, type FileHandle } from "node:fs/promises"
 import { resolve } from "node:path"
 import type { RTCDataChannel, RTCIceCandidateInit, RTCIceServer } from "werift"
 import { RTCPeerConnection } from "werift"
-import { loadLocalFiles, readFileChunk, saveIncomingFile, type LocalFile } from "./files"
+import { closeLocalFile, loadLocalFiles, pathExists, readFileChunk, removePath, saveIncomingFile, uniqueOutputPath, writeFileChunk, type LocalFile } from "./files"
 import {
   BASE_ICE_SERVERS,
   BUFFER_HIGH,
@@ -87,12 +88,23 @@ interface TransferState {
   file?: LocalFile
   buffers?: Buffer[]
   data?: Buffer
+  incomingDisk?: IncomingDiskState
   inFlight: boolean
   cancel: boolean
   cancelReason?: string
   cancelSource?: "local" | "remote"
 }
 
+interface IncomingDiskState {
+  finalPath: string
+  tempPath: string
+  handle: FileHandle
+  queue: Promise<void>
+  offset: number
+  error: string
+  closed: boolean
+}
+
 export interface PeerSnapshot {
   id: string
   name: string
@@ -384,6 +396,7 @@ export class SendSession {
   private readonly logs: LogEntry[] = []
   private readonly subscribers = new Set<() => void>()
   private readonly eventSubscribers = new Set<(event: SessionEvent) => void>()
+  private readonly reservedSavePaths = new Set<string>()
 
   private rtcEpochCounter = 0
   private socket: WebSocket | null = null
@@ -674,7 +687,14 @@ export class SendSession {
     if (!transfer || transfer.direction !== "in" || isFinal(transfer)) return false
     const peer = this.peers.get(transfer.peerId)
     if (!peer || !this.isPeerReady(peer)) return false
-    if (!this.sendDataControl(peer, { kind: "file-accept", transferId })) return false
+    const streamingToDisk = await this.startIncomingDiskTransfer(transfer)
+    transfer.data = undefined
+    transfer.buffers = streamingToDisk ? undefined : []
+    if (!this.sendDataControl(peer, { kind: "file-accept", transferId })) {
+      if (streamingToDisk) this.discardIncomingDiskTransfer(transfer)
+      transfer.buffers = []
+      return false
+    }
     transfer.status = "accepted"
     this.noteTransfer(transfer)
     this.emit({ type: "transfer", transfer: this.transferSnapshot(transfer) })
@@ -738,13 +758,12 @@ export class SendSession {
   async saveTransfer(transferId: string) {
     const transfer = this.transfers.get(transferId)
     if (!transfer || transfer.direction !== "in" || transfer.status !== "complete") return null
+    if (transfer.savedPath) return transfer.savedPath
     if (!transfer.data && transfer.buffers?.length) transfer.data = Buffer.concat(transfer.buffers)
     if (!transfer.data) return null
-    transfer.savedPath ||= await saveIncomingFile(this.saveDir, transfer.name, transfer.data)
+    transfer.savedPath = await saveIncomingFile(this.saveDir, transfer.name, transfer.data)
     transfer.savedAt ||= Date.now()
-    const snapshot = this.transferSnapshot(transfer)
-    this.pushLog("transfer:saved", { transferId: transfer.id, path: transfer.savedPath })
-    this.emit({ type: "saved", transfer: snapshot })
+    this.emitTransferSaved(transfer)
     this.notify()
     return transfer.savedPath
   }
@@ -753,6 +772,124 @@ export class SendSession {
     return this.transfers.get(transferId)
   }
 
+  private emitTransferSaved(transfer: TransferState) {
+    const snapshot = this.transferSnapshot(transfer)
+    this.pushLog("transfer:saved", { transferId: transfer.id, path: transfer.savedPath })
+    this.emit({ type: "saved", transfer: snapshot })
+  }
+
+  private autoSaveTransfer(transferId: string) {
+    void this.saveTransfer(transferId).catch(error => {
+      this.pushLog("transfer:save-error", { transferId, error: `${error}` }, "error")
+      this.notify()
+    })
+  }
+
+  private async createIncomingDiskState(fileName: string): Promise<IncomingDiskState> {
+    const finalPath = await uniqueOutputPath(this.saveDir, fileName || "download", this.reservedSavePaths)
+    this.reservedSavePaths.add(finalPath)
+    for (let attempt = 0; ; attempt += 1) {
+      const tempPath = `${finalPath}.part.${uid(6)}${attempt ? `.${attempt}` : ""}`
+      try {
+        const handle = await open(tempPath, "wx")
+        return {
+          finalPath,
+          tempPath,
+          handle,
+          queue: Promise.resolve(),
+          offset: 0,
+          error: "",
+          closed: false,
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException | undefined)?.code === "EEXIST") continue
+        this.reservedSavePaths.delete(finalPath)
+        throw error
+      }
+    }
+  }
+
+  private takeIncomingDisk(transfer: TransferState) {
+    const disk = transfer.incomingDisk
+    transfer.incomingDisk = undefined
+    return disk
+  }
+
+  private async closeIncomingDiskState(disk: IncomingDiskState, removeTemp: boolean) {
+    if (!disk.closed) {
+      disk.closed = true
+      try { await disk.handle.close() } catch {}
+    }
+    if (removeTemp) await removePath(disk.tempPath)
+    this.reservedSavePaths.delete(disk.finalPath)
+  }
+
+  private discardIncomingDiskTransfer(transfer: TransferState) {
+    const disk = this.takeIncomingDisk(transfer)
+    if (!disk) return
+    void this.closeIncomingDiskState(disk, true)
+  }
+
+  private async startIncomingDiskTransfer(transfer: TransferState) {
+    if (!this.autoSaveIncoming || transfer.incomingDisk) return false
+    try {
+      transfer.incomingDisk = await this.createIncomingDiskState(transfer.name)
+      return true
+    } catch (error) {
+      this.pushLog("transfer:save-error", { transferId: transfer.id, error: `${error}` }, "error")
+      return false
+    }
+  }
+
+  private queueIncomingDiskWrite(peer: PeerState, transfer: TransferState, data: Buffer) {
+    const disk = transfer.incomingDisk
+    if (!disk) return
+    disk.queue = disk.queue.then(async () => {
+      if (disk.closed || disk.error || transfer.cancel || transfer.status !== "receiving") return
+      await writeFileChunk(disk.handle, data, disk.offset)
+      disk.offset += data.byteLength
+    }).catch(error => {
+      if (disk.error || isFinal(transfer)) return
+      disk.error = `${error}`
+      this.pushLog("transfer:save-error", { transferId: transfer.id, error: disk.error }, "error")
+      this.sendDataControl(peer, { kind: "file-error", transferId: transfer.id, reason: disk.error })
+      this.completeTransfer(transfer, "error", disk.error)
+    })
+  }
+
+  private async finalizeIncomingDiskTransfer(transfer: TransferState, expectedSize: number) {
+    const disk = this.takeIncomingDisk(transfer)
+    if (!disk) return null
+    await disk.queue
+    if (disk.error) {
+      await this.closeIncomingDiskState(disk, true)
+      return null
+    }
+    if (disk.offset !== expectedSize) throw new Error(`saved size mismatch: ${disk.offset} vs ${expectedSize}`)
+
+    let finalPath = disk.finalPath
+    try {
+      if (!disk.closed) {
+        disk.closed = true
+        await disk.handle.close()
+      }
+      if (await pathExists(finalPath)) {
+        this.reservedSavePaths.delete(finalPath)
+        finalPath = await uniqueOutputPath(this.saveDir, transfer.name || "download", this.reservedSavePaths)
+        this.reservedSavePaths.add(finalPath)
+      }
+      await rename(disk.tempPath, finalPath)
+      transfer.savedPath = finalPath
+      transfer.savedAt ||= Date.now()
+      return finalPath
+    } catch (error) {
+      await removePath(disk.tempPath)
+      throw error
+    } finally {
+      this.reservedSavePaths.delete(finalPath)
+    }
+  }
+
   async waitFor(predicate: () => boolean, timeoutMs: number, signal?: AbortSignal | null) {
     if (predicate()) return
     if (signal?.aborted) throw new SessionAbortedError()
@@ -930,9 +1067,11 @@ export class SendSession {
     transfer.inFlight = false
     transfer.endedAt = Date.now()
     this.noteTransfer(transfer)
+    if (transfer.direction === "out") void closeLocalFile(transfer.file).catch(() => {})
     if (status !== "complete" && transfer.direction === "in") {
       transfer.buffers = []
       transfer.data = undefined
+      this.discardIncomingDiskTransfer(transfer)
     }
 
     const peer = this.peers.get(transfer.peerId)
@@ -945,7 +1084,7 @@ export class SendSession {
 
     const snapshot = this.transferSnapshot(transfer)
     this.emit({ type: "transfer", transfer: snapshot })
-    if (status === "complete" && transfer.direction === "in" && this.autoSaveIncoming) void this.saveTransfer(transfer.id)
+    if (status === "complete" && transfer.direction === "in" && this.autoSaveIncoming && transfer.savedAt === 0) this.autoSaveTransfer(transfer.id)
     this.notify()
   }
 
@@ -1517,8 +1656,11 @@ export class SendSession {
   private onBinary(peer: PeerState, data: Buffer) {
     const transfer = this.transfers.get(peer.activeIncoming)
     if (!transfer || transfer.status !== "receiving") return
-    transfer.buffers ||= []
-    transfer.buffers.push(data)
+    if (transfer.incomingDisk) this.queueIncomingDiskWrite(peer, transfer, data)
+    else {
+      transfer.buffers ||= []
+      transfer.buffers.push(data)
+    }
     transfer.bytes += data.byteLength
     transfer.chunks += 1
     this.noteTransfer(transfer)
@@ -1579,7 +1721,8 @@ export class SendSession {
           peer.activeIncoming = transfer.id
           transfer.status = "receiving"
           transfer.startedAt ||= Date.now()
-          transfer.buffers = []
+          transfer.data = undefined
+          transfer.buffers = transfer.incomingDisk ? undefined : []
           this.noteTransfer(transfer)
           this.emit({ type: "transfer", transfer: this.transferSnapshot(transfer) })
         }
@@ -1593,6 +1736,7 @@ export class SendSession {
       case "file-end": {
         const transfer = this.transfers.get(message.transferId)
         if (!transfer || transfer.direction !== "in") break
+        if (isFinal(transfer)) break
         if (transfer.status === "cancelling") {
           this.completeTransfer(transfer, "cancelled", transfer.cancelReason || "cancelled")
           break
@@ -1601,6 +1745,27 @@ export class SendSession {
           this.completeTransfer(transfer, "error", `unexpected end while ${transfer.status}`)
           break
         }
+        if (transfer.bytes !== message.size) {
+          const reason = `size mismatch: ${transfer.bytes} vs ${message.size}`
+          this.sendDataControl(peer, { kind: "file-error", transferId: transfer.id, reason })
+          this.completeTransfer(transfer, "error", reason)
+          break
+        }
+        if (transfer.incomingDisk) {
+          try {
+            const savedPath = await this.finalizeIncomingDiskTransfer(transfer, message.size)
+            if (!savedPath) break
+            this.sendDataControl(peer, { kind: "file-done", transferId: transfer.id, size: transfer.bytes, totalChunks: transfer.chunks })
+            this.completeTransfer(transfer, "complete")
+            this.emitTransferSaved(transfer)
+          } catch (error) {
+            const reason = `${error}`
+            this.pushLog("transfer:save-error", { transferId: transfer.id, error: reason }, "error")
+            this.sendDataControl(peer, { kind: "file-error", transferId: transfer.id, reason })
+            this.completeTransfer(transfer, "error", reason)
+          }
+          break
+        }
         const data = Buffer.concat(transfer.buffers || [])
         if (data.byteLength !== message.size) {
           const reason = `size mismatch: ${data.byteLength} vs ${message.size}`

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { resolve } from "node:path"
 import { cac, type CAC } from "cac"
-import { cleanRoom } from "./core/protocol"
+import { cleanRoom, displayPeerName } from "./core/protocol"
 import type { SendSession, SessionConfig, SessionEvent } from "./core/session"
 import { resolvePeerTargets } from "./core/targeting"
 import { ensureSessionRuntimePatches, ensureTuiRuntimePatches } from "../runtime/install"
@@ -74,6 +74,7 @@ const TUI_TOGGLE_OPTIONS = [
   ["--offer <0|1>", "auto-offer drafts to matching ready peers: 1 on, 0 off"],
   ["--save <0|1>", "auto-save completed incoming files: 1 on, 0 off"],
 ] as const
+export const ACCEPT_SESSION_DEFAULTS = { autoAcceptIncoming: true, autoSaveIncoming: true } as const
 const addOptions = (command: CliCommand, definitions: readonly (readonly [string, string])[]) =>
   definitions.reduce((next, [flag, description]) => next.option(flag, description), command)
 
@@ -108,9 +109,10 @@ export const sessionConfigFrom = (options: Record<string, unknown>, defaults: {
   }
 }
 
-export const roomAnnouncement = (room: string, json = false) => json ? JSON.stringify({ type: "room", room }) : `room ${room}`
+export const roomAnnouncement = (room: string, self: string, json = false) =>
+  json ? JSON.stringify({ type: "room", room, self }) : `room ${room}\nself ${self}`
 
-const printRoomAnnouncement = (room: string, json = false) => console.log(roomAnnouncement(room, json))
+const printRoomAnnouncement = (room: string, self: string, json = false) => console.log(roomAnnouncement(room, self, json))
 
 const printEvent = (event: SessionEvent) => console.log(JSON.stringify(event))
 
@@ -191,7 +193,7 @@ const peersCommand = async (options: Record<string, unknown>) => {
   const { SendSession } = await loadSessionRuntime()
   const session = new SendSession(sessionConfigFrom(options, {}))
   handleSignals(session)
-  printRoomAnnouncement(session.room, !!options.json)
+  printRoomAnnouncement(session.room, displayPeerName(session.name, session.localId), !!options.json)
   await session.connect()
   await Bun.sleep(numberOption(options.wait, 3000))
   const snapshot = session.snapshot()
@@ -218,7 +220,7 @@ const offerCommand = async (files: string[], options: Record<string, unknown>) =
   const { SendSession } = await loadSessionRuntime()
   const session = new SendSession(sessionConfigFrom(options, {}))
   handleSignals(session)
-  printRoomAnnouncement(session.room, !!options.json)
+  printRoomAnnouncement(session.room, displayPeerName(session.name, session.localId), !!options.json)
   const detachReporter = attachReporter(session, !!options.json)
   await session.connect()
   const targets = await waitForTargets(session, selectors, timeoutMs)
@@ -232,9 +234,9 @@ const offerCommand = async (files: string[], options: Record<string, unknown>) =
 
 const acceptCommand = async (options: Record<string, unknown>) => {
   const { SendSession } = await loadSessionRuntime()
-  const session = new SendSession(sessionConfigFrom(options, { autoAcceptIncoming: true, autoSaveIncoming: true }))
+  const session = new SendSession(sessionConfigFrom(options, ACCEPT_SESSION_DEFAULTS))
   handleSignals(session)
-  printRoomAnnouncement(session.room, !!options.json)
+  printRoomAnnouncement(session.room, displayPeerName(session.name, session.localId), !!options.json)
   const detachReporter = attachReporter(session, !!options.json)
   await session.connect()
   if (!options.json) console.log(`listening in ${session.room}`)
@@ -252,7 +254,7 @@ const acceptCommand = async (options: Record<string, unknown>) => {
 }
 
 const tuiCommand = async (options: Record<string, unknown>) => {
-  const initialConfig = sessionConfigFrom(options, { autoAcceptIncoming: true, autoSaveIncoming: true })
+  const initialConfig = sessionConfigFrom(options, ACCEPT_SESSION_DEFAULTS)
   const { clean, offer } = parseBinaryOptions(options, ["clean", "offer"] as const)
   const { startTui } = await loadTuiRuntime()
   await startTui(initialConfig, {