Send files directly between devices over the internet - no cloud storage, no size limits.
TypeScript cross-platformdata-transferdecentralizedfile-sharingfile-transferhole-punchingopen-sourcep2ppeer-to-peerprivacyprivacy-tools
import {
applyDownloadMessage,
applyDownloadRouted,
createDownloadStateMap,
markDownloadsQueued,
resolveOfferKey
} from '../receive/downloadModel'
import { applySharingProgress, getPhaseFromSelection, mergeSelectedFiles } from '../send/draftModel'
import { applyPeerDownloadEvent } from '../send/shareModel'
import { TRANSFER_ERROR_CODES } from './types'
import type {
ConnectionState,
IncomingPairRequest,
TransferAction,
TransferConnectionType,
TransferSessionState
} from './types'
function clearIncomingFor(
incoming: IncomingPairRequest | null,
peerKey: string
): IncomingPairRequest | null {
return incoming?.peerKey === peerKey ? null : incoming
}
export { TRANSFER_ERROR_CODES } from './types'
export const initialTransferSessionState: TransferSessionState = {
topic: '',
connectionState: 'disconnected',
connectionType: null,
connectionTypes: {},
relayBusy: false,
webPeers: {},
outdatedPeers: {},
transferPeerKey: null,
role: null,
peerCount: 0,
isReconnecting: false,
reconnectExhausted: false,
sessionEndedByPeer: false,
incomingFileOffers: [],
receiveDownloadStates: {},
selectedFiles: [],
draftPhase: 'empty',
uploadItems: [],
peerDownloads: {},
connectedPeers: {},
errorCode: null,
errorMessage: null,
transferId: null,
remember: {
pairStatus: {},
peerDisplayNames: {},
incomingRequest: null,
incomingInvite: null,
inviteResponses: {}
},
peers: []
}
function deriveConnectionType(
connectionTypes: Record<string, TransferConnectionType>,
transferPeerKey: string | null
): TransferConnectionType | null {
return transferPeerKey ? (connectionTypes[transferPeerKey] ?? null) : null
}
function clearError(state: TransferSessionState): TransferSessionState {
return state.errorCode === null && state.errorMessage === null
? state
: { ...state, errorCode: null, errorMessage: null }
}
function flagPeer(
state: TransferSessionState,
field: 'webPeers' | 'outdatedPeers',
peer: string
): TransferSessionState {
if (state.role !== 'sender' || state[field][peer]) return state
return { ...state, [field]: { ...state[field], [peer]: true } }
}
function unflagPeer(
state: TransferSessionState,
field: 'webPeers' | 'outdatedPeers',
peer: string
): TransferSessionState {
if (!state[field][peer]) return state
const next = { ...state[field] }
delete next[peer]
return { ...state, [field]: next }
}
function mergeIncomingFileOffers(
current: TransferSessionState['incomingFileOffers'],
nextFiles: TransferSessionState['incomingFileOffers']
) {
const existingIds = new Set(current.map((offer) => offer.id))
const uniqueNextFiles = nextFiles.filter((offer) => !existingIds.has(offer.id))
return uniqueNextFiles.length > 0 ? [...current, ...uniqueNextFiles] : current
}
function endSession(state: TransferSessionState): TransferSessionState {
return {
...state,
role: null,
isReconnecting: false,
reconnectExhausted: false,
sessionEndedByPeer: false,
incomingFileOffers: [],
receiveDownloadStates: {},
selectedFiles: [],
draftPhase: 'empty',
uploadItems: [],
peerDownloads: {},
connectedPeers: {},
connectionState: 'disconnected',
connectionType: null,
connectionTypes: {},
relayBusy: false,
webPeers: {},
outdatedPeers: {},
transferPeerKey: null,
peerCount: 0,
topic: '',
errorCode: null,
errorMessage: null,
transferId: null,
remember: {
pairStatus: {},
peerDisplayNames: {},
incomingRequest: null,
incomingInvite: null,
inviteResponses: {}
}
}
}
export function transferSessionReducer(
state: TransferSessionState,
action: TransferAction
): TransferSessionState {
switch (action.type) {
// ─── Lifecycle ────────────────────────────────────────────────
case 'booted':
return clearError(state)
case 'boot_failed':
return {
...state,
errorCode: action.code ?? TRANSFER_ERROR_CODES.transferFailed,
errorMessage: action.message
}
// ─── Connection ───────────────────────────────────────────────
case 'status_changed':
switch (action.state) {
case 'disconnected':
return endSession(state)
case 'joining':
return { ...state, connectionState: 'joining', errorCode: null, errorMessage: null }
case 'joined': {
const peerCount = typeof action.peers === 'number' ? action.peers : state.peerCount
const resolved: ConnectionState = peerCount > 0 ? 'peer-connected' : 'joined'
return {
...state,
connectionState: resolved,
peerCount,
errorCode: null,
errorMessage: null
}
}
case 'peer-connected': {
const peerCount = action.peers ?? 1
return {
...state,
connectionState: 'peer-connected',
peerCount,
isReconnecting: false,
relayBusy: false,
errorCode: null,
errorMessage: null
}
}
}
case 'connection_type_changed': {
if (state.connectionTypes[action.peer] === action.connectionType) return state
const connectionTypes = { ...state.connectionTypes, [action.peer]: action.connectionType }
return {
...state,
connectionTypes,
connectionType: deriveConnectionType(connectionTypes, state.transferPeerKey)
}
}
case 'relay_busy':
if (state.role !== 'receiver' || state.relayBusy) return state
return { ...state, relayBusy: true }
case 'peer_client_changed':
return flagPeer(state, 'webPeers', action.peer)
case 'peer_outdated':
return flagPeer(state, 'outdatedPeers', action.peer)
case 'peer_authenticated':
return unflagPeer(state, 'outdatedPeers', action.peer)
case 'reconnecting':
return { ...state, isReconnecting: true }
case 'peer_session_ended': {
if (state.role !== 'receiver') return state
const fromTransferPeer = !!state.transferPeerKey && action.peerKey === state.transferPeerKey
if (!fromTransferPeer) return state
return { ...state, isReconnecting: false, sessionEndedByPeer: true }
}
case 'clear_session':
return endSession(state)
case 'join_failed':
return {
...state,
role: null,
isReconnecting: false,
connectionState: 'disconnected',
peerCount: 0,
receiveDownloadStates: {},
uploadItems: [],
peerDownloads: {},
connectedPeers: {},
errorCode: action.code ?? TRANSFER_ERROR_CODES.joinFailed,
errorMessage: action.message
}
// ─── Send flow ────────────────────────────────────────────────
case 'share_requested':
return {
...state,
role: 'sender',
peerDownloads: {},
connectedPeers: {},
errorCode: null,
errorMessage: null
}
case 'session_hosted':
return { ...state, topic: action.topic }
case 'add_selected_files': {
if (action.files.length === 0) return state
const next = mergeSelectedFiles(state.selectedFiles, action.files)
return {
...state,
selectedFiles: next,
draftPhase: getPhaseFromSelection(next.length),
uploadItems: []
}
}
case 'remove_selected_file': {
const next = state.selectedFiles.filter((f) => f.path !== action.path)
if (next.length === state.selectedFiles.length) return state
return { ...state, selectedFiles: next, draftPhase: getPhaseFromSelection(next.length) }
}
case 'set_draft_phase':
return state.draftPhase === action.phase ? state : { ...state, draftPhase: action.phase }
case 'clear_send_draft':
return { ...state, selectedFiles: [], draftPhase: 'empty', uploadItems: [] }
case 'init_upload_items':
return { ...state, uploadItems: action.items }
case 'complete_all_uploads':
return {
...state,
uploadItems: state.uploadItems.map((i) =>
i.status === 'completed' ? i : { ...i, status: 'completed' }
)
}
case 'reset_uploading_items':
return {
...state,
uploadItems: state.uploadItems.map((i) =>
i.status === 'uploading' ? { ...i, status: 'waiting' } : i
)
}
case 'apply_sharing_progress':
if (state.role !== 'sender') return state
return {
...state,
uploadItems: applySharingProgress(state.uploadItems, action.event),
transferId: action.event.transferId ?? state.transferId,
errorCode: null,
errorMessage: null
}
case 'peer_download_event':
if (state.role !== 'sender') return state
return {
...state,
peerDownloads: applyPeerDownloadEvent(state.peerDownloads, action.event)
}
case 'peer_joined': {
if (state.role !== 'sender') return state
return {
...state,
connectedPeers: {
...state.connectedPeers,
[action.peerKey]: { peerKey: action.peerKey, connectedAt: Date.now() }
}
}
}
case 'peer_left': {
if (state.role !== 'sender') return state
const existing = state.connectedPeers[action.peerKey]
if (!existing || existing.disconnectedAt) return state
return {
...state,
connectedPeers: {
...state.connectedPeers,
[action.peerKey]: { ...existing, disconnectedAt: Date.now() }
}
}
}
// ─── Receive flow ─────────────────────────────────────────────
case 'join_requested':
return {
...state,
role: 'receiver',
isReconnecting: false,
reconnectExhausted: false,
sessionEndedByPeer: false,
incomingFileOffers: [],
receiveDownloadStates: {},
selectedFiles: [],
draftPhase: 'empty',
uploadItems: [],
peerDownloads: {},
connectedPeers: {},
connectionState: 'joining',
connectionType: null,
connectionTypes: {},
relayBusy: false,
webPeers: {},
outdatedPeers: {},
transferPeerKey: null,
peerCount: 0,
errorCode: null,
errorMessage: null
}
case 'transfer_ready': {
if (state.role !== 'receiver') return state
const incomingFileOffers = mergeIncomingFileOffers(state.incomingFileOffers, action.files)
const transferPeerKey = action.peer ?? state.transferPeerKey
return {
...state,
isReconnecting: false,
reconnectExhausted: false,
sessionEndedByPeer: false,
incomingFileOffers,
receiveDownloadStates: createDownloadStateMap(
state.receiveDownloadStates,
incomingFileOffers
),
transferPeerKey,
connectionType: deriveConnectionType(state.connectionTypes, transferPeerKey),
relayBusy: false,
transferId: action.files[0]?.transferId ?? state.transferId,
errorCode: null,
errorMessage: null
}
}
case 'receive_download_event': {
if (state.role !== 'receiver') return state
const offerKey = resolveOfferKey(state.incomingFileOffers, action.event)
if (!offerKey) return state
const nextDownloadStates = applyDownloadMessage(
state.receiveDownloadStates,
offerKey,
action.event
)
if (
action.event.state === 'download-failed' &&
action.event.resumable !== true &&
action.event.cancelled !== true
) {
return {
...state,
receiveDownloadStates: nextDownloadStates,
errorCode: TRANSFER_ERROR_CODES.downloadFailed,
errorMessage: action.event.message ?? state.errorMessage
}
}
return {
...state,
receiveDownloadStates: nextDownloadStates
}
}
case 'downloads_queued': {
if (state.role !== 'receiver') return state
return {
...state,
receiveDownloadStates: markDownloadsQueued(
state.receiveDownloadStates,
action.offerKeys,
action.queued
)
}
}
case 'downloads_retries_exhausted': {
if (state.role !== 'receiver') return state
const next = { ...state.receiveDownloadStates }
for (const key of action.offerKeys) {
const previous = next[key]
if (!previous) continue
next[key] = { ...previous, retriesExhausted: true }
}
return { ...state, receiveDownloadStates: next }
}
case 'download_routed':
if (state.role !== 'receiver') return state
return {
...state,
receiveDownloadStates: applyDownloadRouted(state.receiveDownloadStates, action.offerKey, {
destination: action.destination,
intendedDestination: action.intendedDestination,
savedTo: action.savedTo
})
}
case 'peer_unreachable':
if (state.incomingFileOffers.length > 0) {
return { ...state, isReconnecting: false, reconnectExhausted: true }
}
return {
...state,
role: null,
connectionState: 'disconnected',
peerCount: 0,
isReconnecting: false,
topic: '',
connectedPeers: {},
relayBusy: false,
errorCode: state.relayBusy
? TRANSFER_ERROR_CODES.relayBusy
: TRANSFER_ERROR_CODES.peerUnreachable,
errorMessage: null
}
// ─── Misc ─────────────────────────────────────────────────────
case 'role_changed':
return {
...state,
role: action.role,
...(action.role === null
? {
incomingFileOffers: [],
receiveDownloadStates: {},
selectedFiles: [],
draftPhase: 'empty' as const,
uploadItems: [],
peerDownloads: {},
connectedPeers: {}
}
: {})
}
case 'set_error':
return {
...state,
errorCode: action.code ?? TRANSFER_ERROR_CODES.transferFailed,
errorMessage: action.message
}
case 'remember_confirmed':
return {
...state,
remember: {
...state.remember,
pairStatus: { ...state.remember.pairStatus, [action.peerKey]: 'paired' },
peerDisplayNames: {
...state.remember.peerDisplayNames,
[action.peerKey]: action.displayName
},
incomingRequest: clearIncomingFor(state.remember.incomingRequest, action.peerKey)
}
}
case 'remember_declined': {
const pairStatus = { ...state.remember.pairStatus }
delete pairStatus[action.peerKey]
const peerDisplayNames = { ...state.remember.peerDisplayNames }
delete peerDisplayNames[action.peerKey]
return {
...state,
remember: {
...state.remember,
pairStatus,
peerDisplayNames,
incomingRequest: clearIncomingFor(state.remember.incomingRequest, action.peerKey)
}
}
}
case 'remember_requested':
return { ...state, remember: { ...state.remember, incomingRequest: action.request } }
case 'set_peers':
return { ...state, peers: action.peers }
case 'forget_peer': {
const key = action.peerKey.toLowerCase()
const peers = state.peers.filter((peer) => peer.remoteDevicePubkey.toLowerCase() !== key)
const pairStatus = { ...state.remember.pairStatus }
delete pairStatus[action.peerKey]
delete pairStatus[key]
const peerDisplayNames = { ...state.remember.peerDisplayNames }
delete peerDisplayNames[action.peerKey]
delete peerDisplayNames[key]
const inviteResponses = { ...state.remember.inviteResponses }
delete inviteResponses[action.peerKey]
delete inviteResponses[key]
return {
...state,
peers,
remember: {
...state.remember,
pairStatus,
peerDisplayNames,
inviteResponses,
incomingRequest: clearIncomingFor(state.remember.incomingRequest, action.peerKey),
incomingInvite:
state.remember.incomingInvite?.remoteDevicePubkey.toLowerCase() === key
? null
: state.remember.incomingInvite
}
}
}
case 'rename_peer': {
const key = action.peerKey.toLowerCase()
const peers = state.peers.map((peer) => {
if (peer.remoteDevicePubkey.toLowerCase() !== key) return peer
return { ...peer, displayName: action.displayName }
})
const peerDisplayNames = { ...state.remember.peerDisplayNames }
for (const cachedKey of Object.keys(peerDisplayNames)) {
if (cachedKey.toLowerCase() === key) peerDisplayNames[cachedKey] = action.displayName
}
const invite = state.remember.incomingInvite
const incomingInvite =
invite?.remoteDevicePubkey.toLowerCase() === key
? { ...invite, displayName: action.displayName }
: invite
return {
...state,
peers,
remember: { ...state.remember, peerDisplayNames, incomingInvite }
}
}
case 'invite_received':
return { ...state, remember: { ...state.remember, incomingInvite: action.invite } }
case 'invite_response_received':
return {
...state,
remember: {
...state.remember,
inviteResponses: {
...state.remember.inviteResponses,
[action.response.remoteDevicePubkey]: action.response
}
}
}
case 'dismiss_invite':
return { ...state, remember: { ...state.remember, incomingInvite: null } }
case 'request_pair_peer':
if (state.remember.pairStatus[action.peerKey] === 'paired') return state
return {
...state,
remember: {
...state.remember,
pairStatus: { ...state.remember.pairStatus, [action.peerKey]: 'requested' }
}
}
default: {
const exhaustiveCheck: never = action
return exhaustiveCheck
}
}
}