@elefunc/send 0.1.4 → 0.1.6

package/package.json

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

package/src/core/protocol.ts

@@ -1,4 +1,4 @@
-import type { RTCIceCandidateInit, RTCSessionDescriptionInit } from "werift"
+import type { RTCIceCandidateInit, RTCIceServer, RTCSessionDescriptionInit } from "werift"
 
 export const SIGNAL_WS_URL = "wss://sig.efn.kr/ws"
 export const BASE_ICE_SERVERS = [
@@ -59,6 +59,7 @@ export interface SignalEnvelope {
   from: string
   to: string
   at: string
+  instanceId?: string
 }
 
 export interface HelloSignal extends SignalEnvelope {
@@ -68,6 +69,7 @@ export interface HelloSignal extends SignalEnvelope {
   profile?: PeerProfile
   rtcEpoch?: number
   reply?: boolean
+  recovery?: boolean
 }
 
 export interface NameSignal extends SignalEnvelope {
@@ -105,6 +107,11 @@ export interface CandidateSignal extends SignalEnvelope {
   candidate: RTCIceCandidateInit
 }
 
+export interface TurnShareSignal extends SignalEnvelope {
+  kind: "turn-share"
+  iceServers: RTCIceServer[]
+}
+
 export type SignalMessage =
   | HelloSignal
   | NameSignal
@@ -112,6 +119,7 @@ export type SignalMessage =
   | ByeSignal
   | DescriptionSignal
   | CandidateSignal
+  | TurnShareSignal
 
 export interface DataEnvelope {
   room: string
@@ -200,6 +208,7 @@ export const cleanText = (value: unknown, max = 72) => `${value ?? ""}`.trim().r
 export const cleanRoom = (value: unknown) => cleanText(value).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || uid(8)
 export const cleanName = (value: unknown) => cleanText(value, 24).toLowerCase().replace(/[^a-z0-9]+/g, "").slice(0, 24) || fallbackName
 export const cleanLocalId = (value: unknown) => cleanText(value, 24).toLowerCase().replace(/[^a-z0-9]+/g, "").slice(0, 24) || uid(8)
+export const cleanInstanceId = (value: unknown) => cleanText(value, 24).toLowerCase().replace(/[^a-z0-9]+/g, "").slice(0, 24)
 export const signalEpoch = (value: unknown) => Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : 0
 
 export const buildCliProfile = (): PeerProfile => ({

package/src/core/session.ts

@@ -11,6 +11,7 @@ import {
   SIGNAL_WS_URL,
   buildCliProfile,
   cleanText,
+  cleanInstanceId,
   cleanLocalId,
   cleanName,
   cleanRoom,
@@ -39,6 +40,7 @@ interface PeerState {
   name: string
   presence: Presence
   selected: boolean
+  remoteInstanceId: string
   polite: boolean
   pc: RTCPeerConnection | null
   dc: RTCDataChannel | null
@@ -157,6 +159,7 @@ export interface SessionConfig {
   localId?: string
   name?: string
   saveDir?: string
+  peerSelectionMemory?: Map<string, boolean>
   autoAcceptIncoming?: boolean
   autoSaveIncoming?: boolean
   turnUrls?: string[]
@@ -257,7 +260,22 @@ export const turnUsageState = (
   return "idle"
 }
 
-const timeoutSignal = (ms: number) => typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(ms) : undefined
+export class SessionAbortedError extends Error {
+  constructor(message = "session aborted") {
+    super(message)
+    this.name = "SessionAbortedError"
+  }
+}
+
+export const isSessionAbortedError = (error: unknown): error is SessionAbortedError =>
+  error instanceof SessionAbortedError || error instanceof Error && error.name === "SessionAbortedError"
+
+const timeoutSignal = (ms: number, base?: AbortSignal | null) => {
+  const timeout = typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(ms) : undefined
+  if (!base) return timeout
+  if (!timeout) return base
+  return typeof AbortSignal.any === "function" ? AbortSignal.any([base, timeout]) : base
+}
 
 const normalizeCandidateType = (value: unknown) => typeof value === "string" ? value.toLowerCase() : ""
 const validCandidateType = (value: string) => ["host", "srflx", "prflx", "relay"].includes(value)
@@ -311,7 +329,30 @@ const sameConnectivity = (left: PeerConnectivitySnapshot, right: PeerConnectivit
   && left.remoteCandidateType === right.remoteCandidateType
   && left.pathLabel === right.pathLabel
 
-const turnServers = (urls: string[], username?: string, credential?: string): RTCIceServer[] => [...new Set(urls.filter(Boolean))].map(urls => ({ urls, ...(username ? { username } : {}), ...(credential ? { credential } : {}) }))
+const turnServerUrls = (server?: RTCIceServer | null) => (Array.isArray(server?.urls) ? server.urls : [server?.urls]).map(url => `${url ?? ""}`.trim()).filter(url => /^turns?:/i.test(url))
+const normalizeTurnServer = (server?: RTCIceServer | null): RTCIceServer | null => {
+  const urls = [...new Set(turnServerUrls(server))]
+  if (!urls.length) return null
+  const username = `${server?.username ?? ""}`.trim()
+  const credential = `${server?.credential ?? ""}`.trim()
+  return {
+    urls: urls[0],
+    ...(username ? { username } : {}),
+    ...(credential ? { credential } : {}),
+  }
+}
+const turnServerKey = (server?: RTCIceServer | null) => {
+  const normalized = normalizeTurnServer(server)
+  return normalized ? JSON.stringify({
+    urls: turnServerUrls(normalized).sort(),
+    username: `${normalized.username ?? ""}`,
+    credential: `${normalized.credential ?? ""}`,
+  }) : ""
+}
+const turnServers = (urls: string[], username?: string, credential?: string): RTCIceServer[] =>
+  [...new Set(urls.map(url => `${url ?? ""}`.trim()).filter(url => /^turns?:/i.test(url)))]
+    .map(url => normalizeTurnServer({ urls: url, ...(username ? { username } : {}), ...(credential ? { credential } : {}) }))
+    .filter((server): server is RTCIceServer => !!server)
 
 const messageString = async (value: unknown) => {
   if (typeof value === "string") return value
@@ -322,6 +363,7 @@ const messageString = async (value: unknown) => {
 }
 
 export class SendSession {
+  readonly instanceId: string
   readonly localId: string
   profile = sanitizeProfile(buildCliProfile())
   readonly saveDir: string
@@ -334,7 +376,9 @@ export class SendSession {
   private autoAcceptIncoming: boolean
   private autoSaveIncoming: boolean
   private readonly reconnectSocket: boolean
-  private readonly iceServers: RTCIceServer[]
+  private iceServers: RTCIceServer[]
+  private extraTurnServers: RTCIceServer[]
+  private readonly peerSelectionMemory: Map<string, boolean>
   private readonly peers = new Map<string, PeerState>()
   private readonly transfers = new Map<string, TransferState>()
   private readonly logs: LogEntry[] = []
@@ -346,19 +390,23 @@ export class SendSession {
   private socketToken = 0
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
   private peerStatsTimer: ReturnType<typeof setInterval> | null = null
+  private readonly pendingRtcCloses = new Set<Promise<void>>()
+  private lifecycleAbortController: AbortController | null = null
   private stopped = false
 
   constructor(config: SessionConfig) {
+    this.instanceId = cleanInstanceId(uid(10)) || uid(10)
     this.localId = cleanLocalId(config.localId)
     this.room = cleanRoom(config.room)
     this.name = cleanName(config.name ?? fallbackName)
     this.saveDir = resolve(config.saveDir ?? resolve(process.cwd(), "downloads"))
+    this.peerSelectionMemory = config.peerSelectionMemory ?? new Map()
     this.autoAcceptIncoming = !!config.autoAcceptIncoming
     this.autoSaveIncoming = !!config.autoSaveIncoming
     this.reconnectSocket = config.reconnectSocket ?? true
-    const extraTurn = turnServers(config.turnUrls ?? [], config.turnUsername, config.turnCredential)
-    this.iceServers = [...BASE_ICE_SERVERS, ...extraTurn]
-    this.turnAvailable = extraTurn.length > 0
+    this.extraTurnServers = turnServers(config.turnUrls ?? [], config.turnUsername, config.turnCredential)
+    this.iceServers = [...BASE_ICE_SERVERS, ...this.extraTurnServers]
+    this.turnAvailable = this.extraTurnServers.length > 0
   }
 
   subscribe(listener: () => void) {
@@ -394,17 +442,22 @@ export class SendSession {
 
   async connect(timeoutMs = 10_000) {
     this.stopped = false
+    this.lifecycleAbortController?.abort()
+    this.lifecycleAbortController = typeof AbortController === "function" ? new AbortController() : null
     this.startPeerStatsPolling()
     void this.loadLocalProfile()
     void this.probePulse()
     this.connectSocket()
-    await this.waitFor(() => this.socketState === "open", timeoutMs)
+    await this.waitFor(() => this.socketState === "open", timeoutMs, this.lifecycleAbortController?.signal)
   }
 
   async close() {
     this.stopped = true
     this.stopPeerStatsPolling()
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer)
+    this.reconnectTimer = null
+    this.lifecycleAbortController?.abort()
+    this.lifecycleAbortController = null
     if (this.socket?.readyState === WebSocket.OPEN) this.sendSignal({ kind: "bye" })
     const socket = this.socket
     this.socket = null
@@ -412,6 +465,7 @@ export class SendSession {
     if (socket) try { socket.close(1000, "normal") } catch {}
     for (const peer of this.peers.values()) this.destroyPeer(peer, "session-close")
     this.notify()
+    if (this.pendingRtcCloses.size) await Promise.allSettled([...this.pendingRtcCloses])
   }
 
   activePeers() {
@@ -426,10 +480,34 @@ export class SendSession {
     return this.readyPeers().filter(peer => peer.selected)
   }
 
+  canShareTurn() {
+    return this.extraTurnServers.length > 0
+  }
+
+  shareTurnWithPeer(peerId: string) {
+    const peer = this.peers.get(peerId)
+    if (!peer || peer.presence !== "active" || !this.extraTurnServers.length) return false
+    const sent = this.sendSignal({ kind: "turn-share", to: peer.id, iceServers: this.sharedTurnServers() })
+    if (sent) this.pushLog("turn:share-sent", { peer: peer.id, scope: "peer" }, "info")
+    return sent
+  }
+
+  shareTurnWithAllPeers() {
+    const count = this.activePeers().length
+    if (!count || !this.extraTurnServers.length) return 0
+    const sent = this.sendSignal({ kind: "turn-share", to: "*", iceServers: this.sharedTurnServers() })
+    if (sent) this.pushLog("turn:share-sent", { peers: count, scope: "all" }, "info")
+    return sent ? count : 0
+  }
+
   setPeerSelected(peerId: string, selected: boolean) {
     const peer = this.peers.get(peerId)
-    if (!peer || peer.presence !== "active") return false
-    peer.selected = selected
+    if (!peer) return false
+    const next = !!selected
+    const rememberedChanged = this.rememberPeerSelected(peerId, next)
+    if (peer.presence !== "active") return rememberedChanged
+    if (peer.selected === next && !rememberedChanged) return false
+    peer.selected = next
     this.emit({ type: "peer", peer: this.peerSnapshot(peer) })
     this.notify()
     return true
@@ -440,6 +518,32 @@ export class SendSession {
     return peer ? this.setPeerSelected(peerId, !peer.selected) : false
   }
 
+  private sharedTurnServers() {
+    return this.extraTurnServers.map(server => normalizeTurnServer(server)).filter((server): server is RTCIceServer => !!server)
+  }
+
+  private refreshIceServers() {
+    this.turnAvailable = this.extraTurnServers.length > 0
+    this.iceServers = [...BASE_ICE_SERVERS, ...this.extraTurnServers]
+  }
+
+  private mergeTurnServers(iceServers: RTCIceServer[] = []) {
+    const known = new Set(this.extraTurnServers.map(turnServerKey).filter(Boolean))
+    const added: RTCIceServer[] = []
+    for (const server of iceServers) {
+      const normalized = normalizeTurnServer(server)
+      if (!normalized) continue
+      const key = turnServerKey(normalized)
+      if (!key || known.has(key)) continue
+      known.add(key)
+      added.push(normalized)
+    }
+    if (!added.length) return 0
+    this.extraTurnServers = [...this.extraTurnServers, ...added]
+    this.refreshIceServers()
+    return added.length
+  }
+
   clearLogs() {
     this.logs.length = 0
     this.notify()
@@ -635,19 +739,31 @@ export class SendSession {
     return this.transfers.get(transferId)
   }
 
-  async waitFor(predicate: () => boolean, timeoutMs: number) {
+  async waitFor(predicate: () => boolean, timeoutMs: number, signal?: AbortSignal | null) {
     if (predicate()) return
+    if (signal?.aborted) throw new SessionAbortedError()
     await new Promise<void>((resolveWait, rejectWait) => {
-      const timeout = setTimeout(() => {
+      let unsubscribe = () => {}
+      const cleanup = () => {
+        clearTimeout(timeout)
+        signal?.removeEventListener("abort", onAbort)
         unsubscribe()
+      }
+      const onAbort = () => {
+        cleanup()
+        rejectWait(new SessionAbortedError())
+      }
+      const timeout = setTimeout(() => {
+        cleanup()
         rejectWait(new Error(`timed out after ${timeoutMs}ms`))
       }, timeoutMs)
-      const unsubscribe = this.subscribe(() => {
+      unsubscribe = this.subscribe(() => {
         if (!predicate()) return
-        clearTimeout(timeout)
-        unsubscribe()
+        cleanup()
         resolveWait()
       })
+      signal?.addEventListener("abort", onAbort, { once: true })
+      if (signal?.aborted) onAbort()
     })
   }
 
@@ -862,13 +978,17 @@ export class SendSession {
 
   private async loadLocalProfile() {
     try {
-      const response = await fetch(PROFILE_URL, { cache: "no-store", signal: timeoutSignal(4000) })
+      const response = await fetch(PROFILE_URL, { cache: "no-store", signal: timeoutSignal(4000, this.lifecycleAbortController?.signal) })
       if (!response.ok) throw new Error(`profile ${response.status}`)
-      this.profile = localProfileFromResponse(await response.json())
+      const data = await response.json()
+      if (this.stopped) return
+      this.profile = localProfileFromResponse(data)
     } catch (error) {
+      if (this.stopped) return
       this.profile = localProfileFromResponse(null, `${error}`)
       this.pushLog("profile:error", { error: `${error}` }, "error")
     }
+    if (this.stopped) return
     this.broadcastProfile()
     this.notify()
   }
@@ -878,13 +998,16 @@ export class SendSession {
     this.pulse = { ...this.pulse, state: "checking", error: "" }
     this.notify()
     try {
-      const response = await fetch(PULSE_URL, { cache: "no-store", signal: timeoutSignal(3500) })
+      const response = await fetch(PULSE_URL, { cache: "no-store", signal: timeoutSignal(3500, this.lifecycleAbortController?.signal) })
       if (!response.ok) throw new Error(`pulse ${response.status}`)
+      if (this.stopped) return
       this.pulse = { state: "open", at: Date.now(), ms: performance.now() - startedAt, error: "" }
     } catch (error) {
+      if (this.stopped) return
       this.pulse = { state: "error", at: Date.now(), ms: 0, error: `${error}` }
       this.pushLog("pulse:error", { error: `${error}` }, "error")
     }
+    if (this.stopped) return
     this.notify()
   }
 
@@ -908,7 +1031,7 @@ export class SendSession {
 
   private sendSignal(payload: { kind: string; to?: string; [key: string]: unknown }) {
     if (!this.socket || this.socket.readyState !== WebSocket.OPEN) return false
-    const message = { room: this.room, from: this.localId, to: "*", at: stamp(), ...payload }
+    const message = { room: this.room, from: this.localId, to: "*", at: stamp(), instanceId: this.instanceId, ...payload }
     this.socket.send(JSON.stringify(message))
     this.pushLog("signal:out", message)
     return true
@@ -931,12 +1054,24 @@ export class SendSession {
     return !!peer && !!channel && peer.rtcEpoch === rtcEpoch && peer.dc === channel && channel.readyState === "open"
   }
 
-  private buildPeer(remoteId: string) {
+  private peerSelected(peerId: string) {
+    return this.peerSelectionMemory.get(peerId) ?? true
+  }
+
+  private rememberPeerSelected(peerId: string, selected: boolean) {
+    const next = !!selected
+    const previous = this.peerSelectionMemory.get(peerId)
+    this.peerSelectionMemory.set(peerId, next)
+    return previous !== next
+  }
+
+  private buildPeer(remoteId: string, remoteInstanceId = "") {
     const peer: PeerState = {
       id: remoteId,
       name: fallbackName,
       presence: "active",
-      selected: true,
+      selected: this.peerSelected(remoteId),
+      remoteInstanceId: cleanInstanceId(remoteInstanceId),
       polite: this.localId > remoteId,
       pc: null,
       dc: null,
@@ -960,14 +1095,42 @@ export class SendSession {
     return peer
   }
 
-  private syncPeerPresence(remoteId: string, name?: string, profile?: PeerProfile, turnAvailable?: boolean) {
-    const peer = this.peers.get(remoteId) ?? this.buildPeer(remoteId)
+  private resetPeerInstance(peer: PeerState, remoteInstanceId: string) {
+    peer.remoteInstanceId = remoteInstanceId
+    peer.remoteEpoch = 0
+    peer.selected = this.peerSelected(peer.id)
+    peer.presence = "active"
+    peer.terminalReason = ""
+    peer.lastError = ""
+    peer.turnAvailable = false
+    peer.connectivity = emptyConnectivitySnapshot()
+    this.failPeerTransfers(peer, "peer-restarted")
+    this.closePeerRTC(peer)
+    this.pushLog("peer:instance-replaced", { peer: peer.id, instanceId: remoteInstanceId })
+  }
+
+  private acceptPeerInstance(peer: PeerState, remoteInstanceId: unknown, kind: string) {
+    const nextInstanceId = cleanInstanceId(remoteInstanceId)
+    if (!nextInstanceId) return true
+    if (!peer.remoteInstanceId) {
+      peer.remoteInstanceId = nextInstanceId
+      return true
+    }
+    if (peer.remoteInstanceId === nextInstanceId) return true
+    if (kind !== "hello") return false
+    this.resetPeerInstance(peer, nextInstanceId)
+    return true
+  }
+
+  private syncPeerPresence(peer: PeerState, name?: string, profile?: PeerProfile, turnAvailable?: boolean) {
+    const wasTerminal = peer.presence === "terminal"
     peer.lastSeenAt = Date.now()
     peer.presence = "active"
     peer.terminalReason = ""
+    if (wasTerminal) peer.selected = this.peerSelected(peer.id)
     if (name != null) {
       peer.name = cleanName(name)
-      for (const transfer of this.transfers.values()) if (transfer.peerId === remoteId) transfer.peerName = peer.name
+      for (const transfer of this.transfers.values()) if (transfer.peerId === peer.id) transfer.peerName = peer.name
     }
     if (typeof turnAvailable === "boolean") peer.turnAvailable = turnAvailable
     if (profile) peer.profile = sanitizeProfile(profile)
@@ -975,14 +1138,21 @@ export class SendSession {
     return peer
   }
 
-  private syncPeerSignal(peer: PeerState, kind: string, remoteEpoch = 0) {
+  private syncPeerSignal(peer: PeerState, kind: string, remoteEpoch = 0, recovery = false) {
     const epoch = signalEpoch(remoteEpoch)
     if (epoch && epoch < peer.remoteEpoch) return null
     if (epoch) peer.remoteEpoch = epoch
-    if (kind !== "bye" && (!peer.pc || peer.pc.connectionState === "closed" || peer.dc?.readyState === "closed")) this.ensurePeerConnection(peer, `signal:${kind}`)
+    if (kind !== "bye" && (recovery || !peer.pc || peer.pc.connectionState === "closed" || peer.dc?.readyState === "closed")) this.ensurePeerConnection(peer, `signal:${kind}`)
     return peer
   }
 
+  private restartPeerConnection(peer: PeerState, reason: string, announceRecovery = false) {
+    this.ensurePeerConnection(peer, reason)
+    if (announceRecovery) this.sendPeerHello(peer, { recovery: true })
+    this.emit({ type: "peer", peer: this.peerSnapshot(peer) })
+    this.notify()
+  }
+
   private ensurePeerConnection(peer: PeerState, reason: string) {
     const epoch = this.nextRtcEpoch()
     peer.rtcEpoch = epoch
@@ -1072,13 +1242,34 @@ export class SendSession {
     channel.onmessage = ({ data }) => void this.onDataMessage(peer, data)
   }
 
+  private trackRtcClose(closeTask: Promise<void> | null | undefined) {
+    if (!closeTask) return
+    const task = closeTask.catch(() => {}).finally(() => {
+      this.pendingRtcCloses.delete(task)
+    })
+    this.pendingRtcCloses.add(task)
+  }
+
   private closePeerRTC(peer: PeerState) {
     const dc = peer.dc
     const pc = peer.pc
     peer.dc = null
     peer.pc = null
+    if (dc) {
+      ;(dc as any).onopen = null
+      ;(dc as any).onclose = null
+      ;(dc as any).onerror = null
+      ;(dc as any).onmessage = null
+    }
+    if (pc) {
+      ;(pc as any).onicecandidate = null
+      ;(pc as any).ondatachannel = null
+      ;(pc as any).onnegotiationneeded = null
+      ;(pc as any).onconnectionstatechange = null
+      ;(pc as any).oniceconnectionstatechange = null
+    }
     try { dc?.close() } catch {}
-    void pc?.close().catch(() => {})
+    this.trackRtcClose(pc ? Promise.resolve().then(() => pc.close()) : null)
   }
 
   private failPeerTransfers(peer: PeerState, reason: string) {
@@ -1098,29 +1289,45 @@ export class SendSession {
     const message = JSON.parse(raw) as SignalMessage
     if (message.room !== this.room || message.from === this.localId || (message.to && message.to !== "*" && message.to !== this.localId)) return
     this.pushLog("signal:in", message)
+    const peer = this.peers.get(message.from) ?? (message.kind === "bye" ? null : this.buildPeer(message.from, message.instanceId))
+    if (peer && !this.acceptPeerInstance(peer, message.instanceId, message.kind)) return
 
     if (message.kind === "hello") {
-      const peer = this.syncPeerSignal(this.syncPeerPresence(message.from, message.name, message.profile, message.turnAvailable), "hello", message.rtcEpoch)
-      if (peer && !message.reply) this.sendPeerHello(peer, { reply: true })
+      if (!peer) return
+      const synced = this.syncPeerSignal(this.syncPeerPresence(peer, message.name, message.profile, message.turnAvailable), "hello", message.rtcEpoch, !!message.recovery)
+      if (synced && !message.reply) this.sendPeerHello(synced, { reply: true })
       this.notify()
       return
     }
     if (message.kind === "name") {
-      this.syncPeerPresence(message.from, message.name)
+      if (!peer) return
+      this.syncPeerPresence(peer, message.name)
       this.notify()
       return
     }
     if (message.kind === "profile") {
-      this.syncPeerSignal(this.syncPeerPresence(message.from, message.name, message.profile, message.turnAvailable), "profile", message.rtcEpoch)
+      if (!peer) return
+      this.syncPeerSignal(this.syncPeerPresence(peer, message.name, message.profile, message.turnAvailable), "profile", message.rtcEpoch)
       this.notify()
       return
     }
     if (message.kind === "bye") {
-      const peer = this.peers.get(message.from)
       if (peer) this.destroyPeer(peer, "peer-left")
       this.notify()
       return
     }
+    if (message.kind === "turn-share") {
+      if (!peer) return
+      this.syncPeerPresence(peer)
+      const added = this.mergeTurnServers(message.iceServers)
+      if (added) {
+        this.pushLog("turn:share-applied", { peer: peer.id, added }, "info")
+        this.broadcastProfile()
+        this.restartPeerConnection(peer, "turn-share", true)
+      }
+      this.notify()
+      return
+    }
     if (message.kind === "description") {
       await this.onDescriptionSignal(message)
       return
@@ -1132,7 +1339,9 @@ export class SendSession {
   }
 
   private async onDescriptionSignal(message: DescriptionSignal) {
-    const peer = this.syncPeerSignal(this.syncPeerPresence(message.from, message.name, message.profile, message.turnAvailable), "description", message.rtcEpoch)
+    const existing = this.peers.get(message.from) ?? this.buildPeer(message.from, message.instanceId)
+    if (!this.acceptPeerInstance(existing, message.instanceId, message.kind)) return
+    const peer = this.syncPeerSignal(this.syncPeerPresence(existing, message.name, message.profile, message.turnAvailable), "description", message.rtcEpoch)
     if (!peer?.pc) return
     const offerCollision = message.description.type === "offer" && !peer.makingOffer && peer.pc.signalingState !== "stable"
     if (!peer.polite && offerCollision) return
@@ -1152,7 +1361,9 @@ export class SendSession {
   }
 
   private async onCandidateSignal(message: CandidateSignal) {
-    const peer = this.syncPeerSignal(this.syncPeerPresence(message.from, message.name, message.profile, message.turnAvailable), "candidate", message.rtcEpoch)
+    const existing = this.peers.get(message.from) ?? this.buildPeer(message.from, message.instanceId)
+    if (!this.acceptPeerInstance(existing, message.instanceId, message.kind)) return
+    const peer = this.syncPeerSignal(this.syncPeerPresence(existing, message.name, message.profile, message.turnAvailable), "candidate", message.rtcEpoch)
     if (!peer?.pc) return
     try {
       await peer.pc.addIceCandidate(message.candidate as RTCIceCandidateInit)

package/src/tui/app.ts

@@ -1,7 +1,7 @@
 import { rgb, ui, type BadgeVariant, type VNode } from "@rezi-ui/core"
 import { createNodeApp } from "@rezi-ui/node"
 import { inspectLocalFile } from "../core/files"
-import { SendSession, type PeerSnapshot, type SessionConfig, type SessionSnapshot, type TransferSnapshot } from "../core/session"
+import { isSessionAbortedError, SendSession, type PeerSnapshot, type SessionConfig, type SessionSnapshot, type TransferSnapshot } from "../core/session"
 import { cleanLocalId, cleanName, cleanRoom, displayPeerName, fallbackName, formatBytes, type LogEntry, peerDefaultsToken, type PeerProfile, uid } from "../core/protocol"
 import { FILE_SEARCH_VISIBLE_ROWS, type FileSearchEvent, type FileSearchMatch, type FileSearchRequest } from "./file-search-protocol"
 import { deriveFileSearchScope, formatFileSearchDisplayPath, normalizeSearchQuery, offsetFileSearchMatchIndices } from "./file-search"
@@ -43,6 +43,7 @@ export type VisiblePane = "peers" | "transfers" | "logs"
 export interface TuiState {
   session: SendSession
   sessionSeed: SessionSeed
+  peerSelectionByRoom: Map<string, Map<string, boolean>>
   snapshot: SessionSnapshot
   focusedId: string | null
   roomInput: string
@@ -75,6 +76,8 @@ export interface TuiActions {
   clearPeerSelection: TuiAction
   toggleHideTerminalPeers: TuiAction
   togglePeer: (peerId: string) => void
+  shareTurnWithPeer: (peerId: string) => void
+  shareTurnWithAllPeers: TuiAction
   toggleAutoOffer: TuiAction
   toggleAutoAccept: TuiAction
   toggleAutoSave: TuiAction
@@ -97,7 +100,13 @@ const NAME_INPUT_ID = "name-input"
 const DRAFT_INPUT_ID = "draft-input"
 const TRANSPARENT_BORDER_STYLE = { fg: rgb(7, 10, 12) } as const
 const METRIC_BORDER_STYLE = { fg: rgb(20, 25, 32) } as const
+const PRIMARY_TEXT_STYLE = { fg: rgb(255, 255, 255) } as const
+const HEADING_TEXT_STYLE = { fg: rgb(255, 255, 255), bold: true } as const
 const DEFAULT_WEB_URL = "https://send.rt.ht/"
+const TRANSFER_DIRECTION_ARROW = {
+  out: { glyph: "↗", style: { fg: rgb(170, 217, 76), bold: true } },
+  in: { glyph: "↙", style: { fg: rgb(240, 113, 120), bold: true } },
+} as const
 
 const countFormat = new Intl.NumberFormat(undefined, { maximumFractionDigits: 0 })
 const percentFormat = new Intl.NumberFormat(undefined, { maximumFractionDigits: 0 })
@@ -146,6 +155,8 @@ export const createNoopTuiActions = (): TuiActions => ({
   clearPeerSelection: noop,
   toggleHideTerminalPeers: noop,
   togglePeer: noop,
+  shareTurnWithPeer: noop,
+  shareTurnWithAllPeers: noop,
   toggleAutoOffer: noop,
   toggleAutoAccept: noop,
   toggleAutoSave: noop,
@@ -180,6 +191,20 @@ const peerConnectionStatusKind = (status: string) => ({
   idle: "unknown",
   new: "unknown",
 }[status] || "unknown") as "online" | "offline" | "away" | "busy" | "unknown"
+const transferStatusKind = (status: TransferSnapshot["status"]) => ({
+  complete: "online",
+  sending: "online",
+  receiving: "online",
+  "awaiting-done": "online",
+  accepted: "busy",
+  queued: "busy",
+  offered: "busy",
+  pending: "busy",
+  cancelling: "busy",
+  rejected: "offline",
+  cancelled: "offline",
+  error: "offline",
+}[status] || "unknown") as "online" | "offline" | "away" | "busy" | "unknown"
 const visiblePeers = (peers: PeerSnapshot[], hideTerminalPeers: boolean) => hideTerminalPeers ? peers.filter(peer => peer.presence === "active") : peers
 const transferProgress = (transfer: TransferSnapshot) => Math.max(0, Math.min(1, transfer.progress / 100))
 const isPendingOffer = (transfer: TransferSnapshot) => transfer.direction === "out" && (transfer.status === "queued" || transfer.status === "offered")
@@ -298,8 +323,19 @@ const normalizeSessionSeed = (config: SessionConfig): SessionSeed => ({
   room: cleanRoom(config.room),
 })
 
-const makeSession = (seed: SessionSeed, autoAcceptIncoming: boolean, autoSaveIncoming: boolean) => new SendSession({
+const roomPeerSelectionMemory = (peerSelectionByRoom: Map<string, Map<string, boolean>>, room: string) => {
+  const roomKey = cleanRoom(room)
+  let selectionMemory = peerSelectionByRoom.get(roomKey)
+  if (!selectionMemory) {
+    selectionMemory = new Map<string, boolean>()
+    peerSelectionByRoom.set(roomKey, selectionMemory)
+  }
+  return selectionMemory
+}
+
+const makeSession = (seed: SessionSeed, autoAcceptIncoming: boolean, autoSaveIncoming: boolean, peerSelectionMemory: Map<string, boolean>) => new SendSession({
   ...seed,
+  peerSelectionMemory,
   autoAcceptIncoming,
   autoSaveIncoming,
 })
@@ -435,11 +471,13 @@ export const createInitialTuiState = (initialConfig: SessionConfig, showEvents =
   const sessionSeed = normalizeSessionSeed(initialConfig)
   const autoAcceptIncoming = initialConfig.autoAcceptIncoming ?? true
   const autoSaveIncoming = initialConfig.autoSaveIncoming ?? true
-  const session = makeSession(sessionSeed, autoAcceptIncoming, autoSaveIncoming)
+  const peerSelectionByRoom = new Map<string, Map<string, boolean>>()
+  const session = makeSession(sessionSeed, autoAcceptIncoming, autoSaveIncoming, roomPeerSelectionMemory(peerSelectionByRoom, sessionSeed.room))
   const focusState = deriveBootFocusState(sessionSeed.name)
   return {
     session,
     sessionSeed,
+    peerSelectionByRoom,
     snapshot: session.snapshot(),
     focusedId: null,
     roomInput: sessionSeed.room,
@@ -487,6 +525,32 @@ const ghostButton = (id: string, label: string, onPress?: TuiAction, options: {
   dsVariant: "ghost",
 })
 
+const TEXT_BUTTON_FOCUS_CONFIG = { indicator: "none", showHint: false } as const
+
+const textButton = (id: string, label: string, onPress?: TuiAction, options: { focusable?: boolean; accessibleLabel?: string } = {}) => ui.button({
+  id,
+  label,
+  ...(onPress === undefined ? {} : { onPress }),
+  ...(options.focusable === undefined ? {} : { focusable: options.focusable }),
+  ...(options.accessibleLabel === undefined ? {} : { accessibleLabel: options.accessibleLabel }),
+  px: 0,
+  dsVariant: "ghost",
+  style: PRIMARY_TEXT_STYLE,
+  focusConfig: TEXT_BUTTON_FOCUS_CONFIG,
+})
+
+const headingTextButton = (id: string, label: string, onPress?: TuiAction, options: { focusable?: boolean; accessibleLabel?: string } = {}) => ui.button({
+  id,
+  label,
+  ...(onPress === undefined ? {} : { onPress }),
+  ...(options.focusable === undefined ? {} : { focusable: options.focusable }),
+  ...(options.accessibleLabel === undefined ? {} : { accessibleLabel: options.accessibleLabel }),
+  px: 0,
+  dsVariant: "ghost",
+  style: HEADING_TEXT_STYLE,
+  focusConfig: TEXT_BUTTON_FOCUS_CONFIG,
+})
+
 const denseSection = (options: DenseSectionOptions, children: readonly DenseSectionChild[]) => ui.box({
   ...(options.id === undefined ? {} : { id: options.id }),
   ...(options.key === undefined ? {} : { key: options.key }),
@@ -588,7 +652,7 @@ const renderSelfCard = (state: TuiState, actions: TuiActions) => denseSection({
   ]),
 ])
 
-const renderPeerRow = (peer: PeerSnapshot, actions: TuiActions) => denseSection({
+const renderPeerRow = (peer: PeerSnapshot, turnShareEnabled: boolean, actions: TuiActions) => denseSection({
   id: `peer-row-${peer.id}`,
   key: peer.id,
 }, [
@@ -607,9 +671,9 @@ const renderPeerRow = (peer: PeerSnapshot, actions: TuiActions) => denseSection(
         }),
       ]),
       ui.box({ id: `peer-name-slot-${peer.id}`, flex: 1, minWidth: 0, border: "none" }, [
-        ui.text(peer.displayName, {
-          id: `peer-name-text-${peer.id}`,
-          textOverflow: "ellipsis",
+        textButton(`peer-share-turn-${peer.id}`, peer.displayName, turnShareEnabled && peer.presence === "active" ? () => actions.shareTurnWithPeer(peer.id) : undefined, {
+          focusable: turnShareEnabled && peer.presence === "active",
+          accessibleLabel: `share TURN with ${peer.displayName}`,
         }),
       ]),
       ui.row({ id: `peer-status-cluster-${peer.id}`, gap: 1, items: "center" }, [
@@ -639,9 +703,16 @@ const renderPeersCard = (state: TuiState, actions: TuiActions) => {
   const peers = visiblePeers(state.snapshot.peers, state.hideTerminalPeers)
   const activeCount = state.snapshot.peers.filter(peer => peer.presence === "active").length
   const selectedCount = state.snapshot.peers.filter(peer => peer.selectable && peer.selected).length
+  const canShareTurn = state.session.canShareTurn()
   return denseSection({
     id: "peers-card",
-    title: `Peers ${selectedCount}/${activeCount}`,
+    titleNode: ui.row({ id: "peers-title-row", gap: 1, items: "center" }, [
+      headingTextButton("share-turn-all-peers", "Peers", canShareTurn && !!activeCount ? actions.shareTurnWithAllPeers : undefined, {
+        focusable: canShareTurn && !!activeCount,
+        accessibleLabel: "share TURN with all active peers",
+      }),
+      ui.text(`${selectedCount}/${activeCount}`, { id: "peers-count-text", variant: "heading" }),
+    ]),
     flex: 1,
     actions: [
       actionButton("select-ready-peers", "All", actions.toggleSelectReadyPeers),
@@ -651,7 +722,7 @@ const renderPeersCard = (state: TuiState, actions: TuiActions) => {
   }, [
     ui.box({ id: "peers-list", flex: 1, minHeight: 0, overflow: "scroll", border: "none" }, [
       peers.length
-        ? ui.column({ gap: 0 }, peers.map(peer => renderPeerRow(peer, actions)))
+        ? ui.column({ gap: 0 }, peers.map(peer => renderPeerRow(peer, canShareTurn, actions)))
         : ui.empty(`Waiting for peers in ${state.snapshot.room}...`),
     ]),
   ])
@@ -755,6 +826,7 @@ const transferPathLabel = (transfer: TransferSnapshot, peersById: Map<string, Pe
 
 const renderTransferRow = (transfer: TransferSnapshot, peersById: Map<string, PeerSnapshot>, actions: TuiActions, now = Date.now()) => {
   const hasStarted = !!transfer.startedAt
+  const directionArrow = TRANSFER_DIRECTION_ARROW[transfer.direction]
   const facts = [
     renderTransferFact("Size", formatBytes(transfer.size)),
     renderTransferFact("Path", transferPathLabel(transfer, peersById)),
@@ -767,13 +839,18 @@ const renderTransferRow = (transfer: TransferSnapshot, peersById: Map<string, Pe
 
   return denseSection({
     key: transfer.id,
-    title: `${transfer.direction === "out" ? "→" : "←"} ${transfer.name}`,
+    titleNode: ui.row({ id: `transfer-title-row-${transfer.id}`, gap: 1, items: "center", wrap: true }, [
+      ui.row({ id: `transfer-title-main-${transfer.id}`, gap: 0, items: "center", wrap: true }, [
+        ui.text(directionArrow.glyph, { style: directionArrow.style }),
+        ui.text(` ${transfer.name}`, { variant: "heading" }),
+      ]),
+      ui.row({ id: `transfer-badges-${transfer.id}`, gap: 1, items: "center", wrap: true }, [
+        ui.status(transferStatusKind(transfer.status), { label: transfer.status, showLabel: true }),
+        transfer.error ? tightTag("error", { variant: "error", bare: true }) : null,
+      ]),
+    ]),
     actions: transferActionButtons(transfer, actions),
   }, [
-    ui.row({ gap: 1, wrap: true }, [
-      tightTag(transfer.status, { variant: statusVariant(transfer.status), bare: true }),
-      transfer.error ? tightTag("error", { variant: "error", bare: true }) : null,
-    ]),
     ui.row({ gap: 0, wrap: true }, facts),
     ui.progress(transferProgress(transfer), { showPercent: true, label: `${percentFormat.format(transfer.progress)}%` }),
     ui.row({ gap: 0, wrap: true }, [
@@ -987,7 +1064,11 @@ export const startTui = async (initialConfig: SessionConfig, showEvents = false)
   const requestStop = () => {
     if (stopping) return
     stopping = true
-    void app.stop()
+    try {
+      process.kill(process.pid, "SIGINT")
+    } catch {
+      void app.stop()
+    }
   }
 
   const resetFilePreview = (overrides: Partial<FilePreviewState> = {}): FilePreviewState => ({
@@ -1181,19 +1262,20 @@ export const startTui = async (initialConfig: SessionConfig, showEvents = false)
     })
     commit(current => current.session === session ? { ...current, snapshot: session.snapshot() } : current)
     void session.connect().catch(error => {
-      if (state.session !== session) return
+      if (state.session !== session || stopping || cleanedUp || isSessionAbortedError(error)) return
       commit(current => withNotice(current, { text: `${error}`, variant: "error" }))
     })
   }
 
   const replaceSession = (nextSeed: SessionSeed, text: string, options: { reseedBootFocus?: boolean } = {}) => {
     const previousSession = state.session
-    const nextSession = makeSession(nextSeed, state.autoAcceptIncoming, state.autoSaveIncoming)
+    const nextSession = makeSession(nextSeed, state.autoAcceptIncoming, state.autoSaveIncoming, roomPeerSelectionMemory(state.peerSelectionByRoom, nextSeed.room))
     stopPreviewSession()
     commit(current => withNotice({
       ...current,
       session: nextSession,
       sessionSeed: nextSeed,
+      peerSelectionByRoom: current.peerSelectionByRoom,
       snapshot: nextSession.snapshot(),
       roomInput: nextSeed.room,
       nameInput: visibleNameInput(nextSeed.name),
@@ -1270,7 +1352,7 @@ export const startTui = async (initialConfig: SessionConfig, showEvents = false)
     setNameInput: value => commit(current => ({ ...current, nameInput: value })),
     toggleSelectReadyPeers: () => {
       let changed = 0
-      for (const peer of state.snapshot.peers) if (peer.presence === "active" && state.session.setPeerSelected(peer.id, peer.ready)) changed += 1
+      for (const peer of state.snapshot.peers) if (state.session.setPeerSelected(peer.id, peer.presence === "active" && peer.ready)) changed += 1
       commit(current => withNotice(current, { text: changed ? "Selected ready peers." : "No ready peers to select.", variant: changed ? "success" : "info" }))
       maybeOfferDrafts()
     },
@@ -1284,6 +1366,29 @@ export const startTui = async (initialConfig: SessionConfig, showEvents = false)
       state.session.togglePeerSelection(peerId)
       maybeOfferDrafts()
     },
+    shareTurnWithPeer: peerId => {
+      const peer = state.snapshot.peers.find(item => item.id === peerId)
+      const sent = state.session.shareTurnWithPeer(peerId)
+      commit(current => withNotice(current, {
+        text: !state.session.canShareTurn()
+          ? "TURN is not configured."
+          : sent
+            ? `Shared TURN with ${peer?.displayName ?? peerId}.`
+            : `Unable to share TURN with ${peer?.displayName ?? peerId}.`,
+        variant: !state.session.canShareTurn() ? "info" : sent ? "success" : "warning",
+      }))
+    },
+    shareTurnWithAllPeers: () => {
+      const shared = state.session.shareTurnWithAllPeers()
+      commit(current => withNotice(current, {
+        text: !state.session.canShareTurn()
+          ? "TURN is not configured."
+          : shared
+            ? `Shared TURN with ${plural(shared, "active peer")}.`
+            : "No active peers to share TURN with.",
+        variant: !state.session.canShareTurn() ? "info" : shared ? "success" : "info",
+      }))
+    },
     toggleAutoOffer: () => {
       commit(current => withNotice({ ...current, autoOfferOutgoing: !current.autoOfferOutgoing }, { text: !state.autoOfferOutgoing ? "Auto-offer on." : "Auto-offer off.", variant: !state.autoOfferOutgoing ? "success" : "warning" }))
       maybeOfferDrafts()
@@ -1461,17 +1566,14 @@ export const startTui = async (initialConfig: SessionConfig, showEvents = false)
     await state.session.close()
   }
 
-  const onSignal = () => requestStop()
-  process.once("SIGINT", onSignal)
-  process.once("SIGTERM", onSignal)
-
   try {
     bindSession(state.session)
     await app.run()
   } finally {
-    process.off("SIGINT", onSignal)
-    process.off("SIGTERM", onSignal)
-    await stop()
-    app.dispose()
+    try {
+      await stop()
+    } finally {
+      app.dispose()
+    }
   }
 }