molex-ftp-client 1.0.1 → 1.2.1

package/lib/connection.js

@@ -0,0 +1,176 @@
+const net = require('net');
+
+/**
+ * Handle FTP connection establishment and authentication
+ */
+class FTPConnection {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /**
+   * Connect to FTP server and authenticate
+   * @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.client._debug(`Connecting to ${host}:${port} as ${user}`);
+    
+    return new Promise((resolve, reject) => {
+      this.client.socket = net.createConnection({ host, port }, () => {
+        this.client.connected = true;
+        this.client._debug('TCP connection established');
+        
+        if (this.client.keepAlive) {
+          this.client.socket.setKeepAlive(true, 10000);
+        }
+        
+        this.client.emit('connected');
+      });
+
+      this.client.socket.setEncoding('utf8');
+      this.client.socket.on('data', async (data) => {
+        this.client.buffer += data;
+        const lines = this.client.buffer.split('\r\n');
+        this.client.buffer = lines.pop();
+
+        for (const line of lines) {
+          if (line) {
+            this.client._debug('<<<', line);
+            this.client.emit('response', line);
+            const code = parseInt(line.substring(0, 3));
+
+            // Handle initial connection
+            if (code === 220 && !this.client.authenticated) {
+              try {
+                this.client._debug('Authenticating...');
+                await this.sendCommand(`USER ${user}`);
+                await this.sendCommand(`PASS ${password}`);
+                this.client.authenticated = true;
+                this.client._debug('Authentication successful');
+                resolve();
+              } catch (err) {
+                reject(err);
+              }
+            }
+          }
+        }
+      });
+
+      this.client.socket.on('error', (err) => {
+        this.client.emit('error', err);
+        reject(err);
+      });
+
+      this.client.socket.on('close', () => {
+        this.client.connected = false;
+        this.client.authenticated = false;
+        this.client.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) {
+    const { maskPassword } = require('./utils');
+    
+    return new Promise((resolve, reject) => {
+      if (!this.client.connected) {
+        return reject(new Error('Not connected'));
+      }
+
+      this.client._commandCount++;
+      this.client._lastCommand = command;
+      const cmdToLog = maskPassword(command);
+      this.client._debug('>>>', cmdToLog);
+
+      const timeoutId = setTimeout(() => {
+        this.client.removeListener('response', responseHandler);
+        reject(new Error(`Command timeout: ${cmdToLog}`));
+      }, this.client.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.client._debug('Preliminary response, waiting for completion...');
+            return;
+          }
+
+          clearTimeout(timeoutId);
+          this.client.removeListener('response', responseHandler);
+
+          if (code >= 200 && code < 400) {
+            resolve({ code, message, raw: line });
+          } else {
+            this.client._debug(`Error response: ${code}`);
+            reject(new Error(`FTP Error ${code}: ${message}`));
+          }
+        }
+      };
+
+      this.client.on('response', responseHandler);
+      this.client.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 };
+  }
+
+  /**
+   * Close connection
+   * @returns {Promise<void>}
+   */
+  async close() {
+    if (this.client.connected) {
+      this.client._debug('Closing connection...');
+      try {
+        await this.sendCommand('QUIT');
+      } catch (err) {
+        this.client._debug('Error during QUIT:', err.message);
+      }
+      this.client.socket.end();
+      this.client.connected = false;
+      this.client.authenticated = false;
+      this.client._debug('Connection closed');
+    }
+  }
+}
+
+module.exports = FTPConnection;

package/lib/utils.js

@@ -0,0 +1,84 @@
+/**
+ * FTP Command helpers
+ * Utilities for building and parsing FTP commands
+ */
+
+/**
+ * Parse PASV response to extract host and port
+ * @param {string} message - PASV response message
+ * @returns {Object} - { host, port }
+ */
+function parsePasvResponse(message) {
+  const match = 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 };
+}
+
+/**
+ * Parse MDTM response to Date object
+ * @param {string} message - MDTM response message
+ * @returns {Date}
+ */
+function parseMdtmResponse(message) {
+  const match = message.match(/(\d{14})/);
+  if (!match) {
+    throw new Error('Failed to parse MDTM response');
+  }
+
+  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));
+}
+
+/**
+ * Normalize FTP path
+ * @param {string} path - Path to normalize
+ * @returns {string}
+ */
+function normalizePath(path) {
+  return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+}
+
+/**
+ * Get parent directory path
+ * @param {string} filePath - File path
+ * @returns {string}
+ */
+function getParentDir(filePath) {
+  const normalized = normalizePath(filePath);
+  const lastSlash = normalized.lastIndexOf('/');
+  if (lastSlash <= 0) {
+    return '/';
+  }
+  return normalized.substring(0, lastSlash);
+}
+
+/**
+ * Mask password in command for logging
+ * @param {string} command - FTP command
+ * @returns {string}
+ */
+function maskPassword(command) {
+  return command.startsWith('PASS ') ? 'PASS ********' : command;
+}
+
+module.exports = {
+  parsePasvResponse,
+  parseMdtmResponse,
+  normalizePath,
+  getParentDir,
+  maskPassword
+};

package/package.json

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