@honeybbq/teamspeak-client 1.0.0-beta.2 → 1.0.0-beta.4

package/src/trace.ts

@@ -0,0 +1,238 @@
+import type { ChannelID, ClientID } from "@honeybbq/teamspeak-core";
+import type { ServerCapabilities } from "./capabilities.js";
+import type { ResolvedAddr } from "./types.js";
+
+/** The values of the table below, before freezing. */
+const connectPhaseValues = {
+  /** Opening the socket, or the address was not usable once resolved. */
+  Open: "open",
+  /** The handshake, from the first packet until the shared secret exists. */
+  Handshake: "handshake",
+  /** After the handshake, waiting for the server to accept the client: a wrong password, a ban or an invalid nickname end here. */
+  Join: "join",
+} as const;
+/** Where a connection attempt can fail; see {@link AttemptFailedInfo}. */
+export const ConnectPhase: typeof connectPhaseValues =
+  /* @__PURE__ */ Object.freeze(connectPhaseValues);
+/**
+ * One of {@link ConnectPhase}. May gain members in a minor release: a
+ * `switch` over it needs a default case.
+ */
+export type ConnectPhase = (typeof ConnectPhase)[keyof typeof ConnectPhase];
+
+/** What every milestone of one connection attempt says about the attempt. */
+interface AttemptInfo {
+  /**
+   * The attempt's number, from 1. The attempt `connect()` starts is 1; a
+   * reconnection attempt carries the retry number the reconnect policy uses,
+   * the one `shouldRetry` and the backoff see.
+   */
+  readonly attempt: number;
+  /** Whether the reconnect loop started this attempt rather than a call to `connect()`. */
+  readonly reconnect: boolean;
+}
+
+/** The address is about to be resolved. */
+export interface ResolveStartInfo extends AttemptInfo {
+  /** The address as the client was given it. */
+  readonly addr: string;
+}
+
+/** The address has been resolved, or the lookup failed and the address is used as given. */
+export interface ResolveDoneInfo extends AttemptInfo {
+  /** The address as the client was given it. */
+  readonly addr: string;
+  /** The `host:port` that will be dialled. */
+  readonly target: string;
+  /** What the resolver reports as the source of the answer dialled; may be empty. */
+  readonly source: string;
+  /** Every answer the resolver gave, in order; empty when the address is used as given. */
+  readonly candidates: readonly ResolvedAddr[];
+  /** Why the lookup failed, when the address is used as given; `undefined` otherwise. */
+  readonly error: unknown;
+  /** How long the resolution took, in milliseconds. */
+  readonly durationMs: number;
+}
+
+/** The socket is about to be opened. */
+export interface ConnectStartInfo extends AttemptInfo {
+  /** The `host:port` being dialled. */
+  readonly target: string;
+}
+
+/** The socket is open; the first handshake packet has not been sent yet. */
+export interface ConnectDoneInfo extends AttemptInfo {
+  /** The `host:port` being dialled. */
+  readonly target: string;
+  /** The local socket's `host:port`; empty when the socket does not say. */
+  readonly localAddr: string;
+  /** Milliseconds since `connectStart`. */
+  readonly durationMs: number;
+}
+
+/** The encrypted session exists; `clientinit` has not been sent yet. */
+export interface HandshakeDoneInfo extends AttemptInfo {
+  /** Milliseconds since `connectStart`. */
+  readonly durationMs: number;
+  /** The level of the RSA puzzle the server demanded; 0 if it sent none. */
+  readonly puzzleLevel: number;
+  /** Milliseconds spent solving the puzzle. */
+  readonly puzzleDurationMs: number;
+  /**
+   * The packets sent again from `connectStart` to now, for want of an
+   * acknowledgement: the Init1 steps and the handshake's command packets.
+   */
+  readonly resends: number;
+  /**
+   * The server's public key exactly as it sent it, base64, so that a caller can
+   * pin a server's identity.
+   */
+  readonly serverPublicKey: string;
+}
+
+/** The server accepted the client, which is now connected. */
+export interface SessionStartInfo extends AttemptInfo {
+  /** The client's ID on the server, the same as `client.clientID`. */
+  readonly clientID: ClientID;
+  /**
+   * The nickname the server accepted (`acn`), which differs from the one asked
+   * for when that was taken. The one asked for when the server did not say.
+   */
+  readonly nickname: string;
+  /** The client's talk power (`client_talk_power`); 0 when the server did not say. */
+  readonly talkPower: number;
+  /**
+   * Every parameter of `initserver`, unescaped, except those that could carry a
+   * secret: `client_server_password`, `client_default_channel_password`,
+   * `client_default_token` and `client_key_offset`. Frozen.
+   */
+  readonly initServer: Readonly<Record<string, string>>;
+  /** What the server said about itself in this handshake. */
+  readonly capabilities: ServerCapabilities;
+  /** Milliseconds since `connectStart`. */
+  readonly durationMs: number;
+}
+
+/** The server's welcome sequence ended: the channel list and the clients already there have arrived. */
+export interface WelcomeDoneInfo extends AttemptInfo {
+  /**
+   * The channel the client is in at the end of the welcome: where it landed,
+   * which differs from the default channel asked for when that was refused.
+   */
+  readonly channelID: ChannelID;
+  /** How many channel rows the welcome delivered. */
+  readonly channels: number;
+  /** How many clients are in view at the end of the welcome, this client included. */
+  readonly clients: number;
+  /** Milliseconds since `connectStart`. */
+  readonly durationMs: number;
+}
+
+/** An attempt ended without a session. */
+export interface AttemptFailedInfo extends AttemptInfo {
+  /** Where the attempt failed. */
+  readonly phase: ConnectPhase;
+  /** Why: the error `connect()` rejects with, or the one that ended the reconnection attempt. */
+  readonly error: unknown;
+  /** The `host:port` being dialled; empty when the attempt failed before `resolveDone`. */
+  readonly target: string;
+  /** Milliseconds since `resolveStart`. */
+  readonly durationMs: number;
+}
+
+/** The reconnect loop will retry, after a wait. */
+export interface ReconnectScheduledInfo {
+  /** The attempt that will follow, numbered as in {@link ResolveStartInfo.attempt}. */
+  readonly attempt: number;
+  /** How long the loop waits first, in milliseconds. */
+  readonly delayMs: number;
+  /** The error that ended the previous connection or attempt. */
+  readonly cause: unknown;
+}
+
+/** A connected session is about to be left with `disconnect()`. It has no fields yet. */
+// oxlint-disable-next-line no-empty-interface -- fields are added here later
+export interface DisconnectStartInfo {}
+
+/** The goodbye of `disconnect()` is over. */
+export interface DisconnectDoneInfo {
+  /** Whether the server acknowledged the goodbye before the goodbye timeout. */
+  readonly acknowledged: boolean;
+  /** Milliseconds since `disconnectStart`. */
+  readonly durationMs: number;
+}
+
+/** A session that had a `sessionStart` has ended, however it ended. */
+export interface SessionEndInfo {
+  /** The client's ID on the server during the session. */
+  readonly clientID: ClientID;
+  /**
+   * `undefined` after `disconnect()`, and otherwise the cause the
+   * `disconnected` event gets.
+   */
+  readonly error: unknown;
+  /** Milliseconds since `sessionStart`. */
+  readonly durationMs: number;
+  /** The number of the attempt that started the session. */
+  readonly attempt: number;
+  /** Whether the reconnect loop started the attempt that started the session. */
+  readonly reconnect: boolean;
+}
+
+/** The reconnect loop ended without a session. */
+export interface ReconnectStoppedInfo {
+  /** How many reconnection attempts the loop made. */
+  readonly attempts: number;
+  /**
+   * The error `shouldRetry` declined, or the last attempt's when the attempts
+   * ran out; `undefined` when `disconnect()` stopped the loop.
+   */
+  readonly cause: unknown;
+}
+
+/**
+ * Hooks that observe a client for timing, metrics, logs or a progress
+ * display: the milestones of every connection attempt, the end of a session,
+ * and the reconnect loop. Every hook is optional.
+ *
+ * A hook is called synchronously, at the moment of the milestone, and the
+ * client waits for it to return: keep it quick, and hand slow work to your own
+ * task. What it returns is ignored, and a returned promise is never awaited. A
+ * hook that throws, or whose promise rejects, is reported the way a throwing
+ * event listener is, and the client carries on. A hook may read the
+ * client's state. It must not call `connect()` or `disconnect()`: to give up
+ * on an attempt, abort the signal passed to `connect()`, and to leave once
+ * connected, call `disconnect()` from a `connected` listener.
+ *
+ * Every attempt ends with exactly one of `sessionStart` and `attemptFailed`,
+ * and every session that started with exactly one `sessionEnd`. The hooks are
+ * read when the client is made, from a copy of this object.
+ */
+export interface ClientTrace {
+  /** Before the address is resolved. */
+  readonly resolveStart?: (info: ResolveStartInfo) => void;
+  /** After the address is resolved, also when it fell back to the address as given. */
+  readonly resolveDone?: (info: ResolveDoneInfo) => void;
+  /** Right before the socket is opened. */
+  readonly connectStart?: (info: ConnectStartInfo) => void;
+  /** Once the socket is open, before the first handshake packet is sent. */
+  readonly connectDone?: (info: ConnectDoneInfo) => void;
+  /** When the shared secret is derived, before `clientinit` is sent. */
+  readonly handshakeDone?: (info: HandshakeDoneInfo) => void;
+  /** When the server accepts the client: before `connect()` resolves and before `connected` is delivered. */
+  readonly sessionStart?: (info: SessionStartInfo) => void;
+  /** When the server's welcome sequence ends; at most once per attempt, and only after `sessionStart`. */
+  readonly welcomeDone?: (info: WelcomeDoneInfo) => void;
+  /** When an attempt ends without `sessionStart`, for any reason, an abort or `disconnect()` included. */
+  readonly attemptFailed?: (info: AttemptFailedInfo) => void;
+  /** When `disconnect()` begins saying goodbye to a connected session. */
+  readonly disconnectStart?: (info: DisconnectStartInfo) => void;
+  /** When that goodbye is over. */
+  readonly disconnectDone?: (info: DisconnectDoneInfo) => void;
+  /** When a session ends, however it ends; before `disconnected` is queued. */
+  readonly sessionEnd?: (info: SessionEndInfo) => void;
+  /** When the reconnect loop has decided to retry and is about to wait. */
+  readonly reconnectScheduled?: (info: ReconnectScheduledInfo) => void;
+  /** When the reconnect loop ends without a session. */
+  readonly reconnectStopped?: (info: ReconnectStoppedInfo) => void;
+}

package/src/transfer.ts

@@ -8,14 +8,96 @@
 
 import { connect } from "node:net";
 import { pipeline } from "node:stream/promises";
-import type { Duplex, Readable, Writable } from "node:stream";
+import { Transform, type Duplex, type Readable, type Writable } from "node:stream";
 import type { FileUploadInfo, FileDownloadInfo } from "@honeybbq/teamspeak-core";
 import type { FileTransferSocketFactory } from "./types.js";
 import { FileTransferError } from "./errors.js";
+import { callHook } from "./hooks.js";
+import { joinHostPort } from "./address.js";
+import { abortable } from "./abort.js";
 
 /** How long dialing may take before it fails, unless a signal says otherwise. */
 const DIAL_TIMEOUT_MS = 10_000;
 
+/** How long a transfer may go without moving a byte, unless `idleTimeoutMs` says otherwise. */
+const DEFAULT_IDLE_TIMEOUT_MS = 30_000;
+
+/** How many bytes move between two calls of the `progress` hook, at least. */
+const PROGRESS_STEP_BYTES = 64 * 1024;
+
+/** Where a failed transfer failed. */
+export type FileTransferStage = "dial" | "transfer";
+
+/** The file transfer port is about to be dialled. */
+export interface FileTransferDialStartInfo {
+  /** The `host:port` being dialled. */
+  readonly addr: string;
+}
+
+/** The connection is open and the transfer key has been sent. */
+export interface FileTransferDialDoneInfo {
+  /** The `host:port` dialled. */
+  readonly addr: string;
+  /** The local socket's `host:port`; empty when the socket does not say. */
+  readonly localAddr: string;
+  /** Milliseconds since `dialStart`. */
+  readonly durationMs: number;
+}
+
+/** Data has moved. */
+export interface FileTransferProgressInfo {
+  /** The bytes moved so far. */
+  readonly bytes: number;
+  /** The size the negotiation gave; 0 when it is not known, as for an upload. */
+  readonly total: number;
+}
+
+/** The transfer succeeded. */
+export interface FileTransferDoneInfo {
+  /** The bytes moved. */
+  readonly bytes: number;
+  /** Milliseconds since `dialStart`. */
+  readonly durationMs: number;
+}
+
+/** The transfer failed. */
+export interface FileTransferFailedInfo {
+  /** Why: the error the transfer function rejects with. */
+  readonly error: unknown;
+  /** The bytes moved before it failed. */
+  readonly bytes: number;
+  /** Milliseconds since `dialStart`. */
+  readonly durationMs: number;
+  /** Whether the failure came while dialling or while the data moved. */
+  readonly stage: FileTransferStage;
+}
+
+/**
+ * Hooks that observe one file transfer. Every hook is optional, and none ever
+ * sees the transfer key.
+ *
+ * A hook runs synchronously on the task doing the transfer, and its return
+ * value is ignored: a returned promise is not awaited. A hook that throws, or
+ * whose promise rejects, is reported the way a throwing event listener is, and
+ * the transfer goes on. Keep hooks quick.
+ *
+ * A call of `uploadFileData` or `downloadFileData` ends with exactly one of
+ * `done` and `failed`; `dialFileTransfer` on its own reports `dialStart`, then
+ * `dialDone` or `failed` with the stage `"dial"`.
+ */
+export interface FileTransferTrace {
+  /** Before the file transfer port is dialled. */
+  readonly dialStart?: (info: FileTransferDialStartInfo) => void;
+  /** When the connection is open and the transfer key is sent. */
+  readonly dialDone?: (info: FileTransferDialDoneInfo) => void;
+  /** While data moves, at most once per 64 KiB, and once more at the end with the final count. */
+  readonly progress?: (info: FileTransferProgressInfo) => void;
+  /** When the transfer function is about to resolve. */
+  readonly done?: (info: FileTransferDoneInfo) => void;
+  /** When the transfer function is about to reject, a failed dial included. */
+  readonly failed?: (info: FileTransferFailedInfo) => void;
+}
+
 /** Options for a file transfer. */
 export interface FileTransferOptions {
   /** Abandons the transfer; it then rejects with the signal's reason. */
@@ -25,6 +107,83 @@ export interface FileTransferOptions {
    * through a proxy or tunnel.
    */
   readonly socketFactory?: FileTransferSocketFactory | undefined;
+  /**
+   * Hooks called at each milestone of this transfer. The object is copied when
+   * the call starts. See {@link FileTransferTrace}.
+   */
+  readonly trace?: FileTransferTrace | undefined;
+  /**
+   * The longest, in milliseconds, the transfer may go without moving a byte,
+   * the write of the transfer key included. When it passes, the transfer
+   * rejects with a {@link FileTransferError} whose `cause` is a `TimeoutError`
+   * and the connection is destroyed. `undefined` means the default, 30 000;
+   * `0` turns the limit off.
+   */
+  readonly idleTimeoutMs?: number | undefined;
+}
+
+/** What a transfer's hooks share: the trace, when the call began, and what has moved. */
+interface TransferTrace {
+  readonly trace: FileTransferTrace | undefined;
+  readonly startedAt: number;
+  bytes: number;
+}
+
+/**
+ * Watches a transfer for going idle. `touch()` says a byte moved; when none
+ * does for the whole limit, `signal` aborts with a `TimeoutError`.
+ */
+interface IdleGuard {
+  readonly signal: AbortSignal;
+  readonly limitMs: number;
+  touch(): void;
+  stop(): void;
+}
+
+function newIdleGuard(options: FileTransferOptions): IdleGuard {
+  const limitMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  if (!Number.isFinite(limitMs) || limitMs < 0) {
+    throw new RangeError("idleTimeoutMs must be a finite number of milliseconds, 0 or more");
+  }
+  const controller = new AbortController();
+  if (limitMs === 0) {
+    return { signal: controller.signal, limitMs, touch() {}, stop() {} };
+  }
+  const timer = setTimeout(
+    () => controller.abort(new DOMException(`no data moved for ${limitMs} ms`, "TimeoutError")),
+    limitMs,
+  );
+  return {
+    signal: controller.signal,
+    limitMs,
+    touch: () => timer.refresh(),
+    stop: () => clearTimeout(timer),
+  };
+}
+
+/** The error a transfer fails with when `idle` expired, else `error` as it is. */
+function idleOr(idle: IdleGuard, error: unknown): unknown {
+  if (!idle.signal.aborted) return error;
+  return new FileTransferError(`file transfer stalled: no data moved for ${idle.limitMs} ms`, {
+    cause: idle.signal.reason,
+  });
+}
+
+function newTransferTrace(options: FileTransferOptions): TransferTrace {
+  return {
+    trace: options.trace === undefined ? undefined : { ...options.trace },
+    startedAt: performance.now(),
+    bytes: 0,
+  };
+}
+
+function reportFailed(t: TransferTrace, error: unknown, stage: FileTransferStage): void {
+  callHook(t.trace?.failed, t.trace, () => ({
+    error,
+    bytes: t.bytes,
+    durationMs: performance.now() - t.startedAt,
+    stage,
+  }));
 }
 
 /**
@@ -36,8 +195,37 @@ export async function dialFileTransfer(
   port: number,
   key: string,
   options: FileTransferOptions = {},
+): Promise<Duplex> {
+  const t = newTransferTrace(options);
+  const idle = newIdleGuard(options);
+  try {
+    return await dial(host, port, key, options, t, idle);
+  } catch (error) {
+    const failure = idleOr(idle, error);
+    reportFailed(t, failure, "dial");
+    throw failure;
+  } finally {
+    idle.stop();
+  }
+}
+
+async function dial(
+  host: string,
+  port: number,
+  key: string,
+  options: FileTransferOptions,
+  t: TransferTrace,
+  idle: IdleGuard,
 ): Promise<Duplex> {
   const { signal, socketFactory } = options;
+  // One budget for the connection and the key write: a peer that accepts the
+  // connection and never reads would otherwise hold the write forever.
+  const timeout = AbortSignal.timeout(DIAL_TIMEOUT_MS);
+  const dialSignal = AbortSignal.any(
+    signal ? [signal, timeout, idle.signal] : [timeout, idle.signal],
+  );
+  const addr = joinHostPort(host, String(port));
+  callHook(t.trace?.dialStart, t.trace, () => ({ addr }));
   signal?.throwIfAborted();
   const socket: Duplex = socketFactory ? socketFactory(host, port) : connect({ host, port });
 
@@ -46,42 +234,154 @@ export async function dialFileTransfer(
   const swallow = (): void => {};
   socket.on("error", swallow);
   try {
-    await connected(socket, signal);
-    await new Promise<void>((resolve, reject) => {
-      socket.write(key, (err) =>
-        err
-          ? reject(
-              new FileTransferError(`failed to send transfer key: ${err.message}`, { cause: err }),
-            )
-          : resolve(),
-      );
-    });
+    await abortable(connected(socket), dialSignal);
+    idle.touch();
+    await abortable(
+      new Promise<void>((resolve, reject) => {
+        socket.write(key, (err) =>
+          err
+            ? reject(
+                new FileTransferError(`failed to send transfer key: ${err.message}`, {
+                  cause: err,
+                }),
+              )
+            : resolve(),
+        );
+      }),
+      dialSignal,
+    );
+    idle.touch();
   } catch (error) {
     socket.destroy();
+    if (timeout.aborted && error === timeout.reason) {
+      throw new FileTransferError("file transfer connection timed out", { cause: error });
+    }
     throw error;
   } finally {
     socket.off("error", swallow);
   }
+  callHook(t.trace?.dialDone, t.trace, () => {
+    let localAddr = "";
+    const local = socket as { localAddress?: unknown; localPort?: unknown };
+    if (typeof local.localAddress === "string" && typeof local.localPort === "number") {
+      localAddr = joinHostPort(local.localAddress, String(local.localPort));
+    }
+    return { addr, localAddr, durationMs: performance.now() - t.startedAt };
+  });
   return socket;
 }
 
+/**
+ * A pass-through that counts what moves and reports it to `progress`. It never
+ * fails the pipeline: a hook's error is reported, not thrown.
+ */
+function countingStream(t: TransferTrace, total: number, idle: IdleGuard): Transform {
+  let reported = 0;
+  return new Transform({
+    transform(chunk: Buffer | string, _encoding, callback) {
+      t.bytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+      idle.touch();
+      if (t.bytes - reported >= PROGRESS_STEP_BYTES) {
+        reported = t.bytes;
+        const bytes = t.bytes;
+        callHook(t.trace?.progress, t.trace, () => ({ bytes, total }));
+      }
+      callback(null, chunk);
+    },
+  });
+}
+
+/**
+ * Passes exactly `expected` bytes. One more byte fails the transfer, and is
+ * not passed on; a stream that ends before `expected` fails it too.
+ */
+function exactSize(expected: number): Transform {
+  let received = 0;
+  return new Transform({
+    transform(chunk: Buffer, _encoding, callback) {
+      const room = expected - received;
+      if (chunk.length > room) {
+        this.push(chunk.subarray(0, room));
+        received = expected;
+        callback(
+          new FileTransferError(`file transfer sent more than the announced ${expected} bytes`),
+        );
+        return;
+      }
+      received += chunk.length;
+      callback(null, chunk);
+    },
+    flush(callback) {
+      callback(
+        received === expected
+          ? null
+          : new FileTransferError(
+              `file transfer ended after ${received} of the announced ${expected} bytes`,
+            ),
+      );
+    },
+  });
+}
+
+/** Run a transfer's data phase, and report how the whole call ended. */
+async function transfer(
+  host: string,
+  port: number,
+  key: string,
+  total: number,
+  options: FileTransferOptions,
+  move: (
+    socket: Duplex,
+    counter: Transform,
+    pipeOptions: { signal?: AbortSignal },
+  ) => Promise<void>,
+): Promise<void> {
+  const t = newTransferTrace(options);
+  const idle = newIdleGuard(options);
+  try {
+    let socket: Duplex;
+    try {
+      socket = await dial(host, port, key, options, t, idle);
+    } catch (error) {
+      const failure = idleOr(idle, error);
+      reportFailed(t, failure, "dial");
+      throw failure;
+    }
+    try {
+      const signal = options.signal ? AbortSignal.any([options.signal, idle.signal]) : idle.signal;
+      await move(socket, countingStream(t, total, idle), { signal });
+    } catch (error) {
+      // A pipeline aborted by the caller's signal rejects as the signal says;
+      // one aborted by the idle limit is the transfer's own failure.
+      const failure = idleOr(idle, error);
+      reportFailed(t, failure, "transfer");
+      throw failure;
+    }
+  } finally {
+    idle.stop();
+  }
+  const bytes = t.bytes;
+  callHook(t.trace?.progress, t.trace, () => ({ bytes, total }));
+  callHook(t.trace?.done, t.trace, () => ({
+    bytes,
+    durationMs: performance.now() - t.startedAt,
+  }));
+}
+
 /**
  * Wait for a stream to be connected. A `node:net` socket says so with
  * `connect`; a stream from elsewhere that is already writable is taken as
  * connected.
  */
-function connected(socket: Duplex, signal: AbortSignal | undefined): Promise<void> {
+function connected(socket: Duplex): Promise<void> {
   const pending = (socket as { pending?: boolean }).pending;
   if (pending === false || (pending === undefined && socket.writable)) return Promise.resolve();
 
   return new Promise<void>((resolve, reject) => {
-    const timeout = AbortSignal.timeout(DIAL_TIMEOUT_MS);
     const done = (error?: unknown): void => {
       socket.off("connect", onConnect);
       socket.off("ready", onConnect);
       socket.off("error", onError);
-      signal?.removeEventListener("abort", onAbort);
-      timeout.removeEventListener("abort", onTimeout);
       if (error === undefined) resolve();
       else reject(error);
     };
@@ -92,36 +392,45 @@ function connected(socket: Duplex, signal: AbortSignal | undefined): Promise<voi
           cause: error,
         }),
       );
-    const onAbort = (): void => done(signal!.reason);
-    const onTimeout = (): void => done(new FileTransferError("file transfer connection timed out"));
     socket.once("connect", onConnect);
     socket.once("ready", onConnect);
     socket.once("error", onError);
-    signal?.addEventListener("abort", onAbort, { once: true });
-    timeout.addEventListener("abort", onTimeout, { once: true });
   });
 }
 
 /** Upload `data` over a negotiated transfer. Resolves once every byte is sent. */
-export async function uploadFileData(
+export function uploadFileData(
   host: string,
   info: FileUploadInfo,
   data: Readable,
   options: FileTransferOptions = {},
 ): Promise<void> {
-  const socket = await dialFileTransfer(host, info.port, info.fileTransferKey, options);
-  await pipeline(data, socket, options.signal ? { signal: options.signal } : {});
+  return transfer(
+    host,
+    info.port,
+    info.fileTransferKey,
+    0,
+    options,
+    (socket, counter, pipeOptions) => pipeline(data, counter, socket, pipeOptions),
+  );
 }
 
 /** Download a negotiated transfer into `dest`. Resolves once the file is written. */
-export async function downloadFileData(
+export function downloadFileData(
   host: string,
   info: FileDownloadInfo,
   dest: Writable,
   options: FileTransferOptions = {},
 ): Promise<void> {
-  const socket = await dialFileTransfer(host, info.port, info.fileTransferKey, options);
-  await pipeline(socket, dest, options.signal ? { signal: options.signal } : {});
+  return transfer(
+    host,
+    info.port,
+    info.fileTransferKey,
+    Number(info.size),
+    options,
+    (socket, counter, pipeOptions) =>
+      pipeline(socket, exactSize(Number(info.size)), counter, dest, pipeOptions),
+  );
 }
 
 export { FileTransferError };