Skip to content

Send files directly between devices over the internet - no cloud storage, no size limits.

5.7 KB
Raw Blame
import b4a from 'b4a'
import type { TransferOffer, PeerControlMessage } from '../transfer/control-channel'
import type { RememberedPeer } from '../peers/remembered-peer'
import type { DeviceSecretInit } from '../identity/device-identity-store'
import type {
  ErrorEvent,
  InviteReceivedEvent,
  InviteResponseReceivedEvent,
  PairingPeerConnectedEvent,
  ReadyEvent,
  RememberConfirmedEvent,
  RememberDeclinedEvent,
  RememberRequestedEvent,
  RoleEvent,
  StatusEvent,
  TransferErrorCode,
  TransferRole
} from './events'
import { API, API_BY_VALUE } from './commands'
import type { TransferMethod } from './commands'

export { API, API_BY_VALUE }
export type { TransferErrorCode, TransferRole, TransferMethod }
export type { DeviceSecretInit }

export interface DownloadFileRequest {
  transferId: string
  fileId: string
  path: string
  name?: string
  size?: number
  targetDir?: string
  targetPath?: string
  overwrite?: boolean
}

export interface HostReply {
  topic: string
}

export interface JoinReply {
  state: 'joined'
}

export interface ShareFileRequest {
  path: string
  name?: string
  relativePath?: string
  isTemporary?: boolean
  kind?: 'file' | 'text'
  content?: string
}

export interface ShareFilesReply {
  acceptedFiles: number
}

export interface DownloadFileResult {
  fileId?: string
  fileName: string
  ok: boolean
  savedTo?: string
  message?: string
}

export interface DownloadFilesReply {
  files: DownloadFileResult[]
}

export interface DisconnectReply {
  state: 'disconnected'
}

export interface RememberVoteInput {
  transferId: string
  peerKey: string
  vote: 'remember' | 'no'
  isMine: boolean
}

export interface RememberVoteReply {
  ok: true
}

export interface InviteDeviceInput {
  remoteDevicePubkey: string
  topic: string
  fileCount?: number
  textCount?: number
  totalSize?: number
}

export interface InviteDeviceReply {
  delivered: boolean
}

export interface InviteResponseInput {
  remoteDevicePubkey: string
  topic: string
  response: 'declined'
}

export interface InviteResponseReply {
  delivered: boolean
}

export interface RenamePeerInput {
  remoteDevicePubkey: string
  displayName: string
}

export interface InitDeviceSecretReply {
  secretKey: string | null
}

export type CustomRelayInput =
  | { kind: 'relay'; keyHex: string; host: string }
  | { kind: 'org'; keyHex: string }

export interface SetRelayConfigInput {
  enabled: boolean
  proToken?: string | null
  customRelay?: CustomRelayInput | null
  customRelayFallback?: boolean
}

export interface SetRelayConfigReply {
  enabled: boolean
  keyCount: number
}

export interface TestCustomRelayReply {
  ok: boolean
  ms?: number
}

export interface RPCErrorPayload {
  code: 'BAD_REQUEST' | 'UNKNOWN_COMMAND' | 'INTERNAL_ERROR'
  message: string
  transferErrorCode?: TransferErrorCode
}

interface RPCSuccessPayload<T> {
  ok: true
  data: T
}

interface RPCErrorResponse {
  ok: false
  error: RPCErrorPayload
}

export type RPCResponse<T> = RPCSuccessPayload<T> | RPCErrorResponse

type WorkerReadyEvent = ReadyEvent
export type RendererTransferEvent =
  | StatusEvent
  | ErrorEvent
  | RoleEvent
  | RememberConfirmedEvent
  | RememberDeclinedEvent
  | RememberRequestedEvent
  | InviteReceivedEvent
  | InviteResponseReceivedEvent
  | PairingPeerConnectedEvent
  | PeerControlMessage
export type WorkerTransferEvent = WorkerReadyEvent | RendererTransferEvent
export type IncomingFileOffer = TransferOffer

export interface TransferRPC {
  host(): Promise<HostReply>
  join(topic: string): Promise<JoinReply>
  shareFiles(files: ShareFileRequest[]): Promise<ShareFilesReply>

  downloadFiles(files: DownloadFileRequest[]): Promise<DownloadFilesReply>
  pauseDownload(fileId: string): Promise<void>
  disconnect(): Promise<DisconnectReply>
  closePeers(): Promise<void>
  rememberVote(input: RememberVoteInput): Promise<RememberVoteReply>
  peersList(): Promise<RememberedPeer[]>
  inviteDevice(input: InviteDeviceInput): Promise<InviteDeviceReply>
  respondToInvite(input: InviteResponseInput): Promise<InviteResponseReply>
  forgetPeer(pubkey: string): Promise<void>
  renamePeer(input: RenamePeerInput): Promise<RememberedPeer | null>
  initDeviceSecret(init: DeviceSecretInit): Promise<InitDeviceSecretReply>
  hostPairing(): Promise<HostReply>
  joinPairing(topic: string): Promise<JoinReply>
  setRelayConfig(input: SetRelayConfigInput): Promise<SetRelayConfigReply>
  testCustomRelay(): Promise<TestCustomRelayReply>
}

export class BadRequestError extends Error {
  transferErrorCode?: TransferErrorCode

  constructor(message: string, transferErrorCode?: TransferErrorCode) {
    super(message)
    this.name = 'BadRequestError'
    this.transferErrorCode = transferErrorCode
  }
}

export function encodeRPCPayload(value: unknown): string {
  return JSON.stringify(value ?? null)
}

export function decodeRPCPayload<T>(data: Uint8Array | ArrayBuffer | string | null): T | null {
  if (!data) return null

  let source: string
  if (typeof data === 'string') {
    source = data
  } else {
    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data)
    if (bytes.byteLength === 0) return null
    source = b4a.toString(bytes, 'utf8')
  }
  if (source.length === 0) return null

  try {
    return JSON.parse(source) as T
  } catch (err) {
    console.warn('decodeRPCPayload: malformed JSON payload', err)
    return null
  }
}

export function encodeRPCSuccess<T>(value: T): string {
  return encodeRPCPayload({
    ok: true,
    data: value
  })
}

export function encodeRPCError(
  message: string,
  code: RPCErrorPayload['code'] = 'INTERNAL_ERROR',
  transferErrorCode?: TransferErrorCode
): string {
  return encodeRPCPayload({
    ok: false,
    error: {
      code,
      message,
      ...(transferErrorCode ? { transferErrorCode } : {})
    }
  })
}