ezshare-cli 1.0.1 → 1.0.3

package/dist/commands/receive.js

@@ -4,10 +4,23 @@ import { Box, Text } from 'ink';
 import { Spinner, ProgressBar } from '@inkjs/ui';
 import { pipeline } from 'node:stream/promises';
 import { Transform } from 'node:stream';
+import { appendFileSync } from 'node:fs';
 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';
+// Debug logging to file (Ink captures stdout)
+const LOG_FILE = '/tmp/ezshare_debug.log';
+function debugLog(message) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+    try {
+        appendFileSync(LOG_FILE, logLine);
+    }
+    catch (e) {
+        // Ignore file errors
+    }
+}
 export function ReceiveCommand({ shareKey, outputPath = process.cwd(), onComplete, onError }) {
     const [state, setState] = useState('connecting');
     const [progress, setProgress] = useState(0);
@@ -26,16 +39,16 @@ export function ReceiveCommand({ shareKey, outputPath = process.cwd(), onComplet
             const { swarm, connectionPromise } = await createReceiverSwarm(topic);
             // Wait for peer connection (listener already registered)
             const socket = await connectionPromise;
-            console.log('[Receiver] Connected to sender');
+            debugLog('[Receiver] Connected to sender');
             // Add socket error handler
             socket.on('error', (err) => {
-                console.error('[Receiver] Socket error:', err);
+                debugLog('[Receiver] Socket error: ' + err);
             });
             socket.on('end', () => {
-                console.log('[Receiver] Socket end event received');
+                debugLog('[Receiver] Socket end event received');
             });
             socket.on('close', () => {
-                console.log('[Receiver] Socket closed');
+                debugLog('[Receiver] Socket closed');
             });
             // Read metadata first (JSON header followed by newline)
             const metadataBuffer = [];
@@ -52,19 +65,19 @@ export function ReceiveCommand({ shareKey, outputPath = process.cwd(), onComplet
                             // Found metadata
                             try {
                                 const metadataJson = combined.slice(0, newlineIndex).toString();
-                                console.log('[Receiver] Received metadata:', metadataJson);
+                                debugLog('[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`);
+                                debugLog(`[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);
+                                debugLog('[Receiver] Failed to parse metadata: ' + err);
                                 callback(err);
                                 return;
                             }
@@ -91,18 +104,18 @@ export function ReceiveCommand({ shareKey, outputPath = process.cwd(), onComplet
             });
             // Start receiving
             setState('receiving');
-            console.log('[Receiver] Starting receive pipeline');
+            debugLog('[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');
+            debugLog('[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');
+            debugLog('[Receiver] Cleaning up receiver swarm');
             await cleanupSwarm(swarm);
             if (onComplete) {
                 onComplete();

package/dist/commands/send.js

@@ -4,10 +4,23 @@ import { Box, Text } from 'ink';
 import { Spinner, ProgressBar } from '@inkjs/ui';
 import { pipeline } from 'node:stream/promises';
 import { Transform } from 'node:stream';
+import { appendFileSync } from 'node:fs';
 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';
+// Debug logging to file (Ink captures stdout)
+const LOG_FILE = '/tmp/ezshare_debug.log';
+function debugLog(message) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+    try {
+        appendFileSync(LOG_FILE, logLine);
+    }
+    catch (e) {
+        // Ignore file errors
+    }
+}
 export function SendCommand({ path, onComplete, onError }) {
     const [state, setState] = useState('init');
     const [shareKey, setShareKey] = useState('');
@@ -32,14 +45,18 @@ export function SendCommand({ path, onComplete, onError }) {
             });
             // Create sender swarm
             setState('waiting');
+            debugLog('[Sender] About to call createSenderSwarm');
             const { swarm, waitForPeer } = await createSenderSwarm(topic);
+            debugLog('[Sender] createSenderSwarm completed, got waitForPeer function');
             // Wait for peer connection
+            debugLog('[Sender] Calling waitForPeer()...');
             const socket = await waitForPeer();
+            debugLog('[Sender] Got socket from 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');
+                    debugLog('[Sender] Socket closed');
                     resolve();
                 });
             });
@@ -47,9 +64,10 @@ export function SendCommand({ path, onComplete, onError }) {
             socket.on('error', (err) => {
                 console.error('[Sender] Socket error:', err);
             });
+            debugLog('[Sender] About to set state to sending');
             // Peer connected! Start sending
             setState('sending');
-            console.log('[Sender] Starting transfer pipeline');
+            debugLog('[Sender] Starting transfer pipeline');
             // Create metadata prepend stream
             const metadataJson = JSON.stringify({
                 totalSize: transferMetadata.totalSize,
@@ -84,11 +102,11 @@ export function SendCommand({ path, onComplete, onError }) {
             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');
+            debugLog('[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');
+            debugLog('[Sender] Socket closed, cleaning up swarm');
             // Transfer complete
             setState('done');
             await cleanupSwarm(swarm);

package/dist/utils/compression.js

@@ -16,7 +16,14 @@
 import { Transform } from 'node:stream';
 import { extname } from 'node:path';
 import { execSync } from 'node:child_process';
-import { compress, decompress } from 'simple-zstd/dist/index.mjs';
+// Dynamic import to handle CommonJS module from ES module context
+let zstdModule = null;
+async function getZstdModule() {
+    if (!zstdModule) {
+        zstdModule = await import('simple-zstd');
+    }
+    return zstdModule;
+}
 // Protocol flags
 const FLAG_RAW = 0x00;
 const FLAG_COMPRESSED = 0x01;
@@ -150,6 +157,7 @@ export async function createCompressStream(shouldCompress = true) {
             '  Windows: choco install zstd');
     }
     // Get zstd compression stream
+    const { compress } = await getZstdModule();
     const zstdStream = await compress(COMPRESSION_LEVEL);
     // Track state
     let flagSent = false;
@@ -257,7 +265,8 @@ export async function createDecompressStream() {
                         return callback(new Error('zstd is not installed but data is compressed'));
                     }
                     // Synchronously set up - decompress() returns Promise but we handle async carefully
-                    decompress()
+                    getZstdModule()
+                        .then(({ decompress }) => decompress())
                         .then((stream) => {
                         if (destroyed) {
                             stream.destroy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezshare-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Secure P2P file transfer CLI with end-to-end encryption - No servers, no signups, just share",
   "type": "module",
   "bin": {