molex-ftp-client 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Tony Wiedman / MolexWorks
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,398 @@
+# molex-ftp-client
+
+Lightweight FTP client built with native Node.js TCP sockets (net module).
+
+## 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
+- ✅ **Directory operations** (list, cd, mkdir, pwd)
+- ✅ **File operations** (delete, rename, size, exists, modifiedTime)
+- ✅ **Connection statistics** - Track command count and status
+
+## Installation
+
+```bash
+npm install molex-ftp-client
+```
+
+## Quick Start
+
+```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)
+});
+
+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);
+}
+```
+
+## 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
+});
+```
+
+## API
+
+### Connection
+
+#### `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@'
+});
+```
+
+Returns: `Promise<void>`
+
+#### `close()` / `disconnect()`
+
+Close connection to FTP server.
+
+```javascript
+await client.close();
+```
+
+Returns: `Promise<void>`
+
+### File Operations
+
+#### `upload(data, remotePath)`
+
+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');
+```
+
+Returns: `Promise<void>`
+
+#### `download(remotePath)`
+
+Download file from server.
+
+```javascript
+const data = await client.download('/path/file.txt');
+console.log(data.toString()); // Convert Buffer to string
+```
+
+Returns: `Promise<Buffer>`
+
+#### `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');
+```
+
+Returns: `Promise<void>`
+
+#### `size(path)`
+
+Get file size in bytes.
+
+```javascript
+const bytes = await client.size('/path/file.txt');
+console.log(`File size: ${bytes} bytes`);
+```
+
+Returns: `Promise<number>`
+
+#### `exists(path)`
+
+Check if file exists.
+
+```javascript
+const exists = await client.exists('/path/file.txt');
+console.log(exists ? 'File exists' : 'File not found');
+```
+
+Returns: `Promise<boolean>`
+
+#### `modifiedTime(path)`
+
+Get file modification time.
+
+```javascript
+const date = await client.modifiedTime('/path/file.txt');
+console.log(`Last modified: ${date.toISOString()}`);
+```
+
+Returns: `Promise<Date>`
+
+### Directory Operations
+
+#### `list(path)`
+
+List directory contents.
+
+```javascript
+const listing = await client.list('/remote/path');
+console.log(listing);
+```
+
+Returns: `Promise<string>` - Raw directory listing
+
+#### `cd(path)`
+
+Change working directory.
+
+```javascript
+await client.cd('/remote/path');
+```
+
+Returns: `Promise<void>`
+
+#### `pwd()`
+
+Get current working directory.
+
+```javascript
+const dir = await client.pwd();
+console.log(`Current directory: ${dir}`);
+```
+
+Returns: `Promise<string>`
+
+#### `mkdir(path)`
+
+Create directory.
+
+```javascript
+await client.mkdir('/remote/newdir');
+```
+
+Returns: `Promise<void>`
+
+### Utilities
+
+#### `getStats()`
+
+Get connection statistics.
+
+```javascript
+const stats = client.getStats();
+console.log(stats);
+// {
+//   connected: true,
+//   authenticated: true,
+//   commandCount: 5,
+//   lastCommand: 'LIST .'
+// }
+```
+
+Returns: `Object`
+
+#### `setDebug(enabled)`
+
+Enable or disable debug mode at runtime.
+
+```javascript
+client.setDebug(true);  // Enable debug logging
+client.setDebug(false); // Disable debug logging
+```
+
+## 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');
+});
+```
+
+## Debug Mode
+
+Enable debug logging to troubleshoot FTP issues:
+
+```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
+// [FTP Debug] <<< 220 Welcome to FTP server
+// [FTP Debug] >>> USER user
+// [FTP Debug] <<< 331 Password required
+// [FTP Debug] >>> PASS ********
+// [FTP Debug] <<< 230 Login successful
+// [FTP Debug] Authentication successful
+```
+
+## 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
+
+```javascript
+const FTPClient = require('molex-ftp-client');
+
+async function backupFile() {
+  const client = new FTPClient({ 
+    debug: true,
+    timeout: 60000 
+  });
+
+  try {
+    // Connect
+    await client.connect({
+      host: 'ftp.myserver.com',
+      port: 21,
+      user: 'admin',
+      password: 'secret123'
+    });
+
+    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');
+    }
+
+    // Upload new backup
+    const newData = JSON.stringify({ timestamp: Date.now(), data: [1, 2, 3] });
+    await client.upload(newData, '/backup/data.json');
+    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
+    await client.close();
+  } catch (err) {
+    console.error('Backup failed:', err.message);
+    await client.close();
+  }
+}
+
+backupFile();
+```
+
+## License
+
+ISC © Tony Wiedman / MolexWorks
+

package/index.js

@@ -0,0 +1,476 @@
+const net = require('net');
+const { EventEmitter } = require('events');
+
+/**
+ * Lightweight FTP Client using native Node.js TCP sockets (net module)
+ */
+class FTPClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.socket = null;
+    this.dataSocket = null;
+    this.buffer = '';
+    this.connected = false;
+    this.authenticated = false;
+    this.debug = options.debug || false;
+    this.timeout = options.timeout || 30000;
+    this.keepAlive = options.keepAlive !== false;
+    this._log = options.logger || console.log;
+    this._commandCount = 0;
+    this._lastCommand = null;
+  }
+
+  /**
+   * Log message if debug is enabled
+   * @private
+   */
+  _debug(...args) {
+    if (this.debug && this._log) {
+      this._log('[FTP Debug]', ...args);
+    }
+  }
+
+  /**
+   * Connect to FTP server
+   * @param {Object} options - Connection options
+   * @param {string} options.host - FTP server host
+   * @param {number} [options.port=21] - FTP server port
+   * @param {string} [options.user='anonymous'] - Username
+   * @param {string} [options.password='anonymous@'] - Password
+   * @returns {Promise<void>}
+   */
+  async connect({ host, port = 21, user = 'anonymous', password = 'anonymous@' }) {
+    this._debug(`Connecting to ${host}:${port} as ${user}`);
+    return new Promise((resolve, reject) => {
+      this.socket = net.createConnection({ host, port }, () => {
+        this.connected = true;
+        this._debug('TCP connection established');
+        if (this.keepAlive) {
+          this.socket.setKeepAlive(true, 10000);
+        }
+        this.emit('connected');
+      });
+
+      this.socket.setEncoding('utf8');
+      this.socket.on('data', async (data) => {
+        this.buffer += data;
+        const lines = this.buffer.split('\r\n');
+        this.buffer = lines.pop();
+
+        for (const line of lines) {
+          if (line) {
+            this._debug('<<<', line);
+            this.emit('response', line);
+            const code = parseInt(line.substring(0, 3));
+
+            // Handle initial connection
+            if (code === 220 && !this.authenticated) {
+              try {
+                this._debug('Authenticating...');
+                await this._sendCommand(`USER ${user}`);
+                await this._sendCommand(`PASS ${password}`);
+                this.authenticated = true;
+                this._debug('Authentication successful');
+                resolve();
+              } catch (err) {
+                reject(err);
+              }
+            }
+          }
+        }
+      });
+
+      this.socket.on('error', (err) => {
+        this.emit('error', err);
+        reject(err);
+      });
+
+      this.socket.on('close', () => {
+        this.connected = false;
+        this.authenticated = false;
+        this.emit('close');
+      });
+
+      setTimeout(() => reject(new Error('Connection timeout')), 10000);
+    });
+  }
+
+  /**
+   * Send FTP command and wait for response
+   * @param {string} command - FTP command
+   * @param {boolean} allowPreliminary - Allow 1xx preliminary responses
+   * @returns {Promise<Object>}
+   */
+  _sendCommand(command, allowPreliminary = false) {
+    return new Promise((resolve, reject) => {
+      if (!this.connected) {
+        return reject(new Error('Not connected'));
+      }
+
+      this._commandCount++;
+      this._lastCommand = command;
+      const cmdToLog = command.startsWith('PASS ') ? 'PASS ********' : command;
+      this._debug('>>>', cmdToLog);
+
+      const timeoutId = setTimeout(() => {
+        this.removeListener('response', responseHandler);
+        reject(new Error(`Command timeout: ${cmdToLog}`));
+      }, this.timeout);
+
+      const responseHandler = (line) => {
+        clearTimeout(timeoutId);
+        const code = parseInt(line.substring(0, 3));
+        const message = line.substring(4);
+
+        // Check if this is a complete response (not a multi-line response in progress)
+        if (line.charAt(3) === ' ') {
+          // 1xx = Preliminary positive reply (command okay, another command expected)
+          // 2xx = Positive completion reply
+          // 3xx = Positive intermediate reply (command okay, awaiting more info)
+          // 4xx/5xx = Negative replies (errors)
+          
+          if (code >= 100 && code < 200 && allowPreliminary) {
+            // Don't remove listener, wait for final response
+            this._debug('Preliminary response, waiting for completion...');
+            return;
+          }
+
+          clearTimeout(timeoutId);
+          this.removeListener('response', responseHandler);
+
+          if (code >= 200 && code < 400) {
+            resolve({ code, message, raw: line });
+          } else {
+            this._debug(`Error response: ${code}`);
+            reject(new Error(`FTP Error ${code}: ${message}`));
+          }
+        }
+      };
+
+      this.on('response', responseHandler);
+      this.socket.write(command + '\r\n');
+    });
+  }
+
+  /**
+   * Enter passive mode and get data connection info
+   * @returns {Promise<Object>}
+   */
+  async _enterPassiveMode() {
+    const response = await this._sendCommand('PASV');
+    const match = response.message.match(/\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)/);
+    
+    if (!match) {
+      throw new Error('Failed to parse PASV response');
+    }
+
+    const host = `${match[1]}.${match[2]}.${match[3]}.${match[4]}`;
+    const port = parseInt(match[5]) * 256 + parseInt(match[6]);
+
+    return { host, port };
+  }
+
+  /**
+   * Upload file to FTP server
+   * @param {string|Buffer} data - File data
+   * @param {string} remotePath - Remote file path
+   * @returns {Promise<void>}
+   */
+  async upload(data, remotePath) {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    this._debug(`Uploading ${buffer.length} bytes to ${remotePath}`);
+    const { host, port } = await this._enterPassiveMode();
+
+    return new Promise((resolve, reject) => {
+      let commandSent = false;
+
+      this.dataSocket = net.createConnection({ host, port }, () => {
+        // Send STOR command to start upload (expects 150, then 226)
+        if (!commandSent) {
+          commandSent = true;
+          this._debug(`Data connection established for upload`);
+          this._sendCommand(`STOR ${remotePath}`, true).catch(reject);
+          
+          // Write data to data socket
+          this.dataSocket.write(buffer);
+          this.dataSocket.end();
+        }
+      });
+
+      this.dataSocket.on('error', reject);
+
+      this.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.removeListener('response', finalHandler);
+            this._debug(`Upload completed successfully`);
+            resolve();
+          } else if (code >= 400) {
+            this.removeListener('response', finalHandler);
+            reject(new Error(`FTP Error ${code}: ${line.substring(4)}`));
+          }
+        };
+        this.on('response', finalHandler);
+        
+        // Timeout if no response
+        setTimeout(() => {
+          this.removeListener('response', finalHandler);
+          resolve();
+        }, 5000);
+      });
+    });
+  }
+
+  /**
+   * Download file from FTP server
+   * @param {string} remotePath - Remote file path
+   * @returns {Promise<Buffer>}
+   */
+  async download(remotePath) {
+    this._debug(`Downloading ${remotePath}`);
+    const { host, port } = await this._enterPassiveMode();
+
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let commandSent = false;
+
+      this.dataSocket = net.createConnection({ host, port }, () => {
+        // Send RETR command to start download (expects 150, then 226)
+        if (!commandSent) {
+          commandSent = true;
+          this._debug(`Data connection established for download`);
+          this._sendCommand(`RETR ${remotePath}`, true).catch(reject);
+        }
+      });
+
+      this.dataSocket.on('data', (chunk) => {
+        chunks.push(chunk);
+        this._debug(`Received ${chunk.length} bytes`);
+      });
+
+      this.dataSocket.on('error', reject);
+
+      this.dataSocket.on('close', () => {
+        // Wait for final 226 response
+        const finalHandler = (line) => {
+          const code = parseInt(line.substring(0, 3));
+          if (code === 226 || code === 250) {
+            this.removeListener('response', finalHandler);
+            const result = Buffer.concat(chunks);
+            this._debug(`Download completed: ${result.length} bytes`);
+            resolve(result);
+          } else if (code >= 400) {
+            this.removeListener('response', finalHandler);
+            reject(new Error(`FTP Error ${code}: ${line.substring(4)}`));
+          }
+        };
+        this.on('response', finalHandler);
+        
+        // Timeout if no response
+        setTimeout(() => {
+          this.removeListener('response', finalHandler);
+          if (chunks.length > 0) {
+            resolve(Buffer.concat(chunks));
+          }
+        }, 5000);
+      });
+    });
+  }
+
+  /**
+   * List directory contents
+   * @param {string} [path='.'] - Directory path
+   * @returns {Promise<string>}
+   */
+  async list(path = '.') {
+    this._debug(`Listing directory: ${path}`);
+    const { host, port } = await this._enterPassiveMode();
+
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let commandSent = false;
+
+      this.dataSocket = net.createConnection({ host, port }, () => {
+        if (!commandSent) {
+          commandSent = true;
+          this._sendCommand(`LIST ${path}`, true).catch(reject);
+        }
+      });
+
+      this.dataSocket.on('data', (chunk) => {
+        chunks.push(chunk);
+      });
+
+      this.dataSocket.on('error', reject);
+
+      this.dataSocket.on('close', () => {
+        // Wait for final 226 response
+        const finalHandler = (line) => {
+          const code = parseInt(line.substring(0, 3));
+          if (code === 226 || code === 250) {
+            this.removeListener('response', finalHandler);
+            resolve(Buffer.concat(chunks).toString('utf8'));
+          }
+        };
+        this.on('response', finalHandler);
+        
+        // Timeout fallback
+        setTimeout(() => {
+          this.removeListener('response', finalHandler);
+          resolve(Buffer.concat(chunks).toString('utf8'));
+        }, 3000);
+      });
+    });
+  }
+
+  /**
+   * Change working directory
+   * @param {string} path - Directory path
+   * @returns {Promise<void>}
+   */
+  async cd(path) {
+    await this._sendCommand(`CWD ${path}`);
+  }
+
+  /**
+   * Get current working directory
+   * @returns {Promise<string>}
+   */
+  async pwd() {
+    const response = await this._sendCommand('PWD');
+    const match = response.message.match(/"(.+)"/);
+    return match ? match[1] : '/';
+  }
+
+  /**
+   * Create directory
+   * @param {string} path - Directory path
+   * @returns {Promise<void>}
+   */
+  async mkdir(path) {
+    await this._sendCommand(`MKD ${path}`);
+  }
+
+  /**
+   * Delete file
+   * @param {string} path - File path
+   * @returns {Promise<void>}
+   */
+  async delete(path) {
+    await this._sendCommand(`DELE ${path}`);
+  }
+
+  /**
+   * Rename file
+   * @param {string} from - Current name
+   * @param {string} to - New name
+   * @returns {Promise<void>}
+   */
+  async rename(from, to) {
+    await this._sendCommand(`RNFR ${from}`);
+    await this._sendCommand(`RNTO ${to}`);
+  }
+
+  /**
+   * Get file size
+   * @param {string} path - File path
+   * @returns {Promise<number>}
+   */
+  async size(path) {
+    this._debug(`Getting size of ${path}`)
+    const response = await this._sendCommand(`SIZE ${path}`);
+    return parseInt(response.message);
+  }
+
+  /**
+   * Check if file or directory exists
+   * @param {string} path - File or directory path
+   * @returns {Promise<boolean>}
+   */
+  async exists(path) {
+    try {
+      await this.size(path);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Get file modification time
+   * @param {string} path - File path
+   * @returns {Promise<Date>}
+   */
+  async modifiedTime(path) {
+    this._debug(`Getting modification time of ${path}`);
+    const response = await this._sendCommand(`MDTM ${path}`);
+    // Parse MDTM response: YYYYMMDDhhmmss
+    const match = response.message.match(/(\d{14})/);
+    if (match) {
+      const str = match[1];
+      const year = parseInt(str.substring(0, 4));
+      const month = parseInt(str.substring(4, 6)) - 1;
+      const day = parseInt(str.substring(6, 8));
+      const hour = parseInt(str.substring(8, 10));
+      const minute = parseInt(str.substring(10, 12));
+      const second = parseInt(str.substring(12, 14));
+      return new Date(Date.UTC(year, month, day, hour, minute, second));
+    }
+    throw new Error('Failed to parse MDTM response');
+  }
+
+  /**
+   * Get connection statistics
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      connected: this.connected,
+      authenticated: this.authenticated,
+      commandCount: this._commandCount,
+      lastCommand: this._lastCommand
+    };
+  }
+
+  /**
+   * Enable or disable debug mode
+   * @param {boolean} enabled - Enable debug mode
+   */
+  setDebug(enabled) {
+    this.debug = enabled;
+    this._debug(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
+  }
+
+  /**
+   * Close connection
+   * @returns {Promise<void>}
+   */
+  async close() {
+    if (this.connected) {
+      this._debug('Closing connection...');
+      try {
+        await this._sendCommand('QUIT');
+      } catch (err) {
+        this._debug('Error during QUIT:', err.message);
+      }
+      this.socket.end();
+      this.connected = false;
+      this.authenticated = false;
+      this._debug('Connection closed');
+    }
+  }
+
+  /**
+   * Disconnect (alias for close)
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    return this.close();
+  }
+}
+
+module.exports = FTPClient;
+module.exports.FTPClient = FTPClient;
+module.exports.default = FTPClient;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "molex-ftp-client",
+  "version": "1.0.0",
+  "description": "Lightweight FTP client using native Node.js TCP sockets (net module) with zero dependencies",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "ftp",
+    "client",
+    "tcp",
+    "net",
+    "native",
+    "zero-dependencies",
+    "upload",
+    "download",
+    "file-transfer",
+    "passive-mode"
+  ],
+  "author": "Tony Wiedman",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/molexworks/ftp-client"
+  },
+  "bugs": {
+    "url": "https://github.com/molexworks/ftp-client/issues"
+  },
+  "homepage": "https://github.com/molexworks/ftp-client#readme",
+  "engines": {
+    "node": ">=12.0.0"
+  }
+}