ezshare-cli 1.0.0

package/dist/components/FileBrowser.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { dirname } from 'node:path';
+import { readDirectory, formatFileSize } from '../utils/fileSystem.js';
+export function FileBrowser({ initialPath = process.cwd(), onSelect, onCancel, }) {
+    const [currentPath, setCurrentPath] = useState(initialPath);
+    const [files, setFiles] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [loading, setLoading] = useState(true);
+    useEffect(() => {
+        loadDirectory(currentPath);
+    }, [currentPath]);
+    const loadDirectory = async (path) => {
+        setLoading(true);
+        try {
+            const entries = await readDirectory(path);
+            // Add ".." entry to go up one level (unless we're at root)
+            const parentDir = dirname(path);
+            if (parentDir !== path) {
+                entries.unshift({
+                    name: '..',
+                    path: parentDir,
+                    isDirectory: true,
+                });
+            }
+            setFiles(entries);
+            setSelectedIndex(0);
+        }
+        catch (error) {
+            console.error('Error loading directory:', error);
+            setFiles([]);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useInput((input, key) => {
+        if (loading)
+            return; // Ignore input while loading
+        if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(files.length - 1, prev + 1));
+        }
+        else if (key.return) {
+            const selected = files[selectedIndex];
+            if (selected) {
+                if (selected.isDirectory) {
+                    // Navigate into directory
+                    setCurrentPath(selected.path);
+                }
+                else {
+                    // File selected!
+                    onSelect(selected.path);
+                }
+            }
+        }
+        else if (key.escape) {
+            onCancel();
+        }
+        else if (input === 's' && selectedIndex < files.length) {
+            // Quick shortcut: 's' to select current file/folder for sending
+            const selected = files[selectedIndex];
+            if (selected && selected.name !== '..') {
+                onSelect(selected.path);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Loading directory..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "cyan", children: ["Current: ", currentPath] }), _jsx(Text, { dimColor: true, children: "\u2191\u2193 to navigate | Enter to open/select | 's' to select | Esc to cancel" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: files.length === 0 ? (_jsx(Text, { dimColor: true, children: "Empty directory" })) : (files.map((file, idx) => (_jsx(Box, { children: _jsxs(Text, { color: idx === selectedIndex ? 'green' : undefined, children: [idx === selectedIndex ? '> ' : '  ', file.isDirectory ? '📁 ' : '📄 ', file.name, file.size !== undefined ? ` (${formatFileSize(file.size)})` : ''] }) }, file.path)))) }), files.length > 10 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Showing ", selectedIndex + 1, " of ", files.length, " items"] }) }))] }));
+}

package/dist/components/HelpScreen.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+export function HelpScreen({ onBack }) {
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            onBack();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "EzShare CLI - Help" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Slash Commands:" }), _jsx(Text, { children: "  /ezshare  - Start interactive file transfer" }), _jsx(Text, { children: "  /help     - Show this help screen" }), _jsx(Text, { children: "  /exit     - Exit the shell" })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Direct CLI Mode:" }), _jsx(Text, { children: "  hyperstream send <path>              - Send file/folder" }), _jsx(Text, { children: "  hyperstream receive <key> [-o dir]   - Receive file/folder" })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Keyboard Shortcuts:" }), _jsx(Text, { children: "  \u2191\u2193        - Navigate menus/files" }), _jsx(Text, { children: "  Enter     - Select/Confirm" }), _jsx(Text, { children: "  Esc       - Cancel/Go back" }), _jsx(Text, { children: "  q         - Quit (from command mode)" })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "How It Works:" }), _jsx(Text, { children: "  1. Sender selects a file/folder to share" }), _jsx(Text, { children: "  2. A unique share key is generated" }), _jsx(Text, { children: "  3. Receiver enters the share key" }), _jsx(Text, { children: "  4. Files are transferred peer-to-peer (P2P)" }), _jsx(Text, { children: "  5. Data is encrypted end-to-end with AES-256-GCM" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Esc or 'q' to return" }) })] }));
+}

package/dist/components/MainMenu.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Select } from '@inkjs/ui';
+export function MainMenu({ onSelect }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "What would you like to do?" }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
+                        { label: '📤 Send file or folder', value: 'send' },
+                        { label: '📥 Receive file or folder', value: 'receive' },
+                    ], onChange: (value) => onSelect(value) }) })] }));
+}

package/dist/components/Shell.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { TextInput } from '@inkjs/ui';
+import { HelpScreen } from './HelpScreen.js';
+import { MainMenu } from './MainMenu.js';
+import { FileBrowser } from './FileBrowser.js';
+import { SendCommand } from '../commands/send.js';
+import { ReceiveCommand } from '../commands/receive.js';
+export function Shell() {
+    const [state, setState] = useState({
+        mode: 'command',
+        history: [],
+    });
+    const handleCommand = (cmd) => {
+        const trimmed = cmd.trim();
+        // Add to history
+        setState((prev) => ({
+            ...prev,
+            history: [...prev.history, trimmed],
+        }));
+        // Process slash commands
+        if (trimmed === '/ezshare') {
+            setState((prev) => ({ ...prev, mode: 'main-menu' }));
+        }
+        else if (trimmed === '/help') {
+            setState((prev) => ({ ...prev, mode: 'help' }));
+        }
+        else if (trimmed === '/exit') {
+            process.exit(0);
+        }
+        else if (trimmed.startsWith('/')) {
+            // Unknown command
+            setState((prev) => ({
+                ...prev,
+                history: [...prev.history, `Unknown command: ${trimmed}`],
+            }));
+        }
+    };
+    const handleMenuSelect = (choice) => {
+        if (choice === 'send') {
+            setState((prev) => ({ ...prev, mode: 'file-browser', transferMode: 'send' }));
+        }
+        else {
+            setState((prev) => ({ ...prev, mode: 'receive-key', transferMode: 'receive' }));
+        }
+    };
+    const handleFileSelect = (path) => {
+        setState((prev) => ({
+            ...prev,
+            mode: 'transfer',
+            selectedPath: path,
+        }));
+    };
+    const handleKeyInput = (key) => {
+        setState((prev) => ({
+            ...prev,
+            mode: 'transfer',
+            transferKey: key,
+        }));
+    };
+    const handleTransferComplete = () => {
+        setState((prev) => ({ ...prev, mode: 'done' }));
+    };
+    const handleTransferError = (error) => {
+        console.error('Transfer error:', error);
+        setState((prev) => ({ ...prev, mode: 'done' }));
+    };
+    const handleCancel = () => {
+        setState((prev) => ({ ...prev, mode: 'command' }));
+    };
+    const handleHelpBack = () => {
+        setState((prev) => ({ ...prev, mode: 'command' }));
+    };
+    // Global keyboard shortcuts
+    useInput((input, key) => {
+        if (input === 'q' && state.mode === 'command') {
+            process.exit(0);
+        }
+        if (key.escape && state.mode !== 'transfer') {
+            setState((prev) => ({ ...prev, mode: 'command' }));
+        }
+        if (key.escape && state.mode === 'done') {
+            setState((prev) => ({ ...prev, mode: 'command' }));
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "EzShare CLI - P2P File Transfer" }), _jsx(Text, { dimColor: true, children: "Type /ezshare to start or /help for commands" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [state.mode === 'command' && (_jsx(TextInput, { placeholder: "Enter command...", onSubmit: handleCommand })), state.mode === 'main-menu' && _jsx(MainMenu, { onSelect: handleMenuSelect }), state.mode === 'file-browser' && (_jsx(FileBrowser, { onSelect: handleFileSelect, onCancel: handleCancel })), state.mode === 'receive-key' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Paste the share key you received:" }), _jsx(TextInput, { placeholder: "Enter share key...", onSubmit: handleKeyInput }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Esc to cancel" }) })] })), state.mode === 'transfer' && state.transferMode === 'send' && state.selectedPath && (_jsx(SendCommand, { path: state.selectedPath, onComplete: handleTransferComplete, onError: handleTransferError })), state.mode === 'transfer' && state.transferMode === 'receive' && state.transferKey && (_jsx(ReceiveCommand, { shareKey: state.transferKey, onComplete: handleTransferComplete, onError: handleTransferError })), state.mode === 'done' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Transfer complete!" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Esc to return to command mode" }) })] })), state.mode === 'help' && _jsx(HelpScreen, { onBack: handleHelpBack })] }), state.history.length > 0 && state.mode === 'command' && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Recent commands:" }), state.history.slice(-3).map((cmd, idx) => (_jsxs(Text, { dimColor: true, children: ['  ', cmd] }, `cmd-${idx}-${cmd}`)))] }))] }));
+}

package/dist/components/TransferUI.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Spinner, ProgressBar } from '@inkjs/ui';
+export function TransferUI({ mode, fileName, fileSize, progress, shareKey, }) {
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, color: mode === 'send' ? 'green' : 'blue', children: [mode === 'send' ? '📤 Sending' : '📥 Receiving', " ", fileName || 'file'] }), mode === 'send' && shareKey && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Share this key with receiver:" }), _jsx(Text, { bold: true, children: shareKey }), progress === 0 && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Waiting for peer to connect..." }) }))] })), mode === 'receive' && progress === 0 && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Connecting to peer..." }) })), progress > 0 && progress < 100 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ProgressBar, { value: progress }), _jsxs(Text, { children: [" ", progress, "%"] })] })), progress === 100 && (_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 to command mode" })] }))] }));
+}

package/dist/utils/compression.js

@@ -0,0 +1,354 @@
+/**
+ * Compression utilities for HyperStream
+ *
+ * Uses zstd for streaming compression with adaptive detection
+ * to skip already-compressed files.
+ *
+ * Stream format:
+ *   [1 byte: flag] [payload...]
+ *
+ *   flag = 0x00: raw data (no compression applied)
+ *   flag = 0x01: zstd compressed data
+ *
+ * The flag makes streams self-describing, allowing the receiver
+ * to automatically detect and handle both cases.
+ */
+import { Transform } from 'node:stream';
+import { extname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { compress, decompress } from 'simple-zstd';
+// Protocol flags
+const FLAG_RAW = 0x00;
+const FLAG_COMPRESSED = 0x01;
+// Default zstd compression level (1-22, 3 is default, good balance)
+const COMPRESSION_LEVEL = 3;
+/**
+ * File extensions that are already compressed.
+ * Compressing these again wastes CPU with minimal size benefit.
+ */
+const COMPRESSED_EXTENSIONS = new Set([
+    // Archives
+    '.zip',
+    '.gz',
+    '.bz2',
+    '.xz',
+    '.7z',
+    '.rar',
+    '.zst',
+    '.lz4',
+    '.lzma',
+    '.tgz',
+    '.tbz2',
+    // Images
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.webp',
+    '.avif',
+    '.heic',
+    '.heif',
+    '.ico',
+    // Video
+    '.mp4',
+    '.mkv',
+    '.avi',
+    '.mov',
+    '.webm',
+    '.m4v',
+    '.wmv',
+    '.flv',
+    '.m2ts',
+    // Audio
+    '.mp3',
+    '.aac',
+    '.flac',
+    '.ogg',
+    '.m4a',
+    '.wma',
+    '.opus',
+    // Documents (Office formats use ZIP internally)
+    '.pdf',
+    '.docx',
+    '.xlsx',
+    '.pptx',
+    '.odt',
+    '.ods',
+    '.odp',
+    '.epub',
+    // Web assets
+    '.woff',
+    '.woff2',
+    '.br', // brotli
+]);
+/**
+ * Check if the system has zstd installed
+ */
+export function isZstdAvailable() {
+    try {
+        execSync('zstd --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file should be compressed based on its extension.
+ *
+ * Returns false for files that are already compressed (images, videos,
+ * archives, etc.) since re-compressing them wastes CPU with minimal benefit.
+ *
+ * @param filePath - Path to the file (only extension is checked)
+ * @returns true if the file should be compressed
+ */
+export function shouldCompress(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return !COMPRESSED_EXTENSIONS.has(ext);
+}
+/**
+ * Create a transform that prepends a flag byte to the stream.
+ */
+function createFlagPrepender(flag) {
+    let flagSent = false;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            if (!flagSent) {
+                this.push(Buffer.from([flag]));
+                flagSent = true;
+            }
+            this.push(chunk);
+            callback();
+        },
+    });
+}
+/**
+ * Create a compression stream.
+ *
+ * When compress=true:
+ *   - Outputs [0x01][zstd-compressed-data]
+ *   - Uses zstd for compression
+ *
+ * When compress=false:
+ *   - Outputs [0x00][raw-data]
+ *   - Simple passthrough with flag prefix
+ *
+ * @param shouldCompress - Whether to actually compress (default: true)
+ * @returns Promise resolving to a Transform stream
+ * @throws Error if zstd is not available and compression is requested
+ */
+export async function createCompressStream(shouldCompress = true) {
+    if (!shouldCompress) {
+        // Simple passthrough with raw flag
+        return createFlagPrepender(FLAG_RAW);
+    }
+    // Check zstd availability
+    if (!isZstdAvailable()) {
+        throw new Error('zstd is not installed. Please install zstd:\n' +
+            '  Ubuntu/Debian: sudo apt install zstd\n' +
+            '  macOS: brew install zstd\n' +
+            '  Windows: choco install zstd');
+    }
+    // Get zstd compression stream
+    const zstdStream = await compress(COMPRESSION_LEVEL);
+    // Track state
+    let flagSent = false;
+    const pendingData = [];
+    let zstdFinished = false;
+    let flushCallback = null;
+    // Collect compressed output from zstd
+    zstdStream.on('data', (chunk) => {
+        pendingData.push(chunk);
+    });
+    zstdStream.on('end', () => {
+        zstdFinished = true;
+        if (flushCallback) {
+            const cb = flushCallback;
+            flushCallback = null;
+            cb();
+        }
+    });
+    zstdStream.on('error', (err) => {
+        if (flushCallback) {
+            const cb = flushCallback;
+            flushCallback = null;
+            cb(err);
+        }
+    });
+    const wrapper = new Transform({
+        transform(chunk, _encoding, callback) {
+            // Write input to zstd
+            zstdStream.write(chunk, (err) => {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                // Push any pending compressed data
+                while (pendingData.length > 0) {
+                    const data = pendingData.shift();
+                    if (!flagSent) {
+                        this.push(Buffer.from([FLAG_COMPRESSED]));
+                        flagSent = true;
+                    }
+                    this.push(data);
+                }
+                callback();
+            });
+        },
+        flush(callback) {
+            // End the zstd stream and wait for all data
+            const pushRemaining = () => {
+                while (pendingData.length > 0) {
+                    const data = pendingData.shift();
+                    if (!flagSent) {
+                        this.push(Buffer.from([FLAG_COMPRESSED]));
+                        flagSent = true;
+                    }
+                    this.push(data);
+                }
+                // Handle edge case: empty input
+                if (!flagSent) {
+                    this.push(Buffer.from([FLAG_COMPRESSED]));
+                }
+                callback();
+            };
+            // Wait for 'end' event which fires after all 'data' events
+            zstdStream.once('end', pushRemaining);
+            zstdStream.end();
+        },
+    });
+    return wrapper;
+}
+/**
+ * Create a decompression stream.
+ *
+ * Automatically detects the compression format based on the first byte:
+ *   - 0x00: passthrough (no decompression)
+ *   - 0x01: zstd decompression
+ *
+ * @returns Promise resolving to a Transform stream
+ */
+export async function createDecompressStream() {
+    let flag = null;
+    let zstdStream = null;
+    let buffer = Buffer.alloc(0);
+    let destroyed = false;
+    const pendingOutput = [];
+    const wrapper = new Transform({
+        transform(chunk, _encoding, callback) {
+            if (destroyed) {
+                return callback();
+            }
+            buffer = Buffer.concat([buffer, chunk]);
+            // Read flag byte if not yet read
+            if (flag === null) {
+                if (buffer.length < 1) {
+                    return callback(); // Need more data
+                }
+                flag = buffer[0];
+                buffer = buffer.subarray(1);
+                // Validate flag
+                if (flag !== FLAG_RAW && flag !== FLAG_COMPRESSED) {
+                    return callback(new Error(`Invalid compression flag: 0x${flag.toString(16)}`));
+                }
+                // Initialize zstd if needed
+                if (flag === FLAG_COMPRESSED) {
+                    if (!isZstdAvailable()) {
+                        return callback(new Error('zstd is not installed but data is compressed'));
+                    }
+                    // Synchronously set up - decompress() returns Promise but we handle async carefully
+                    decompress()
+                        .then((stream) => {
+                        if (destroyed) {
+                            stream.destroy();
+                            return callback();
+                        }
+                        zstdStream = stream;
+                        // Collect decompressed output
+                        stream.on('data', (data) => {
+                            pendingOutput.push(data);
+                        });
+                        stream.on('error', (err) => {
+                            wrapper.destroy(err);
+                        });
+                        // Write any buffered compressed data
+                        if (buffer.length > 0) {
+                            stream.write(buffer, (err) => {
+                                buffer = Buffer.alloc(0);
+                                // Push any output that arrived
+                                while (pendingOutput.length > 0) {
+                                    this.push(pendingOutput.shift());
+                                }
+                                callback(err || undefined);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    })
+                        .catch((err) => {
+                        callback(err);
+                    });
+                    return; // Wait for async initialization
+                }
+            }
+            // Process buffered data
+            if (buffer.length > 0) {
+                if (flag === FLAG_COMPRESSED && zstdStream) {
+                    zstdStream.write(buffer, (err) => {
+                        buffer = Buffer.alloc(0);
+                        // Push any output that arrived
+                        while (pendingOutput.length > 0) {
+                            this.push(pendingOutput.shift());
+                        }
+                        if (err && !destroyed) {
+                            callback(err);
+                        }
+                        else {
+                            callback();
+                        }
+                    });
+                }
+                else if (flag === FLAG_RAW) {
+                    this.push(buffer);
+                    buffer = Buffer.alloc(0);
+                    callback();
+                }
+                else {
+                    callback();
+                }
+            }
+            else {
+                // Push any pending output
+                while (pendingOutput.length > 0) {
+                    this.push(pendingOutput.shift());
+                }
+                callback();
+            }
+        },
+        flush(callback) {
+            if (zstdStream) {
+                // Wait for 'end' event which fires after all 'data' events
+                zstdStream.once('end', () => {
+                    // Push any remaining output
+                    while (pendingOutput.length > 0) {
+                        this.push(pendingOutput.shift());
+                    }
+                    callback();
+                });
+                zstdStream.end();
+            }
+            else {
+                callback();
+            }
+        },
+        destroy(err, callback) {
+            destroyed = true;
+            if (zstdStream) {
+                zstdStream.destroy();
+            }
+            callback(err);
+        },
+    });
+    return wrapper;
+}