molex-ftp-client 2.0.0 → 2.2.0

package/lib/FTPClient.js

@@ -1,7 +1,6 @@
 const { EventEmitter } = require('events');
 const FTPConnection = require('./connection');
 const FTPCommands = require('./commands');
-const { PERFORMANCE_PRESETS } = require('./performance');
 
 /**
  * Lightweight FTP Client using native Node.js TCP sockets (net module)
@@ -25,10 +24,8 @@ class FTPClient extends EventEmitter
     this.keepAlive = options.keepAlive !== false;
     this._log = options.logger || console.log;
 
-    // Performance tuning
-    this.performancePreset = options.performancePreset || 'BALANCED';
-    this.performanceOptions = options.performance ||
-      PERFORMANCE_PRESETS[this.performancePreset] || PERFORMANCE_PRESETS.BALANCED;
+    // Statistics
+    this._commandCount = 0;
     this._lastCommand = null;
 
     // Initialize subsystems
@@ -168,6 +165,17 @@ class FTPClient extends EventEmitter
     return this._commands.delete(path);
   }
 
+  /**
+   * Remove directory
+   * @param {string} path - Directory path
+   * @param {boolean} recursive - Delete all contents recursively (default: false)
+   * @returns {Promise<void>}
+   */
+  async removeDir(path, recursive = false)
+  {
+    return this._commands.removeDir(path, recursive);
+  }
+
   /**
    * Rename file
    * @param {string} from - Current name
@@ -199,6 +207,16 @@ class FTPClient extends EventEmitter
     return this._commands.exists(path);
   }
 
+  /**
+   * Get file/directory information
+   * @param {string} path - Path to check
+   * @returns {Promise<Object>} - { exists, size, isFile, isDirectory }
+   */
+  async stat(path)
+  {
+    return this._commands.stat(path);
+  }
+
   /**
    * Ensure directory exists, creating it if necessary
    * @param {string} dirPath - Directory or file path to ensure exists
@@ -254,6 +272,37 @@ class FTPClient extends EventEmitter
     this._debug(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
   }
 
+  /**
+   * Change file permissions (Unix/Linux servers only)
+   * @param {string} path - File or directory path
+   * @param {string|number} mode - Permissions (e.g., '755', 0755)
+   * @returns {Promise<void>}
+   */
+  async chmod(path, mode)
+  {
+    return this._commands.chmod(path, mode);
+  }
+
+  /**
+   * Execute a SITE command (server-specific commands)
+   * @param {string} command - SITE command to execute
+   * @returns {Promise<Object>}
+   */
+  async site(command)
+  {
+    return this._commands.site(command);
+  }
+
+  /**
+   * Get detailed directory listing with permissions, owner, size, etc.
+   * @param {string} path - Directory path
+   * @returns {Promise<Array>}
+   */
+  async listDetailed(path = '.')
+  {
+    return this._commands.listDetailed(path);
+  }
+
   /**
    * Close connection
    * @returns {Promise<void>}

package/lib/commands.js

@@ -1,6 +1,5 @@
-const net = require('net');
 const { normalizePath, getParentDir, parseMdtmResponse } = require('./utils');
-const { optimizeSocket } = require('./performance');
+const { createOptimizedSocket } = require('./performance');
 
 /**
  * FTP command implementations
@@ -32,15 +31,14 @@ class FTPCommands {
     return new Promise((resolve, reject) => {
       let commandSent = false;
 
-      this.client.dataSocket = net.createConnection({ host, port }, () => {
-        
-        optimizeSocket(this.client.dataSocket, this.client.performanceOptions);
-        
+      this.client.dataSocket = createOptimizedSocket({ host, port }, () => {
         // Send STOR command to start upload (expects 150, then 226)
         if (!commandSent) {
           commandSent = true;
           this.client._debug(`Data connection established for upload`);
-          this.connection.sendCommand(`STOR ${remotePath}`, true).catch(reject);
+          // Just send command, don't wait for completion
+          this.client.socket.write(`STOR ${remotePath}\r\n`);
+          this.client._commandCount++;
           
           // Write data to data socket
           this.client.dataSocket.write(buffer);
@@ -51,25 +49,10 @@ class FTPCommands {
       this.client.dataSocket.on('error', reject);
 
       this.client.dataSocket.on('close', () => {
-        // Wait for final response from control socket
-        const finalHandler = (line) => {
-          const code = parseInt(line.substring(0, 3));
-          if (code === 226 || code === 250) {
-            this.client.removeListener('response', finalHandler);
-            this.client._debug(`Upload completed successfully`);
-            resolve();
-          } else if (code >= 400) {
-            this.client.removeListener('response', finalHandler);
-            reject(new Error(`Upload failed - FTP Error ${code}: ${line.substring(4)} (path: ${remotePath})`));
-          }
-        };
-        this.client.on('response', finalHandler);
-        
-        // Timeout if no response
-        setTimeout(() => {
-          this.client.removeListener('response', finalHandler);
-          resolve();
-        }, this.client.timeout || 5000);
+        // Upload complete
+        this.client._debug(`Upload completed successfully`);
+        // Small delay to let 226 response arrive before next command
+        setTimeout(() => resolve(), 10);
       });
     });
   }
@@ -89,49 +72,40 @@ class FTPCommands {
     return new Promise((resolve, reject) => {
       const chunks = [];
       let commandSent = false;
+      let dataComplete = false;
+      let commandComplete = false;
+
+      const checkComplete = () => {
+        if (dataComplete && commandComplete) {
+          const result = Buffer.concat(chunks);
+          this.client._debug(`Download completed: ${result.length} bytes`);
+          resolve(result);
+        }
+      };
 
-      this.client.dataSocket = net.createConnection({ host, port }, () => {
-        
-        optimizeSocket(this.client.dataSocket, this.client.performanceOptions);
-        
+      this.client.dataSocket = createOptimizedSocket({ host, port }, () => {
         // Send RETR command to start download (expects 150, then 226)
         if (!commandSent) {
           commandSent = true;
           this.client._debug(`Data connection established for download`);
-          this.connection.sendCommand(`RETR ${remotePath}`, true).catch(reject);
+          // Just send command, don't wait for completion - data socket will handle it
+          this.client.socket.write(`RETR ${remotePath}\r\n`);
+          this.client._commandCount++;
         }
       });
 
       this.client.dataSocket.on('data', (chunk) => {
         chunks.push(chunk);
-        this.client._debug(`Received ${chunk.length} bytes`);
       });
 
       this.client.dataSocket.on('error', reject);
 
       this.client.dataSocket.on('close', () => {
-        // Wait for final 226 response
-        const finalHandler = (line) => {
-          const code = parseInt(line.substring(0, 3));
-          if (code === 226 || code === 250) {
-            this.client.removeListener('response', finalHandler);
-            const result = Buffer.concat(chunks);
-            this.client._debug(`Download completed: ${result.length} bytes`);
-            resolve(result);
-          } else if (code >= 400) {
-            this.client.removeListener('response', finalHandler);
-            reject(new Error(`Download failed - FTP Error ${code}: ${line.substring(4)} (path: ${remotePath})`));
-          }
-        };
-        this.client.on('response', finalHandler);
-        
-        // Timeout if no response
-        setTimeout(() => {
-          this.client.removeListener('response', finalHandler);
-          if (chunks.length > 0) {
-            resolve(Buffer.concat(chunks));
-          }
-        }, this.client.timeout || 5000);
+        // Data transfer complete, resolve immediately
+        const result = Buffer.concat(chunks);
+        this.client._debug(`Download completed: ${result.length} bytes`);
+        // Small delay to let 226 response arrive before next command
+        setTimeout(() => resolve(result), 10);
       });
     });
   }
@@ -154,14 +128,13 @@ class FTPCommands {
       let totalBytes = 0;
       let commandSent = false;
 
-      this.client.dataSocket = net.createConnection({ host, port }, () => {
-        
-        optimizeSocket(this.client.dataSocket, this.client.performanceOptions);
-        
+      this.client.dataSocket = createOptimizedSocket({ host, port }, () => {
         if (!commandSent) {
           commandSent = true;
           this.client._debug(`Data connection established for streaming download`);
-          this.connection.sendCommand(`RETR ${remotePath}`, true).catch(reject);
+          // Just send command, don't wait for completion
+          this.client.socket.write(`RETR ${remotePath}\r\n`);
+          this.client._commandCount++;
         }
       });
 
@@ -176,33 +149,11 @@ class FTPCommands {
       });
 
       this.client.dataSocket.on('close', () => {
-        // Wait for final 226 response
-        const finalHandler = (line) => {
-          const code = parseInt(line.substring(0, 3));
-          if (code === 226 || code === 250) {
-            this.client.removeListener('response', finalHandler);
-            writeStream.end();
-            this.client._debug(`Streaming download completed: ${totalBytes} bytes`);
-            resolve(totalBytes);
-          } else if (code >= 400) {
-            this.client.removeListener('response', finalHandler);
-            writeStream.end();
-            reject(new Error(`Download failed - FTP Error ${code}: ${line.substring(4)} (path: ${remotePath})`));
-          }
-        };
-        this.client.on('response', finalHandler);
-        
-        // Timeout if no response
-        setTimeout(() => {
-          this.client.removeListener('response', finalHandler);
-          if (totalBytes > 0) {
-            writeStream.end();
-            resolve(totalBytes);
-          } else {
-            writeStream.end();
-            reject(new Error('Download timeout'));
-          }
-        }, this.client.timeout || 5000);
+        // Streaming complete
+        writeStream.end();
+        this.client._debug(`Streaming download completed: ${totalBytes} bytes`);
+        // Small delay to let 226 response arrive before next command
+        setTimeout(() => resolve(totalBytes), 10);
       });
     });
   }
@@ -220,13 +171,12 @@ class FTPCommands {
       const chunks = [];
       let commandSent = false;
 
-      this.client.dataSocket = net.createConnection({ host, port }, () => {
-        
-        optimizeSocket(this.client.dataSocket, this.client.performanceOptions);
-        
+      this.client.dataSocket = createOptimizedSocket({ host, port }, () => {
         if (!commandSent) {
           commandSent = true;
-          this.connection.sendCommand(`LIST ${path}`, true).catch(reject);
+          // Just send command, don't wait for completion
+          this.client.socket.write(`LIST ${path}\r\n`);
+          this.client._commandCount++;
         }
       });
 
@@ -237,21 +187,9 @@ class FTPCommands {
       this.client.dataSocket.on('error', reject);
 
       this.client.dataSocket.on('close', () => {
-        // Wait for final 226 response
-        const finalHandler = (line) => {
-          const code = parseInt(line.substring(0, 3));
-          if (code === 226 || code === 250) {
-            this.client.removeListener('response', finalHandler);
-            resolve(Buffer.concat(chunks).toString('utf8'));
-          }
-        };
-        this.client.on('response', finalHandler);
-        
-        // Timeout fallback
-        setTimeout(() => {
-          this.client.removeListener('response', finalHandler);
-          resolve(Buffer.concat(chunks).toString('utf8'));
-        }, this.client.timeout || 3000);
+        // Data transfer complete, resolve immediately
+        // Small delay to let 226 response arrive before next command
+        setTimeout(() => resolve(Buffer.concat(chunks).toString('utf8')), 10);
       });
     });
   }
@@ -293,6 +231,57 @@ class FTPCommands {
     await this.connection.sendCommand(`DELE ${path}`);
   }
 
+  /**
+   * Remove directory
+   * @param {string} path - Directory path
+   * @param {boolean} recursive - Delete all contents recursively (default: false)
+   * @returns {Promise<void>}
+   */
+  async removeDir(path, recursive = false) {
+    if (!recursive) {
+      // Remove empty directory only
+      await this.connection.sendCommand(`RMD ${path}`);
+      return;
+    }
+
+    // Recursive delete - get contents and delete everything
+    try {
+      const listing = await this.list(path);
+      const lines = listing.split('\n').filter(line => line.trim());
+      
+      // Process each line - faster than listDetailed
+      for (const line of lines) {
+        // Skip . and .. and empty lines
+        if (!line || line.includes(' .') || line.includes(' ..')) continue;
+        
+        // Extract filename (last part of line)
+        const parts = line.trim().split(/\s+/);
+        const name = parts[parts.length - 1];
+        if (name === '.' || name === '..') continue;
+        
+        const fullPath = `${path}/${name}`.replace(/\/+/g, '/');
+        const isDir = line.startsWith('d');
+        
+        if (isDir) {
+          // Directory - recurse
+          await this.removeDir(fullPath, true);
+        } else {
+          // File - delete
+          try {
+            await this.delete(fullPath);
+          } catch (err) {
+            this.client._debug(`Could not delete file ${fullPath}: ${err.message}`);
+          }
+        }
+      }
+      
+      // Remove the now-empty directory
+      await this.connection.sendCommand(`RMD ${path}`);
+    } catch (err) {
+      throw new Error(`Failed to remove directory ${path}: ${err.message}`);
+    }
+  }
+
   /**
    * Rename file
    * @param {string} from - Current name
@@ -321,10 +310,20 @@ class FTPCommands {
    * @returns {Promise<boolean>}
    */
   async exists(path) {
+    const info = await this.stat(path);
+    return info.exists;
+  }
+
+  /**
+   * Get file/directory information
+   * @param {string} path - Path to check
+   * @returns {Promise<Object>} - { exists, size, isFile, isDirectory }
+   */
+  async stat(path) {
     try {
       // First try SIZE command (works for files)
-      await this.size(path);
-      return true;
+      const size = await this.size(path);
+      return { exists: true, size, isFile: true, isDirectory: false };
     } catch (err) {
       // SIZE failed, might be a directory - try CWD
       try {
@@ -332,10 +331,18 @@ class FTPCommands {
         await this.cd(path);
         // Restore original directory
         await this.cd(currentDir);
-        return true;
+        return { exists: true, size: null, isFile: false, isDirectory: true };
       } catch (cdErr) {
-        // Both SIZE and CWD failed - doesn't exist
-        return false;
+        // Both SIZE and CWD failed - try listing parent directory
+        try {
+          const dir = getParentDir(path);
+          const basename = path.split('/').pop();
+          const listing = await this.list(dir);
+          const found = listing.split('\n').some(line => line.includes(basename));
+          return { exists: found, size: null, isFile: null, isDirectory: null };
+        } catch (listErr) {
+          return { exists: false, size: null, isFile: null, isDirectory: null };
+        }
       }
     }
   }
@@ -401,6 +408,71 @@ class FTPCommands {
     const response = await this.connection.sendCommand(`MDTM ${path}`);
     return parseMdtmResponse(response.message);
   }
+
+  /**
+   * Change file permissions (Unix/Linux servers only)
+   * @param {string} path - File or directory path
+   * @param {string|number} mode - Permissions (e.g., '755', 0755, or 'rwxr-xr-x')
+   * @returns {Promise<void>}
+   */
+  async chmod(path, mode) {
+    // Convert numeric mode to octal string if needed
+    const modeStr = typeof mode === 'number' ? mode.toString(8) : String(mode).replace(/[^0-7]/g, '');
+    
+    if (!/^[0-7]{3,4}$/.test(modeStr)) {
+      throw new Error(`Invalid chmod mode: ${mode}. Use octal format like '755' or 0755`);
+    }
+
+    this.client._debug(`Changing permissions of ${path} to ${modeStr}`);
+    await this.connection.sendCommand(`SITE CHMOD ${modeStr} ${path}`);
+  }
+
+  /**
+   * Execute a SITE command (server-specific commands)
+   * @param {string} command - SITE command to execute (without 'SITE' prefix)
+   * @returns {Promise<Object>}
+   */
+  async site(command) {
+    this.client._debug(`Executing SITE command: ${command}`);
+    return await this.connection.sendCommand(`SITE ${command}`);
+  }
+
+  /**
+   * Parse directory listing into structured objects
+   * @param {string} path - Directory path
+   * @returns {Promise<Array>} Array of file/directory objects
+   */
+  async listDetailed(path = '.') {
+    const listing = await this.list(path);
+    const lines = listing.split('\n').filter(line => line.trim() && !line.startsWith('total'));
+    
+    return lines.map(line => {
+      // Parse Unix-style LIST format
+      const match = line.match(/^([drwxlst-]{10})\s+(\d+)\s+(\S+)\s+(\S+)\s+(\d+)\s+(\S+\s+\S+\s+\S+)\s+(.+)$/);
+      
+      if (match) {
+        const [, perms, links, owner, group, size, date, name] = match;
+        return {
+          name,
+          type: perms[0] === 'd' ? 'directory' : (perms[0] === 'l' ? 'symlink' : 'file'),
+          permissions: perms,
+          owner,
+          group,
+          size: parseInt(size),
+          date,
+          raw: line
+        };
+      }
+      
+      // Fallback for non-standard formats - try to extract name
+      const parts = line.trim().split(/\s+/);
+      return { 
+        name: parts[parts.length - 1], 
+        type: 'unknown',
+        raw: line 
+      };
+    }).filter(item => item.name && item.name !== '.' && item.name !== '..');
+  }
 }
 
 module.exports = FTPCommands;

package/lib/connection.js

@@ -1,5 +1,4 @@
-const net = require('net');
-const { optimizeSocket } = require('./performance');
+const { createOptimizedSocket } = require('./performance');
 
 /**
  * Handle FTP connection establishment and authentication
@@ -22,14 +21,10 @@ class FTPConnection {
     this.client._debug(`Connecting to ${host}:${port} as ${user}`);
     
     return new Promise((resolve, reject) => {
-      this.client.socket = net.createConnection({ host, port }, () => {
+      this.client.socket = createOptimizedSocket({ host, port }, () => {
         this.client.connected = true;
         this.client._debug('TCP connection established');
         
-        // Apply performance optimizations
-        optimizeSocket(this.client.socket, this.client.performanceOptions);
-        this.client._debug('TCP optimizations applied:', this.client.performancePreset);
-        
         this.client.emit('connected');
       });
 

package/lib/performance.js

@@ -1,80 +1,29 @@
 /**
  * TCP Performance optimization utilities
- * Based on high-performance networking best practices
+ * Applies sensible defaults for FTP connections
  */
 
+const net = require('net');
+
 /**
- * Apply performance optimizations to a TCP socket
- * @param {net.Socket} socket - TCP socket to optimize
- * @param {Object} options - Performance options
- * @param {boolean} options.noDelay - Disable Nagle's algorithm (default: true)
- * @param {boolean} options.keepAlive - Enable TCP keep-alive (default: true)
- * @param {number} options.keepAliveDelay - Keep-alive initial delay in ms (default: 10000)
+ * Create an optimized TCP socket connection
+ * Automatically applies TCP_NODELAY and keep-alive
+ * @param {Object} options - Connection options (host, port)
+ * @param {Function} callback - Callback on connection
+ * @returns {net.Socket}
  */
-function optimizeSocket(socket, options = {}) {
-  // Use defaults if options not provided
-  const {
-    noDelay = true,
-    keepAlive = true,
-    keepAliveDelay = 10000
-  } = options || {};
-
+function createOptimizedSocket(options, callback) {
+  const socket = net.createConnection(options, callback);
+  
   // TCP_NODELAY - Disable Nagle's algorithm for lower latency
-  // Critical for interactive applications and small packet transfers
-  // Nagle's algorithm buffers small packets, adding latency
-  if (noDelay) {
-    socket.setNoDelay(true);
-  }
-
+  socket.setNoDelay(true);
+  
   // SO_KEEPALIVE - Detect dead connections
-  if (keepAlive) {
-    socket.setKeepAlive(true, keepAliveDelay);
-  }
-
+  socket.setKeepAlive(true, 10000);
+  
   return socket;
 }
 
-/**
- * Performance presets for different use cases
- */
-const PERFORMANCE_PRESETS = {
-  // Low latency - prioritize speed over bandwidth
-  // Good for small files, interactive operations
-  LOW_LATENCY: {
-    noDelay: true,
-    sendBufferSize: 32768,      // 32KB
-    receiveBufferSize: 32768,   // 32KB
-    keepAlive: true,
-    keepAliveDelay: 5000
-  },
-
-  // High throughput - prioritize bandwidth over latency
-  // Good for large file transfers
-  HIGH_THROUGHPUT: {
-    noDelay: false,             // Allow Nagle's algorithm to batch
-    sendBufferSize: 131072,     // 128KB
-    receiveBufferSize: 131072,  // 128KB
-    keepAlive: true,
-    keepAliveDelay: 30000
-  },
-
-  // Balanced - good default for most use cases
-  BALANCED: {
-    noDelay: true,
-    sendBufferSize: 65536,      // 64KB
-    receiveBufferSize: 65536,   // 64KB
-    keepAlive: true,
-    keepAliveDelay: 10000
-  },
-
-  // Default Node.js behavior
-  DEFAULT: {
-    noDelay: false,
-    keepAlive: false
-  }
-};
-
 module.exports = {
-  optimizeSocket,
-  PERFORMANCE_PRESETS
+  createOptimizedSocket
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "molex-ftp-client",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Lightweight FTP client using native Node.js TCP sockets (net module) with zero dependencies",
   "main": "index.js",
   "scripts": {