(feature) add a more detailed summary about the data transfer at the end

Author: collapsinghierarchy

src/commands/recv.js

@@ -12,7 +12,8 @@ import { hardExitIfEnabled } from "../env/hard-exit.js";
 import { createLogger, getLogger, setGlobalLogger } from "../util/logger.js";
 import { sanitizeFilename } from "../util/sanitize.js";
 import { attachRawLogger } from "./raw_tap.js";
-import { humanBytes } from "../util/format.js";
+import { humanBytes, formatDuration } from "../util/format.js";
+import { formatSummary, humanThroughput } from "../util/transfer-summary.js";
 import { formatProgressLine } from "../util/progress.js";
 import { closeTransport, waitForPeerClose } from "../util/rtc.js";
 
@@ -80,7 +81,7 @@ export async function run(outDir, opts, ctx = {}) {
 
   let totalBytes = 0;
   let written = 0;
-  let startedAt = 0;
+  let startedAt = null;
 
   const sink = makeSniffingSink({
     outToStdout,
@@ -159,8 +160,46 @@ export async function run(outDir, opts, ctx = {}) {
     await sink.close();
     await waitForPeerClose(rtc, 1500);
 
-    process.stderr.write("\nDone • " + humanBytes(written) + "\n");
+       const completedAt = Date.now();
+    const durationMs = startedAt != null ? Math.max(0, completedAt - startedAt) : 0;
+    const throughputStr = humanThroughput(written, durationMs);
+    const announced = Number.isFinite(stats.announced) ? stats.announced : null;
+    let announcedValue = "—";
+    if (announced != null) {
+      const delta = announced - written;
+      const deltaSuffix =
+        delta === 0
+          ? ` (Δ ${humanBytes(0)})`
+          : ` (Δ ${delta > 0 ? "+" : "-"}${humanBytes(Math.abs(delta))})`;
+      announcedValue = `${humanBytes(announced)}${deltaSuffix}`;
+    }
+
+    const destinationParts = [];
+    if (stats.label) destinationParts.push(stats.label);
+    if (stats.filePath) {
+      destinationParts.push(stats.filePath);
+    } else if (outToStdout) {
+      destinationParts.push("stdout");
+    }
+    const destinationInfo =
+      destinationParts.length > 0
+        ? destinationParts.join(" → ")
+        : outToStdout
+          ? "stdout"
+          : "(unknown)";
+
+    const summary = formatSummary({
+      rows: [
+        { label: "Bytes", value: humanBytes(written) },
+        { label: "Duration", value: formatDuration(durationMs) },
+        { label: "Throughput", value: throughputStr },
+        { label: "Announced", value: announcedValue },
+        { label: "Destination", value: destinationInfo },
+      ],
+    });
+    process.stderr.write(summary + "\n");
     // Return a structured result for programmatic use
+    
     const stats = sink.getStats?.() || {};
     return {
       bytesWritten: written,

src/commands/send.js

@@ -16,7 +16,8 @@ import { hardExitIfEnabled } from "../env/hard-exit.js";
 import { createLogger, getLogger, setGlobalLogger  } from "../util/logger.js";
 import { sanitizeFilename } from "../util/sanitize.js";
 import { attachRawLogger } from "./raw_tap.js";
-import { humanBytes } from "../util/format.js";
+import { humanBytes, formatDuration } from "../util/format.js";
+import { formatSummary, humanThroughput } from "../util/transfer-summary.js";
 import { formatProgressLine } from "../util/progress.js";
 import { closeTransport, waitForPeerClose } from "../util/rtc.js";
 import { MAX_STREAM_CHUNK_BYTES } from "../transfer/constants.js";
@@ -85,22 +86,27 @@ export async function run(paths, opts, ctx = {}) {
     sendNameHint = opts?.name ? String(opts.name) : `${stem}.tar`;
     getLogger().debug(`send: tarball name set to ${sendNameHint}`);
   }
-  // Progress UI
-  let startedAt = null;
+  // Progress UI + metrics
+  const commandStartedAt = Date.now();
+  let transferStartedAt = null;
+  let lastProgressAt = null;
   let lastTick = 0;
   function onProgress(sent, total) {
     getLogger().debug(`OnProgress: sent=${sent} total=${total}`);
     const now = Date.now();
-    if (startedAt == null && sent > 0) {
-      startedAt = now;
+    if (transferStartedAt == null && sent > 0) {
+      transferStartedAt = now;
+    }
+    if (sent > 0 || (total != null && sent >= total)) {
+      lastProgressAt = now;
     }
     if (now - lastTick < 120 && sent !== total) return;
     lastTick = now;
     if (process.stderr.isTTY) {
       const msg = formatProgressLine({
         doneBytes: sent,
         totalBytes: total,
-        startedAt: startedAt ?? now,
+        startedAt: transferStartedAt ?? commandStartedAt,
       });
       readline.clearLine(process.stderr, 0);
       readline.cursorTo(process.stderr, 0);
@@ -122,6 +128,7 @@ export async function run(paths, opts, ctx = {}) {
   // Attach low-level logger BEFORE wiring auth/stream
   const detachTap = attachRawLogger(rtc, { label: "low" });
   getLogger().debug("send: RTC connected");
+  let peerCloseObservedAt = null;
   try {
     signal.send?.({ type: "telemetry", event: "ice-connected", sessionId });
     getLogger().debug("send: announced telemetry ice-connected");
@@ -166,7 +173,7 @@ export async function run(paths, opts, ctx = {}) {
         assumeYes: !!opts.yes,
       });
     }
-
+    lastProgressAt = Date.now();
     try {
       onProgress(totalBytes, totalBytes);
     } catch {}
@@ -201,11 +208,13 @@ export async function run(paths, opts, ctx = {}) {
       } else if (finAckResult === "nack") {
         finAckError = "send: receiver reported failure while acknowledging FIN";
         getLogger().info(finAckError);
+        peerCloseObservedAt = Date.now();
       }
     }
 
     if (finAckResult !== "peer-close") {
       const peerCloseResult = await waitForPeerClose(rtc, peerCloseTimeoutMs);
+      peerCloseObservedAt = Date.now();
       if (
         peerCloseResult === "timeout" &&
         Number.isFinite(peerCloseTimeoutMs) &&
@@ -223,7 +232,22 @@ export async function run(paths, opts, ctx = {}) {
       throw err;
     }
 
-    process.stderr.write("\nDone • " + humanBytes(totalBytes) + "\n");
+    const completedAt = peerCloseObservedAt ?? Date.now();
+    const dataStart = transferStartedAt ?? commandStartedAt;
+    const dataEnd = lastProgressAt ?? completedAt;
+    const totalDurationMs = Math.max(0, completedAt - commandStartedAt);
+    const dataDurationMs = Math.max(0, dataEnd - dataStart);
+    const handshakeWaitMs = Math.max(0, dataStart - commandStartedAt);
+    const peerCloseWaitMs = Math.max(0, completedAt - dataEnd);
+    const summary = formatSummary({
+      rows: [
+        { label: "Bytes", value: humanBytes(totalBytes) },
+        { label: "Duration", value: formatDuration(totalDurationMs) },
+        { label: "Throughput", value: humanThroughput(totalBytes, dataDurationMs) },
+        { label: "Handshake wait", value: formatDuration(handshakeWaitMs) },
+      ],
+    });
+    process.stderr.write(summary + "\n");
     // --- Silent workaround on success
   } finally {
     // Hard, handler-safe close sequence

src/util/format.js

@@ -15,3 +15,28 @@ export function formatETA(s) {
     sec = Math.floor(s % 60);
   return `${m}:${sec.toString().padStart(2, "0")}`;
 }
+
+export function formatDuration(ms) {
+  if (!Number.isFinite(ms)) return "—";
+  const clamped = Math.max(0, Number(ms));
+  if (clamped < 1) return "0 ms";
+  if (clamped < 1000) return `${Math.round(clamped)} ms`;
+
+  const totalSeconds = clamped / 1000;
+  if (totalSeconds < 60) {
+    const precision = totalSeconds < 10 ? 2 : 1;
+    const trimmed = Number(totalSeconds.toFixed(precision)).toString();
+    return `${trimmed} s`;
+  }
+
+  const parts = [];
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = Math.floor(totalSeconds % 60);
+
+  if (hours) parts.push(`${hours}h`);
+  if (minutes) parts.push(`${minutes}m`);
+  if (seconds || parts.length === 0) parts.push(`${seconds}s`);
+
+  return parts.join(" ");
+}

src/util/transfer-summary.js

@@ -0,0 +1,28 @@
+import { humanBytes } from "./format.js";
+
+export function humanThroughput(bytes, durationMs) {
+  const totalBytes = Number(bytes);
+  const ms = Number(durationMs);
+  if (!Number.isFinite(totalBytes) || totalBytes < 0) return "—";
+  if (!Number.isFinite(ms) || ms <= 0) return "—";
+  const seconds = ms / 1000;
+  if (seconds <= 0) return "—";
+  const perSecond = totalBytes / seconds;
+  if (!Number.isFinite(perSecond)) return "—";
+  return `${humanBytes(perSecond)}/s`;
+}
+
+export function formatSummary({ heading = "Done", rows = [] } = {}) {
+  const lines = ["", String(heading)];
+  for (const row of rows) {
+    if (!row) continue;
+    if (typeof row === "string") {
+      lines.push(row);
+      continue;
+    }
+    const label = row.label ?? "";
+    const value = row.value ?? "";
+    lines.push(`  ${String(label)}: ${String(value)}`);
+  }
+  return lines.join("\n");
+}