ezshare-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,311 @@
+# EzShare
+
+**Secure P2P file transfer with end-to-end encryption - No servers, no signups, just share**
+
+Share files and folders directly between peers using decentralized Hyperswarm DHT. Works across different networks with built-in NAT traversal.
+
+[![Node.js](https://img.shields.io/badge/Node.js-18%2B-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+- **🔒 End-to-End Encryption** — AES-256-GCM authenticated encryption
+- **🌐 Truly Decentralized** — Direct peer-to-peer via Hyperswarm DHT, no servers
+- **🚀 NAT Traversal** — Works across different networks with automatic hole-punching
+- **⚡ Adaptive Compression** — Zstandard compression (smart detection skips .zip, .mp4, etc.)
+- **💻 Interactive Shell** — Claude Code-style TUI with slash commands and file browser
+- **📦 Streaming Architecture** — Memory-efficient for files of any size
+- **🔄 Cross-Platform** — Linux, macOS, and Windows
+
+## 📦 Installation
+
+### Prerequisites
+
+- **Node.js 18+** (recommended: Node 20+)
+- **Zstandard** (`zstd`) - required for compression
+
+```bash
+# Ubuntu/Debian
+sudo apt install zstd
+
+# macOS
+brew install zstd
+
+# Windows (chocolatey)
+choco install zstd
+```
+
+### Install Globally
+
+```bash
+npm install -g ezshare-cli
+```
+
+Now you can use `ezshare` from anywhere!
+
+### Or Use with npx (no install)
+
+```bash
+npx ezshare-cli
+```
+
+## 🚀 Quick Start
+
+### Interactive Mode (Recommended)
+
+Simply type `ezshare` to launch the interactive shell:
+
+```bash
+ezshare
+```
+
+You'll see:
+
+```
+EzShare CLI - P2P File Transfer
+Type /ezshare to start or /help for commands
+
+ezshare>
+```
+
+**Available commands:**
+- `/ezshare` - Open the main menu
+- `/help` - Show help screen
+- `/exit` - Exit the application
+- `q` - Quick exit (when in command mode)
+- `Esc` - Go back to command mode
+
+#### Using the Interactive Shell
+
+1. Type `/ezshare` to open the main menu
+2. Choose **Send** or **Receive**
+3. **For Send:**
+   - Use arrow keys (↑/↓) to navigate your file system
+   - Press `Enter` on a folder to open it
+   - Press `Enter` on a file to select it for sharing
+   - Copy the generated share key
+4. **For Receive:**
+   - Paste the share key from the sender
+   - Files save to current directory by default
+
+### Direct CLI Mode
+
+Or use direct commands for quick transfers:
+
+#### Send a file or directory
+
+```bash
+ezshare send <path>
+```
+
+Example:
+```bash
+$ ezshare send ./documents
+
+ 📤 Sending: documents
+ Size: 2.4 MB | Files: 3
+
+ Share this key with receiver:
+ BhhzKS7G4iIq4okKNYhaoqljeLMAjMR8UkpaLyqP7EA
+
+ ⠋ Waiting for peer to connect...
+```
+
+#### Receive a file
+
+```bash
+ezshare receive <share-key> [--output <directory>]
+```
+
+Example:
+```bash
+$ ezshare receive BhhzKS7G4iIq4okKNYhaoqljeLMAjMR8UkpaLyqP7EA
+
+ 📥 Receiving file(s)
+ Size: 2.4 MB | Files: 3
+
+ ⠋ Connecting to peer...
+ ████████████████████████████████████████ 100%
+
+ ✓ Transfer complete!
+ Saved to: /current/directory
+```
+
+Specify output directory:
+```bash
+ezshare receive <key> --output ~/Downloads
+```
+
+## 🔧 How It Works
+
+```
+┌─────────────┐                                        ┌─────────────┐
+│   Sender    │                                        │  Receiver   │
+└──────┬──────┘                                        └──────┬──────┘
+       │                                                      │
+       │  1. Generate random topic key                       │
+       │  2. Display share key to user                       │
+       │                                                      │
+       │  3. Announce to Hyperswarm DHT ────────────────────►│  4. Look up in DHT
+       │                                                      │
+       │◄─────────────────  5. P2P Connection  ──────────────┤
+       │                   (NAT hole-punching)                │
+       │                                                      │
+       │  Files → Tar → Compress* → Encrypt (AES-256)        │
+       │                                                      │
+       ├──────────────────►  Transfer  ──────────────────────┤
+       │                                                      │
+       │                                        Decrypt → Decompress → Extract → Files
+       │                                                      │
+       │◄─────────────────  6. Close Connection  ────────────┤
+```
+
+*Compression is skipped for already-compressed formats (`.zip`, `.gz`, `.mp4`, `.jpg`, etc.)
+
+## 🛡️ Security
+
+- **Key Generation**: Random 32-byte topic key generated per transfer
+- **Key Derivation**: AES key derived from topic using HKDF-SHA256
+- **Encryption**: AES-256-GCM with unique nonces per 64KB chunk
+- **Authentication**: GCM mode provides integrity verification
+- **Transport**: Hyperswarm uses Noise protocol for transport encryption
+
+⚠️ **Important**: The share key is the only secret. Anyone with the key can receive the file. Share it securely (Signal, encrypted email, etc.).
+
+## 🏗️ Architecture
+
+### Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Runtime | Node.js 18+ with TypeScript ES Modules |
+| P2P Network | [Hyperswarm](https://github.com/holepunchto/hyperswarm) (Kademlia DHT + NAT traversal) |
+| Encryption | AES-256-GCM (Node.js crypto) |
+| Compression | [Zstandard](https://github.com/facebook/zstd) via simple-zstd |
+| Archiving | tar-stream (streaming tar) |
+| TUI | [Ink](https://github.com/vadimdemedes/ink) (React for CLI) |
+| CLI Parser | meow |
+
+### Project Structure
+
+```
+ezsharecli/
+├── bin/
+│   └── ezshare.js          # Global CLI entry point
+├── src/
+│   ├── cli.tsx             # Main CLI router (interactive vs direct mode)
+│   ├── components/
+│   │   ├── Shell.tsx       # Interactive shell REPL
+│   │   ├── MainMenu.tsx    # Send/Receive menu
+│   │   ├── FileBrowser.tsx # Arrow-key file navigator
+│   │   ├── HelpScreen.tsx  # Help documentation
+│   │   └── TransferUI.tsx  # Transfer progress UI
+│   ├── commands/
+│   │   ├── send.tsx        # Send command implementation
+│   │   └── receive.tsx     # Receive command implementation
+│   └── utils/
+│       ├── crypto.ts       # AES-256-GCM encryption/decryption streams
+│       ├── compression.ts  # Zstd compression with format detection
+│       ├── network.ts      # Hyperswarm connection management
+│       ├── tar.ts          # Tar pack/extract utilities
+│       └── fileSystem.ts   # File browser utilities
+├── package.json
+└── tsconfig.json
+```
+
+## 🐛 Troubleshooting
+
+### Connection Issues
+
+**"Connection timeout after 30s"**
+- Ensure both sender and receiver are started within ~10 seconds
+- Check firewall settings (Hyperswarm needs UDP for DHT)
+- Try on different networks if behind restrictive NAT
+
+**"Could not find or connect to sender"**
+- Verify the share key is correct (copy-paste to avoid typos)
+- Ensure sender is still running and waiting
+- Both peers need internet connectivity for DHT bootstrap
+
+### Compression Issues
+
+**"zstd: command not found"**
+- Install zstd using your package manager (see Installation section)
+
+### Performance Tips
+
+- Large files (>1GB): Transfers work fine, but both peers should have stable connections
+- Firewalls: Allow UDP traffic for best DHT performance
+- Multiple files: Directory transfers are automatically tar-packed
+
+## 💡 Examples
+
+### Send a single file
+```bash
+ezshare send presentation.pdf
+```
+
+### Send a directory
+```bash
+ezshare send ./project-folder
+```
+
+### Receive to specific location
+```bash
+ezshare receive ABC123XYZ --output ~/Downloads
+```
+
+### Interactive mode with file browser
+```bash
+ezshare
+# Then: /ezshare → Send → Navigate with arrows → Select file
+```
+
+## 🔮 Roadmap
+
+- [ ] Resume interrupted transfers
+- [ ] Multiple simultaneous receivers
+- [ ] Transfer speed indicator and ETA
+- [ ] QR code for share keys (mobile)
+- [ ] Custom encryption passphrases
+- [ ] Web UI companion app
+- [ ] Transfer history
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how:
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/ezsharecli.git
+cd ezsharecli
+
+# Install dependencies
+npm install
+
+# Run in development
+npm run dev
+
+# Build
+npm run build
+
+# Run tests
+npm test
+```
+
+Please open an issue before starting major features.
+
+## 📝 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## 🙏 Acknowledgments
+
+- Built with [Hyperswarm](https://github.com/holepunchto/hyperswarm) by Holepunch
+- Inspired by [Magic Wormhole](https://magic-wormhole.readthedocs.io/)
+- TUI powered by [Ink](https://github.com/vadimdemedes/ink)
+
+---
+
+**Made with ❤️ for secure, decentralized file sharing**

package/bin/ezshare.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.js';

package/dist/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import meow from 'meow';
+import { render } from 'ink';
+import { Shell } from './components/Shell.js';
+import { SendCommand } from './commands/send.js';
+import { ReceiveCommand } from './commands/receive.js';
+const cli = meow(`
+  Usage
+    $ ezshare                             # Interactive shell mode
+    $ ezshare send <path>                 # Direct send
+    $ ezshare receive <key> [--output]    # Direct receive
+
+  Examples
+    $ ezshare                             # Launch interactive shell
+    $ ezshare send ./myfile.zip           # Quick send
+    $ ezshare receive abc123... -o ./downloads
+
+  Options
+    --output, -o  Output directory for received files (default: current directory)
+
+  Interactive Mode:
+    Launch with no arguments to enter interactive shell mode.
+    Use slash commands:
+      /ezshare  - Start file transfer
+      /help     - Show help
+      /exit     - Exit shell
+`, {
+    importMeta: import.meta,
+    flags: {
+        output: { type: 'string', shortFlag: 'o' }
+    }
+});
+const [command, arg] = cli.input;
+// Interactive shell mode (no arguments)
+if (!command) {
+    render(_jsx(Shell, {}));
+}
+// Direct CLI mode - Send
+else if (command === 'send') {
+    if (!arg) {
+        console.error('Error: Please specify a file or directory to send');
+        console.log('Usage: ezshare send <path>');
+        process.exit(1);
+    }
+    render(_jsx(SendCommand, { path: arg, onComplete: () => process.exit(0), onError: () => process.exit(1) }));
+}
+// Direct CLI mode - Receive
+else if (command === 'receive') {
+    if (!arg) {
+        console.error('Error: Please specify a share key');
+        console.log('Usage: ezshare receive <key> [--output <dir>]');
+        process.exit(1);
+    }
+    const outputPath = cli.flags.output || process.cwd();
+    render(_jsx(ReceiveCommand, { shareKey: arg, outputPath: outputPath, onComplete: () => process.exit(0), onError: () => process.exit(1) }));
+}
+else {
+    cli.showHelp();
+}

package/dist/commands/receive.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { Spinner, ProgressBar } from '@inkjs/ui';
+import { pipeline } from 'node:stream/promises';
+import { Transform } from 'node:stream';
+import { parseTopicKey, deriveKey, createDecryptStream } from '../utils/crypto.js';
+import { createDecompressStream } from '../utils/compression.js';
+import { createExtractStream } from '../utils/tar.js';
+import { createReceiverSwarm, cleanupSwarm } from '../utils/network.js';
+export function ReceiveCommand({ shareKey, outputPath = process.cwd(), onComplete, onError }) {
+    const [state, setState] = useState('connecting');
+    const [progress, setProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const [metadata, setMetadata] = useState(null);
+    useEffect(() => {
+        startReceiving();
+    }, []);
+    const startReceiving = async () => {
+        try {
+            // Parse share key to get topic
+            const topic = parseTopicKey(shareKey);
+            // Derive encryption key from topic
+            const encryptionKey = deriveKey(topic);
+            // Create receiver swarm and get connection promise
+            const { swarm, connectionPromise } = await createReceiverSwarm(topic);
+            // Wait for peer connection (listener already registered)
+            const socket = await connectionPromise;
+            console.log('[Receiver] Connected to sender');
+            // Add socket error handler
+            socket.on('error', (err) => {
+                console.error('[Receiver] Socket error:', err);
+            });
+            socket.on('end', () => {
+                console.log('[Receiver] Socket end event received');
+            });
+            socket.on('close', () => {
+                console.log('[Receiver] Socket closed');
+            });
+            // Read metadata first (JSON header followed by newline)
+            const metadataBuffer = [];
+            let metadataReceived = false;
+            let transferMetadata = null;
+            // Create a passthrough to split metadata from file data
+            const metadataExtractor = new Transform({
+                transform(chunk, encoding, callback) {
+                    if (!metadataReceived) {
+                        metadataBuffer.push(chunk);
+                        const combined = Buffer.concat(metadataBuffer);
+                        const newlineIndex = combined.indexOf('\n');
+                        if (newlineIndex !== -1) {
+                            // Found metadata
+                            try {
+                                const metadataJson = combined.slice(0, newlineIndex).toString();
+                                console.log('[Receiver] Received metadata:', metadataJson);
+                                transferMetadata = JSON.parse(metadataJson);
+                                setMetadata(transferMetadata);
+                                // Push remaining data after newline
+                                const remainingData = combined.slice(newlineIndex + 1);
+                                console.log(`[Receiver] Metadata extracted, ${remainingData.length} bytes of data after newline`);
+                                if (remainingData.length > 0) {
+                                    this.push(remainingData);
+                                }
+                                metadataReceived = true;
+                            }
+                            catch (err) {
+                                console.error('[Receiver] Failed to parse metadata:', err);
+                                callback(err);
+                                return;
+                            }
+                        }
+                        callback();
+                    }
+                    else {
+                        // Pass through file data
+                        callback(null, chunk);
+                    }
+                },
+            });
+            // Create progress tracker
+            let transferred = 0;
+            const progressTracker = new Transform({
+                transform(chunk, encoding, callback) {
+                    if (transferMetadata) {
+                        transferred += chunk.length;
+                        const pct = Math.round((transferred / transferMetadata.totalSize) * 100);
+                        setProgress(Math.min(pct, 100));
+                    }
+                    callback(null, chunk);
+                },
+            });
+            // Start receiving
+            setState('receiving');
+            console.log('[Receiver] Starting receive pipeline');
+            // Build the pipeline: Socket → Metadata Extractor → Progress → Decrypt → Decompress → Tar Extract
+            const decryptStream = createDecryptStream(encryptionKey);
+            const decompressStream = await createDecompressStream();
+            const extractStream = createExtractStream(outputPath);
+            await pipeline(socket, metadataExtractor, progressTracker, decryptStream, decompressStream, extractStream);
+            console.log('[Receiver] Pipeline completed successfully');
+            // Transfer complete
+            setState('done');
+            // Receiver cleanup - small delay to ensure socket is fully closed
+            await new Promise(resolve => setTimeout(resolve, 100));
+            console.log('[Receiver] Cleaning up receiver swarm');
+            await cleanupSwarm(swarm);
+            if (onComplete) {
+                onComplete();
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+            setError(errorMessage);
+            setState('error');
+            if (onError) {
+                onError(err);
+            }
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "blue", children: "\uD83D\uDCE5 Receiving file(s)" }), metadata && (_jsxs(Text, { dimColor: true, children: ["Size: ", formatBytes(metadata.totalSize), " | Files: ", metadata.fileCount] })), state === 'connecting' && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Connecting to peer..." }) })), state === 'receiving' && progress === 0 && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Starting transfer..." }) })), state === 'receiving' && progress > 0 && progress < 100 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ProgressBar, { value: progress }), _jsxs(Text, { children: [" ", progress, "%"] })] })), state === 'done' && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Transfer complete!" }), _jsxs(Text, { dimColor: true, children: ["Saved to: ", outputPath] }), _jsx(Text, { dimColor: true, children: "Press Esc to return" })] })), state === 'error' && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "red", bold: true, children: "\u2717 Transfer failed" }), _jsx(Text, { color: "red", children: error }), _jsx(Text, { dimColor: true, children: "Press Esc to return" })] }))] }));
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}

package/dist/commands/send.js

@@ -0,0 +1,117 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { Spinner, ProgressBar } from '@inkjs/ui';
+import { pipeline } from 'node:stream/promises';
+import { Transform } from 'node:stream';
+import { generateTopicKey, deriveKey, createEncryptStream } from '../utils/crypto.js';
+import { createCompressStream, shouldCompress } from '../utils/compression.js';
+import { createPackStream, getTransferMetadata } from '../utils/tar.js';
+import { createSenderSwarm, cleanupSwarm } from '../utils/network.js';
+export function SendCommand({ path, onComplete, onError }) {
+    const [state, setState] = useState('init');
+    const [shareKey, setShareKey] = useState('');
+    const [progress, setProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const [metadata, setMetadata] = useState(null);
+    useEffect(() => {
+        startSending();
+    }, []);
+    const startSending = async () => {
+        try {
+            // Generate topic and display key
+            const { topic, displayKey } = generateTopicKey();
+            setShareKey(displayKey);
+            // Derive encryption key from topic
+            const encryptionKey = deriveKey(topic);
+            // Get transfer metadata
+            const transferMetadata = await getTransferMetadata(path);
+            setMetadata({
+                totalSize: transferMetadata.totalSize,
+                fileCount: transferMetadata.fileCount,
+            });
+            // Create sender swarm
+            setState('waiting');
+            const { swarm, waitForPeer } = await createSenderSwarm(topic);
+            // Wait for peer connection
+            const socket = await waitForPeer();
+            // Register socket close listener BEFORE pipeline starts
+            // This ensures we don't miss the close event
+            const socketClosed = new Promise((resolve) => {
+                socket.once('close', () => {
+                    console.log('[Sender] Socket closed');
+                    resolve();
+                });
+            });
+            // Add socket error handler
+            socket.on('error', (err) => {
+                console.error('[Sender] Socket error:', err);
+            });
+            // Peer connected! Start sending
+            setState('sending');
+            console.log('[Sender] Starting transfer pipeline');
+            // Create metadata prepend stream
+            const metadataJson = JSON.stringify({
+                totalSize: transferMetadata.totalSize,
+                fileCount: transferMetadata.fileCount,
+                isDirectory: transferMetadata.isDirectory,
+                compressed: shouldCompress(path),
+            }) + '\n';
+            let metadataSent = false;
+            const metadataPrepender = new Transform({
+                transform(chunk, encoding, callback) {
+                    if (!metadataSent) {
+                        // Send metadata as first chunk
+                        this.push(Buffer.from(metadataJson));
+                        metadataSent = true;
+                    }
+                    callback(null, chunk);
+                },
+            });
+            // Create progress tracker
+            let transferred = 0;
+            const progressTracker = new Transform({
+                transform(chunk, encoding, callback) {
+                    transferred += chunk.length;
+                    const pct = Math.round((transferred / transferMetadata.totalSize) * 100);
+                    setProgress(pct);
+                    callback(null, chunk);
+                },
+            });
+            // Build the pipeline: Tar → Compress → Encrypt → Metadata → Progress → Socket
+            // Note: Metadata is added AFTER encryption so it's sent in plaintext
+            const packStream = createPackStream(path);
+            const compressStream = await createCompressStream(shouldCompress(path));
+            const encryptStream = createEncryptStream(encryptionKey);
+            await pipeline(packStream, compressStream, encryptStream, metadataPrepender, progressTracker, socket);
+            console.log('[Sender] Pipeline completed, waiting for socket to close');
+            // Wait for socket to fully close before cleaning up
+            // This ensures the receiver has finished and closed their end
+            await socketClosed;
+            console.log('[Sender] Socket closed, cleaning up swarm');
+            // Transfer complete
+            setState('done');
+            await cleanupSwarm(swarm);
+            if (onComplete) {
+                onComplete();
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+            setError(errorMessage);
+            setState('error');
+            if (onError) {
+                onError(err);
+            }
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, color: "green", children: ["\uD83D\uDCE4 Sending: ", path.split('/').pop()] }), metadata && (_jsxs(Text, { dimColor: true, children: ["Size: ", formatBytes(metadata.totalSize), " | Files: ", metadata.fileCount] })), state === 'init' && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Preparing transfer..." }) })), (state === 'waiting' || state === 'sending') && shareKey && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Share this key with receiver:" }), _jsx(Text, { bold: true, children: shareKey })] })), state === 'waiting' && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Waiting for peer to connect..." }) })), state === 'sending' && progress > 0 && progress < 100 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ProgressBar, { value: progress }), _jsxs(Text, { children: [" ", progress, "%"] })] })), state === 'done' && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Transfer complete!" }), _jsx(Text, { dimColor: true, children: "Press Esc to return" })] })), state === 'error' && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "red", bold: true, children: "\u2717 Transfer failed" }), _jsx(Text, { color: "red", children: error }), _jsx(Text, { dimColor: true, children: "Press Esc to return" })] }))] }));
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}