molex-ftp-client 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [2.1.0] - 2026-02-02
+
+### Added
+- `stat()` method returns detailed file/directory information: `{ exists, size, isFile, isDirectory }`
+
+### Changed
+- **Simplified performance system** - removed over-engineered preset configuration
+- TCP optimizations (TCP_NODELAY, keep-alive) now applied by default at socket creation
+- `createOptimizedSocket()` replaces repeated `optimizeSocket()` calls for cleaner code
+- Updated `exists()` to use new `stat()` method internally
+
+### Removed
+- Performance presets (LOW_LATENCY, HIGH_THROUGHPUT, BALANCED) - unnecessary complexity
+- `performancePreset` and `performance` constructor options
+- `getOptimalChunkSize()` function - Node.js doesn't expose socket buffer controls
+
 ## [2.0.0] - 2026-02-02
 
 ### Breaking Changes
@@ -8,9 +24,6 @@
 
 ### Added
 - **Performance optimization system** with TCP tuning (inspired by HFT practices)
-  - `TCP_NODELAY` support to disable Nagle's algorithm for lower latency
-  - Configurable socket buffer sizes for optimal throughput
-  - Performance presets: `LOW_LATENCY`, `HIGH_THROUGHPUT`, `BALANCED`
 - `downloadStream()` method for memory-efficient large file transfers
 - `isConnected()` method to check connection and authentication status
 - Parameter validation for `connect()`, `upload()`, and `download()`

package/README.md

@@ -1,28 +1,15 @@
 # molex-ftp-client
 
-Lightweight FTP client built with native Node.js TCP sockets (net module).
+Lightweight FTP client built with native Node.js TCP sockets. Zero dependencies, optimized for performance.
 
 ## Features
 
-- ✅ **Zero dependencies** - Uses only native Node.js modules
-- ✅ **Promise-based API** - Modern async/await support
-- ✅ **Passive mode** (PASV) for data transfers
-- ✅ **Debug logging** - Optional verbose logging for troubleshooting
-- ✅ **Connection keep-alive** - Automatic TCP keep-alive
-- ✅ **Configurable timeouts** - Prevent hanging connections
-- ✅ **Event-based** - Listen to FTP responses and events
-- ✅ **Upload/download** files with Buffer support
-- ✅ **Smart directory management** - Auto-create nested directories
-- ✅ **Directory operations** (list, cd, mkdir, pwd, ensureDir)
-- ✅ **File operations** (delete, rename, size, exists, modifiedTime)
-- ✅ **Robust exists()** - Properly detects both files and directories
-- ✅ **Connection validation** - Automatic state checking before operations
-- ✅ **Enhanced error messages** - Include context for better debugging
-- ✅ **High-performance TCP** - Optimized socket settings (TCP_NODELAY, buffer tuning)
-- ✅ **Performance presets** - LOW_LATENCY, HIGH_THROUGHPUT, BALANCED modes
-- ✅ **Streaming downloads** - Memory-efficient for large files
-- ✅ **Connection statistics** - Track command count and status
-- ✅ **Clean architecture** - Modular structure with separation of concerns
+- **Zero dependencies** - Uses only native Node.js modules
+- **Promise-based API** - Modern async/await support
+- **TCP optimizations** - TCP_NODELAY and keep-alive applied by default
+- **Auto-create directories** - Upload files to nested paths automatically
+- **Streaming support** - Memory-efficient downloads for large files
+- **Full FTP support** - Upload, download, list, delete, rename, stat, and more
 
 ## Installation
 
@@ -35,384 +22,166 @@ npm install molex-ftp-client
 ```javascript
 const FTPClient = require('molex-ftp-client');
 
-const client = new FTPClient({
-  debug: true,           // Enable debug logging (default: false)
-  timeout: 30000,        // Command timeout in ms (default: 30000)
-  keepAlive: true        // Enable TCP keep-alive (default: true)
+const client = new FTPClient();
+
+await client.connect({
+  host: 'ftp.example.com',
+  user: 'username',
+  password: 'password'
 });
 
-try {
-  // Connect to FTP server
-  await client.connect({
-    host: 'ftp.example.com',
-    port: 21,
-    user: 'username',
-    password: 'password'
-  });
-
-  // Upload file
-  await client.upload('Hello World!', '/remote/path/file.txt');
-
-  // Download file
-  const data = await client.download('/remote/path/file.txt');
-  console.log(data.toString());
-
-  // Close connection
-  await client.close();
-} catch (err) {
-  console.error('FTP Error:', err);
-}
+// Upload with auto-directory creation
+await client.upload('Hello World!', '/path/to/file.txt', true);
+
+// Download
+const data = await client.download('/path/to/file.txt');
+console.log(data.toString());
+
+await client.close();
 ```
 
 ## Constructor Options
 
 ```javascript
 const client = new FTPClient({
-  debug: false,                      // Enable debug logging
-  timeout: 30000,                    // Command timeout in milliseconds
-  keepAlive: true,                   // Enable TCP keep-alive
-  logger: console.log,               // Custom logger function
-  performancePreset: 'BALANCED',     // Performance preset: LOW_LATENCY, HIGH_THROUGHPUT, BALANCED
-  performance: {                     // Custom performance tuning (overrides preset)
-    noDelay: true,                   // TCP_NODELAY - disable Nagle's algorithm
-    sendBufferSize: 65536,          // SO_SNDBUF in bytes
-    receiveBufferSize: 65536,       // SO_RCVBUF in bytes
-    keepAlive: true,                // TCP keep-alive
-    keepAliveDelay: 10000           // Keep-alive delay in ms
-  }
+  debug: false,       // Enable debug logging
+  timeout: 30000,     // Command timeout in milliseconds (default: 30000)
+  logger: console.log // Custom logger function
 });
 ```
 
-### Performance Presets
-
-Choose a preset based on your use case:
+## API Reference
 
-- **`LOW_LATENCY`** - Optimized for small files and interactive operations (fastest response)
-- **`HIGH_THROUGHPUT`** - Optimized for large file transfers (maximum bandwidth)
-- **`BALANCED`** - Good default for most use cases (recommended)
-
-```javascript
-// For small files like privileges.xml
-const client = new FTPClient({ performancePreset: 'LOW_LATENCY' });
-
-// For large backups or video files
-const client = new FTPClient({ performancePreset: 'HIGH_THROUGHPUT' });
-```
-
-## API
-
-### Connection
+### Connection Methods
 
 #### `connect(options)`
-
-Connect to FTP server.
-
 ```javascript
 await client.connect({
-  host: 'ftp.example.com',  // Required
-  port: 21,                  // Default: 21
-  user: 'username',          // Default: 'anonymous'
-  password: 'password'       // Default: 'anonymous@'
+  host: 'ftp.example.com',    // Required
+  port: 21,                    // Default: 21
+  user: 'username',            // Default: 'anonymous'
+  password: 'password'         // Default: 'anonymous@'
 });
 ```
 
-Returns: `Promise<void>`
-
-#### `close()` / `disconnect()`
-
-Close connection to FTP server.
-
+#### `close()`
 ```javascript
 await client.close();
 ```
 
-Returns: `Promise<void>`
-
-### File Operations
+### File Methods
 
 #### `upload(data, remotePath, ensureDir)`
-
-Upload file to server.
-
 ```javascript
-// Upload string
-await client.upload('Hello World!', '/path/file.txt');
-
-// Upload Buffer
-const buffer = Buffer.from('data');
-await client.upload(buffer, '/path/file.bin');
-
-// Upload with automatic directory creation (recommended for nested paths)
-await client.upload('data', '/deep/nested/path/file.txt', true);
+await client.upload('content', '/path/file.txt');           // Basic upload
+await client.upload(buffer, '/path/file.bin');              // Upload Buffer
+await client.upload('content', '/deep/path/file.txt', true); // Auto-create dirs
 ```
 
-**Parameters:**
-- `data` (string|Buffer): File content
-- `remotePath` (string): Remote file path
-- `ensureDir` (boolean): Create parent directories if needed (default: false)
-
-Returns: `Promise<void>`
-
-#### `download(remotePath)`
-
-Download file from server.
-
+#### `download(remotePath)` → `Buffer`
 ```javascript
 const data = await client.download('/path/file.txt');
-console.log(data.toString()); // Convert Buffer to string
 ```
 
-Returns: `Promise<Buffer>`
-
-#### `downloadStream(remotePath, writeStream)`
-
-Download file as a stream (memory efficient for large files).
-
+#### `downloadStream(remotePath, writeStream)` → `number` (bytes)
 ```javascript
 const fs = require('fs');
-
-// Stream large file directly to disk
-const writeStream = fs.createWriteStream('./local-file.bin');
-const bytesTransferred = await client.downloadStream('/large-file.bin', writeStream);
-console.log(`Downloaded ${bytesTransferred} bytes`);
-
-// Stream to any writable stream
-const { PassThrough } = require('stream');
-const stream = new PassThrough();
-stream.on('data', (chunk) => {
-  console.log(`Received ${chunk.length} bytes`);
-});
-await client.downloadStream('/file.txt', stream);
+const stream = fs.createWriteStream('./local.bin');
+const bytes = await client.downloadStream('/remote.bin', stream);
 ```
 
-**Use this for:** Large files where you don't want to buffer everything in memory.
-
-Returns: `Promise<number>` - Total bytes transferred
-
 #### `delete(path)`
-
-Delete file.
-
 ```javascript
 await client.delete('/path/file.txt');
 ```
 
-Returns: `Promise<void>`
-
 #### `rename(from, to)`
-
-Rename or move file.
-
 ```javascript
-await client.rename('/old/path.txt', '/new/path.txt');
+await client.rename('/old.txt', '/new.txt');
 ```
 
-Returns: `Promise<void>`
-
-#### `size(path)`
-
-Get file size in bytes.
-
+#### `exists(path)` → `boolean`
 ```javascript
-const bytes = await client.size('/path/file.txt');
-console.log(`File size: ${bytes} bytes`);
+const exists = await client.exists('/path/file.txt');
 ```
 
-Returns: `Promise<number>`
-
-#### `exists(path)`
-
-Check if file or directory exists.
-
+#### `stat(path)` → `Object`
+Get detailed file/directory information.
 ```javascript
-const fileExists = await client.exists('/path/file.txt');
-console.log(fileExists ? 'File exists' : 'File not found');
-
-const dirExists = await client.exists('/path/to/directory');
-console.log(dirExists ? 'Directory exists' : 'Directory not found');
+const info = await client.stat('/path/file.txt');
+// { exists: true, size: 1024, isFile: true, isDirectory: false }
 ```
 
-Returns: `Promise<boolean>`
-
-#### `modifiedTime(path)`
-
-Get file modification time.
-
+#### `size(path)` → `number`
 ```javascript
-const date = await client.modifiedTime('/path/file.txt');
-console.log(`Last modified: ${date.toISOString()}`);
+const bytes = await client.size('/path/file.txt');
 ```
 
-Returns: `Promise<Date>`
-
-### Directory Operations
-
-#### `list(path)`
-
-List directory contents.
+### Directory Methods
 
+#### `list(path)` → `string`
 ```javascript
-const listing = await client.list('/remote/path');
-console.log(listing);
+const listing = await client.list('/path');
 ```
 
-Returns: `Promise<string>` - Raw directory listing
-
-#### `cd(path)`
-
-Change working directory.
-
+#### `mkdir(path)`
 ```javascript
-await client.cd('/remote/path');
+await client.mkdir('/path/newdir');
 ```
 
-Returns: `Promise<void>`
-
-#### `pwd()`
-
-Get current working directory.
-
+#### `cd(path)`
 ```javascript
-const dir = await client.pwd();
-console.log(`Current directory: ${dir}`);
+await client.cd('/path/to/directory');
 ```
 
-Returns: `Promise<string>`
-
-#### `mkdir(path)`
-
-Create directory.
-
+#### `pwd()` → `string`
 ```javascript
-await client.mkdir('/remote/newdir');
+const currentDir = await client.pwd();
 ```
 
-Returns: `Promise<void>`
-
 #### `ensureDir(dirPath, recursive, isFilePath)`
-
-Ensure directory exists, creating it (and parent directories) if necessary. Idempotent - safe to call multiple times.
-
+Create directory if it doesn't exist, optionally creating parent directories.
 ```javascript
-// Create nested directories recursively (default)
-await client.ensureDir('/deep/nested/path');
-
-// Create single directory only (will fail if parent doesn't exist)
-await client.ensureDir('/newdir', false);
-
-// Ensure parent directory for a file path
-await client.ensureDir('/path/to/file.txt', true, true);
-
-// Idempotent - no error if directory already exists
-await client.ensureDir('/existing/path'); // No error
+await client.ensureDir('/deep/nested/path');              // Create full path
+await client.ensureDir('/path/file.txt', true, true);     // Ensure parent dir for file
 ```
 
-**Parameters:**
-- `dirPath` (string): Directory path or file path to ensure exists
-- `recursive` (boolean): Create parent directories if needed (default: true)
-- `isFilePath` (boolean): If true, ensures parent directory of file path (default: false)
-
-**Use case:** Preparing directory structure before multiple file uploads. For single file uploads, use `upload()` with `ensureDir=true`.
-
-Returns: `Promise<void>`
-
-### Utilities
-
-#### `isConnected()`
-
-Check if client is connected and authenticated.
+### Utility Methods
 
+#### `getState()` → `Object`
+Get current client state for debugging.
 ```javascript
-if (client.isConnected()) {
-  console.log('Ready to execute commands');
-} else {
-  console.log('Not connected');
-}
-```
-
-Returns: `boolean`
-
-#### `getStats()`
-
-Get connection statistics.
-
-```javascript
-const stats = client.getStats();
-console.log(stats);
+const state = client.getState();
 // {
 //   connected: true,
 //   authenticated: true,
-//   commandCount: 5,
-//   lastCommand: 'LIST .'
+//   host: 'ftp.example.com',
+//   ...
 // }
 ```
 
-Returns: `Object`
-
 #### `setDebug(enabled)`
-
-Enable or disable debug mode at runtime.
-
+Toggle debug mode at runtime.
 ```javascript
-client.setDebug(true);  // Enable debug logging
-client.setDebug(false); // Disable debug logging
+client.setDebug(true);
 ```
 
 ## Events
 
-The client extends EventEmitter and emits the following events:
-
-### `connected`
-
-Fired when TCP connection is established.
-
-```javascript
-client.on('connected', () => {
-  console.log('Connected to FTP server');
-});
-```
-
-### `response`
-
-Fired for each FTP response (useful for debugging).
-
-```javascript
-client.on('response', (line) => {
-  console.log('FTP:', line);
-});
-```
-
-### `error`
-
-Fired on connection errors.
-
-```javascript
-client.on('error', (err) => {
-  console.error('FTP Error:', err);
-});
-```
-
-### `close`
-
-Fired when connection is closed.
-
 ```javascript
-client.on('close', () => {
-  console.log('Connection closed');
-});
+client.on('connected', () => console.log('TCP connection established'));
+client.on('response', (line) => console.log('FTP:', line));
+client.on('error', (err) => console.error('Error:', err));
+client.on('close', () => console.log('Connection closed'));
 ```
 
-## Debug Mode
+## Debugging
 
-Enable debug logging to troubleshoot FTP issues:
+Enable debug mode to see all FTP commands and responses:
 
 ```javascript
 const client = new FTPClient({ debug: true });
 
-client.on('response', (line) => {
-  console.log('FTP Response:', line);
-});
-
 await client.connect({ host: 'ftp.example.com', user: 'user', password: 'pass' });
 // [FTP Debug] Connecting to ftp.example.com:21 as user
 // [FTP Debug] TCP connection established
@@ -421,147 +190,70 @@ await client.connect({ host: 'ftp.example.com', user: 'user', password: 'pass' }
 // [FTP Debug] <<< 331 Password required
 // [FTP Debug] >>> PASS ********
 // [FTP Debug] <<< 230 Login successful
-// [FTP Debug] Authentication successful
 ```
 
-## Performance Optimization
-
-This library implements TCP-level optimizations:
-
-### TCP_NODELAY (Nagle's Algorithm)
+## Performance
 
-By default, the client uses `TCP_NODELAY` which disables Nagle's algorithm. This reduces latency by sending packets immediately instead of buffering them.
+TCP optimizations are automatically applied:
+- **TCP_NODELAY** - Disables Nagle's algorithm for lower latency
+- **Keep-alive** - Detects dead connections (10s interval)
 
-**When to use:**
-- Small file transfers
-- Interactive operations
-- When latency matters more than bandwidth
-
-**Trade-off:** Slightly more network overhead, but much faster response times.
-
-### Buffer Sizing
-
-The client optimizes socket buffers based on your use case:
-
-```javascript
-// Low latency (32KB buffers) - fast for small files
-const client = new FTPClient({ performancePreset: 'LOW_LATENCY' });
-
-// High throughput (128KB buffers) - better for large files
-const client = new FTPClient({ performancePreset: 'HIGH_THROUGHPUT' });
-```
-
-### Streaming for Large Files
-
-Use `downloadStream()` for memory-efficient transfers:
+For large files, use `downloadStream()` for memory-efficient transfers:
 
 ```javascript
 const fs = require('fs');
-const writeStream = fs.createWriteStream('./large-backup.zip');
-await client.downloadStream('/backup.zip', writeStream);
+const stream = fs.createWriteStream('./large.zip');
+const bytes = await client.downloadStream('/backup.zip', stream);
+console.log(`Downloaded ${bytes} bytes`);
 ```
 
-**Benefits:**
-- Constant memory usage (no buffering entire file)
-- Start processing data before download completes
-- Better for files > 10MB
-
-### Performance Comparison
-
-For a typical privileges.xml (< 100KB):
-- **Without optimization:** ~150-200ms
-- **With LOW_LATENCY preset:** ~80-120ms
-- **40-50% faster** response time
-
 ## Error Handling
 
-All methods return promises and will reject on errors:
-
 ```javascript
 try {
   await client.upload('data', '/readonly/file.txt');
 } catch (err) {
   if (err.message.includes('FTP Error 550')) {
     console.error('Permission denied');
-  } else {
-    console.error('Upload failed:', err.message);
   }
 }
 ```
 
-## Complete Example
+## Example
 
 ```javascript
 const FTPClient = require('molex-ftp-client');
 
-async function backupFile() {
-  const client = new FTPClient({ 
-    debug: true,
-    timeout: 60000 
-  });
+async function main() {
+  const client = new FTPClient({ debug: true });
 
   try {
-    // Connect
     await client.connect({
-      host: 'ftp.myserver.com',
-      port: 21,
+      host: 'ftp.example.com',
       user: 'admin',
-      password: 'secret123'
+      password: 'secret'
     });
 
-    console.log('Current directory:', await client.pwd());
-
-    // Check if file exists
-    const exists = await client.exists('/backup/data.json');
-    if (exists) {
-      // Download existing file
-      const oldData = await client.download('/backup/data.json');
-      console.log('Old backup size:', oldData.length, 'bytes');
-      
-      // Get modification time
-      const modTime = await client.modifiedTime('/backup/data.json');
-      console.log('Last modified:', modTime.toISOString());
-      
-      // Rename old backup
-      await client.rename('/backup/data.json', '/backup/data.old.json');
+    // Check file info
+    const info = await client.stat('/backup/data.json');
+    if (info.exists) {
+      console.log(`File size: ${info.size} bytes`);
+      const data = await client.download('/backup/data.json');
+      console.log('Downloaded:', data.toString());
     }
 
-    // Upload new backup (with automatic directory creation)
-    const newData = JSON.stringify({ timestamp: Date.now(), data: [1, 2, 3] });
-    await client.upload(newData, '/backup/data.json', true);
-    console.log('Backup uploaded successfully');
-
-    // Verify
-    const size = await client.size('/backup/data.json');
-    console.log('New backup size:', size, 'bytes');
-
-    // Get stats
-    const stats = client.getStats();
-    console.log('Commands executed:', stats.commandCount);
-
-    // Close connection
+    // Upload new file
+    await client.upload('new data', '/backup/updated.json', true);
+    
     await client.close();
   } catch (err) {
-    console.error('Backup failed:', err.message);
-    await client.close();
+    console.error('FTP Error:', err.message);
   }
 }
 
-backupFile();
+main();
 ```
 
-## Architecture
-
-```
-molex-ftp-client/
-├── index.js           # Entry point - exports FTPClient
-├── lib/
-│   ├── FTPClient.js   # Main class definition & public API
-│   ├── connection.js  # Connection & authentication logic
-│   ├── commands.js    # FTP command implementations
-│   └── utils.js       # Helper functions (parsing, paths)
-```
 ## License
 
-ISC © Tony Wiedman / MolexWorks
-
+ISC License

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
@@ -199,6 +196,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

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,10 +31,7 @@ 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;
@@ -90,10 +86,7 @@ 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 }, () => {
         // Send RETR command to start download (expects 150, then 226)
         if (!commandSent) {
           commandSent = true;
@@ -154,10 +147,7 @@ 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`);
@@ -220,10 +210,7 @@ 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);
@@ -321,10 +308,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 +329,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 };
+        }
       }
     }
   }

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.1.0",
   "description": "Lightweight FTP client using native Node.js TCP sockets (net module) with zero dependencies",
   "main": "index.js",
   "scripts": {