recker 1.0.4 → 1.0.6

package/dist/protocols/ftp.js

@@ -1,27 +1,97 @@
-import { Client as FTPClient } from 'basic-ftp';
+import { Socket } from 'node:net';
+import { connect as tlsConnect } from 'node:tls';
 import { Readable, Writable } from 'node:stream';
-export class FTP {
-    client;
+import { createWriteStream, createReadStream } from 'node:fs';
+import { EventEmitter } from 'node:events';
+const ResponseCode = {
+    RESTART_MARKER: 110,
+    SERVICE_READY_IN: 120,
+    DATA_CONNECTION_OPEN: 125,
+    FILE_STATUS_OK: 150,
+    OK: 200,
+    SUPERFLUOUS: 202,
+    SYSTEM_STATUS: 211,
+    DIRECTORY_STATUS: 212,
+    FILE_STATUS: 213,
+    HELP_MESSAGE: 214,
+    SYSTEM_TYPE: 215,
+    SERVICE_READY: 220,
+    SERVICE_CLOSING: 221,
+    DATA_CONNECTION_READY: 225,
+    CLOSING_DATA_CONNECTION: 226,
+    ENTERING_PASSIVE: 227,
+    ENTERING_EXTENDED_PASSIVE: 229,
+    USER_LOGGED_IN: 230,
+    AUTH_OK: 234,
+    FILE_ACTION_OK: 250,
+    PATHNAME_CREATED: 257,
+    NEED_PASSWORD: 331,
+    NEED_ACCOUNT: 332,
+    FILE_ACTION_PENDING: 350,
+    SERVICE_UNAVAILABLE: 421,
+    CANT_OPEN_DATA: 425,
+    CONNECTION_CLOSED: 426,
+    FILE_BUSY: 450,
+    LOCAL_ERROR: 451,
+    INSUFFICIENT_SPACE: 452,
+    SYNTAX_ERROR: 500,
+    SYNTAX_ERROR_PARAMS: 501,
+    NOT_IMPLEMENTED: 502,
+    BAD_SEQUENCE: 503,
+    NOT_IMPLEMENTED_PARAM: 504,
+    NOT_LOGGED_IN: 530,
+    NEED_ACCOUNT_STORE: 532,
+    FILE_NOT_FOUND: 550,
+    PAGE_TYPE_UNKNOWN: 551,
+    EXCEEDED_ALLOCATION: 552,
+    FILE_NAME_NOT_ALLOWED: 553,
+};
+export class FTP extends EventEmitter {
+    controlSocket = null;
     config;
     connected = false;
+    secureConnection = false;
+    responseBuffer = '';
     onProgress;
+    currentTransferBytes = 0;
+    socketFactory = null;
     constructor(config) {
-        this.config = config;
-        this.client = new FTPClient(config.timeout ?? 30000);
-        if (config.verbose) {
-            this.client.ftp.verbose = true;
-        }
+        super();
+        const isImplicit = config.secure === 'implicit';
+        const defaultPort = isImplicit ? 990 : 21;
+        this.config = {
+            host: config.host,
+            port: config.port ?? defaultPort,
+            user: config.user ?? 'anonymous',
+            password: config.password ?? 'anonymous@',
+            secure: config.secure ?? false,
+            timeout: config.timeout ?? 30000,
+            verbose: config.verbose ?? false,
+            tlsOptions: config.tlsOptions,
+        };
+        this.socketFactory = config._socketFactory ?? null;
+    }
+    createSocket() {
+        return this.socketFactory ? this.socketFactory() : new Socket();
     }
     async connect() {
         try {
-            const accessOptions = {
-                host: this.config.host,
-                port: this.config.port ?? 21,
-                user: this.config.user ?? 'anonymous',
-                password: this.config.password ?? 'anonymous@',
-                secure: this.config.secure ?? false,
-            };
-            await this.client.access(accessOptions);
+            if (this.config.secure === 'implicit') {
+                await this.connectImplicitTLS();
+            }
+            else {
+                await this.connectPlain();
+                if (this.config.secure === true) {
+                    await this.upgradeToTLS();
+                }
+            }
+            const welcome = await this.readResponse();
+            this.debug('Welcome: %s', welcome.message);
+            if (welcome.code !== ResponseCode.SERVICE_READY) {
+                throw new Error(`Server not ready: ${welcome.message}`);
+            }
+            await this.authenticate();
+            await this.sendCommand('TYPE I');
             this.connected = true;
             return {
                 success: true,
@@ -29,6 +99,7 @@ export class FTP {
             };
         }
         catch (error) {
+            this.cleanup();
             return {
                 success: false,
                 message: error instanceof Error ? error.message : 'Connection failed'
@@ -36,20 +107,15 @@ export class FTP {
         }
     }
     isConnected() {
-        return this.connected && !this.client.closed;
+        return this.connected && this.controlSocket !== null && !this.controlSocket.destroyed;
     }
     async list(path = '/') {
         this.ensureConnected();
         try {
-            const files = await this.client.list(path);
-            const items = files.map((file) => ({
-                name: file.name,
-                type: this.mapFileType(file.type),
-                size: file.size,
-                modifiedAt: file.modifiedAt,
-                permissions: file.permissions?.toString(),
-                rawModifiedAt: file.rawModifiedAt
-            }));
+            const dataSocket = await this.openDataConnection();
+            await this.sendCommand(`LIST ${path}`);
+            const data = await this.readDataConnection(dataSocket);
+            const items = this.parseDirectoryListing(data);
             return {
                 success: true,
                 data: items
@@ -65,25 +131,11 @@ export class FTP {
     async download(remotePath, localPath) {
         this.ensureConnected();
         try {
-            if (this.onProgress) {
-                this.client.trackProgress((info) => {
-                    this.onProgress?.({
-                        bytes: info.bytes,
-                        bytesOverall: info.bytesOverall,
-                        name: info.name,
-                        type: 'download'
-                    });
-                });
-            }
-            await this.client.downloadTo(localPath, remotePath);
-            this.client.trackProgress();
-            return {
-                success: true,
-                message: `Downloaded ${remotePath} to ${localPath}`
-            };
+            const writeStream = createWriteStream(localPath);
+            const result = await this.downloadToStream(remotePath, writeStream);
+            return result;
         }
         catch (error) {
-            this.client.trackProgress();
             return {
                 success: false,
                 message: error instanceof Error ? error.message : 'Download failed'
@@ -93,25 +145,42 @@ export class FTP {
     async downloadToStream(remotePath, stream) {
         this.ensureConnected();
         try {
-            if (this.onProgress) {
-                this.client.trackProgress((info) => {
-                    this.onProgress?.({
-                        bytes: info.bytes,
-                        bytesOverall: info.bytesOverall,
-                        name: info.name,
-                        type: 'download'
-                    });
+            const sizeResult = await this.size(remotePath);
+            const totalSize = sizeResult.data ?? 0;
+            const dataSocket = await this.openDataConnection();
+            await this.sendCommand(`RETR ${remotePath}`);
+            this.currentTransferBytes = 0;
+            const fileName = remotePath.split('/').pop() || remotePath;
+            await new Promise((resolve, reject) => {
+                dataSocket.on('data', (chunk) => {
+                    this.currentTransferBytes += chunk.length;
+                    stream.write(chunk);
+                    if (this.onProgress) {
+                        this.onProgress({
+                            bytes: chunk.length,
+                            bytesOverall: this.currentTransferBytes,
+                            name: fileName,
+                            type: 'download'
+                        });
+                    }
+                });
+                dataSocket.on('end', () => {
+                    stream.end();
+                    resolve();
                 });
+                dataSocket.on('error', reject);
+            });
+            const response = await this.readResponse();
+            if (response.code !== ResponseCode.CLOSING_DATA_CONNECTION &&
+                response.code !== ResponseCode.FILE_ACTION_OK) {
+                throw new Error(response.message);
             }
-            await this.client.downloadTo(stream, remotePath);
-            this.client.trackProgress();
             return {
                 success: true,
                 message: `Downloaded ${remotePath}`
             };
         }
         catch (error) {
-            this.client.trackProgress();
             return {
                 success: false,
                 message: error instanceof Error ? error.message : 'Download failed'
@@ -128,7 +197,13 @@ export class FTP {
                     callback();
                 }
             });
-            await this.client.downloadTo(stream, remotePath);
+            const result = await this.downloadToStream(remotePath, stream);
+            if (!result.success) {
+                return {
+                    success: false,
+                    message: result.message
+                };
+            }
             return {
                 success: true,
                 data: Buffer.concat(chunks)
@@ -144,25 +219,10 @@ export class FTP {
     async upload(localPath, remotePath) {
         this.ensureConnected();
         try {
-            if (this.onProgress) {
-                this.client.trackProgress((info) => {
-                    this.onProgress?.({
-                        bytes: info.bytes,
-                        bytesOverall: info.bytesOverall,
-                        name: info.name,
-                        type: 'upload'
-                    });
-                });
-            }
-            await this.client.uploadFrom(localPath, remotePath);
-            this.client.trackProgress();
-            return {
-                success: true,
-                message: `Uploaded ${localPath} to ${remotePath}`
-            };
+            const readStream = createReadStream(localPath);
+            return await this.uploadFromStream(readStream, remotePath);
         }
         catch (error) {
-            this.client.trackProgress();
             return {
                 success: false,
                 message: error instanceof Error ? error.message : 'Upload failed'
@@ -172,25 +232,41 @@ export class FTP {
     async uploadFromStream(stream, remotePath) {
         this.ensureConnected();
         try {
-            if (this.onProgress) {
-                this.client.trackProgress((info) => {
-                    this.onProgress?.({
-                        bytes: info.bytes,
-                        bytesOverall: info.bytesOverall,
-                        name: info.name,
-                        type: 'upload'
-                    });
+            const dataSocket = await this.openDataConnection();
+            await this.sendCommand(`STOR ${remotePath}`);
+            this.currentTransferBytes = 0;
+            const fileName = remotePath.split('/').pop() || remotePath;
+            await new Promise((resolve, reject) => {
+                stream.on('data', (chunk) => {
+                    this.currentTransferBytes += chunk.length;
+                    dataSocket.write(chunk);
+                    if (this.onProgress) {
+                        this.onProgress({
+                            bytes: chunk.length,
+                            bytesOverall: this.currentTransferBytes,
+                            name: fileName,
+                            type: 'upload'
+                        });
+                    }
                 });
+                stream.on('end', () => {
+                    dataSocket.end();
+                    resolve();
+                });
+                stream.on('error', reject);
+                dataSocket.on('error', reject);
+            });
+            const response = await this.readResponse();
+            if (response.code !== ResponseCode.CLOSING_DATA_CONNECTION &&
+                response.code !== ResponseCode.FILE_ACTION_OK) {
+                throw new Error(response.message);
             }
-            await this.client.uploadFrom(stream, remotePath);
-            this.client.trackProgress();
             return {
                 success: true,
                 message: `Uploaded to ${remotePath}`
             };
         }
         catch (error) {
-            this.client.trackProgress();
             return {
                 success: false,
                 message: error instanceof Error ? error.message : 'Upload failed'
@@ -198,30 +274,20 @@ export class FTP {
         }
     }
     async uploadFromBuffer(data, remotePath) {
-        this.ensureConnected();
-        try {
-            const buffer = typeof data === 'string' ? Buffer.from(data) : data;
-            const stream = Readable.from(buffer);
-            await this.client.uploadFrom(stream, remotePath);
-            return {
-                success: true,
-                message: `Uploaded to ${remotePath}`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: error instanceof Error ? error.message : 'Upload failed'
-            };
-        }
+        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+        const stream = Readable.from(buffer);
+        return this.uploadFromStream(stream, remotePath);
     }
     async delete(remotePath) {
         this.ensureConnected();
         try {
-            await this.client.remove(remotePath);
+            const response = await this.sendCommand(`DELE ${remotePath}`);
             return {
-                success: true,
-                message: `Deleted ${remotePath}`
+                success: response.code === ResponseCode.FILE_ACTION_OK,
+                code: response.code,
+                message: response.code === ResponseCode.FILE_ACTION_OK
+                    ? `Deleted ${remotePath}`
+                    : response.message
             };
         }
         catch (error) {
@@ -234,10 +300,29 @@ export class FTP {
     async mkdir(remotePath, recursive = true) {
         this.ensureConnected();
         try {
-            await this.client.ensureDir(remotePath);
+            if (recursive) {
+                const parts = remotePath.split('/').filter(Boolean);
+                let currentPath = '';
+                for (const part of parts) {
+                    currentPath += '/' + part;
+                    try {
+                        await this.sendCommand(`MKD ${currentPath}`);
+                    }
+                    catch {
+                    }
+                }
+                return {
+                    success: true,
+                    message: `Created directory ${remotePath}`
+                };
+            }
+            const response = await this.sendCommand(`MKD ${remotePath}`);
             return {
-                success: true,
-                message: `Created directory ${remotePath}`
+                success: response.code === ResponseCode.PATHNAME_CREATED,
+                code: response.code,
+                message: response.code === ResponseCode.PATHNAME_CREATED
+                    ? `Created directory ${remotePath}`
+                    : response.message
             };
         }
         catch (error) {
@@ -250,10 +335,13 @@ export class FTP {
     async rmdir(remotePath) {
         this.ensureConnected();
         try {
-            await this.client.removeDir(remotePath);
+            const response = await this.sendCommand(`RMD ${remotePath}`);
             return {
-                success: true,
-                message: `Removed directory ${remotePath}`
+                success: response.code === ResponseCode.FILE_ACTION_OK,
+                code: response.code,
+                message: response.code === ResponseCode.FILE_ACTION_OK
+                    ? `Removed directory ${remotePath}`
+                    : response.message
             };
         }
         catch (error) {
@@ -266,10 +354,17 @@ export class FTP {
     async rename(oldPath, newPath) {
         this.ensureConnected();
         try {
-            await this.client.rename(oldPath, newPath);
+            const rnfrResponse = await this.sendCommand(`RNFR ${oldPath}`);
+            if (rnfrResponse.code !== ResponseCode.FILE_ACTION_PENDING) {
+                throw new Error(rnfrResponse.message);
+            }
+            const rntoResponse = await this.sendCommand(`RNTO ${newPath}`);
             return {
-                success: true,
-                message: `Renamed ${oldPath} to ${newPath}`
+                success: rntoResponse.code === ResponseCode.FILE_ACTION_OK,
+                code: rntoResponse.code,
+                message: rntoResponse.code === ResponseCode.FILE_ACTION_OK
+                    ? `Renamed ${oldPath} to ${newPath}`
+                    : rntoResponse.message
             };
         }
         catch (error) {
@@ -282,10 +377,12 @@ export class FTP {
     async pwd() {
         this.ensureConnected();
         try {
-            const dir = await this.client.pwd();
+            const response = await this.sendCommand('PWD');
+            const match = response.message.match(/"([^"]+)"/);
+            const path = match ? match[1] : '/';
             return {
                 success: true,
-                data: dir
+                data: path
             };
         }
         catch (error) {
@@ -298,10 +395,13 @@ export class FTP {
     async cd(remotePath) {
         this.ensureConnected();
         try {
-            await this.client.cd(remotePath);
+            const response = await this.sendCommand(`CWD ${remotePath}`);
             return {
-                success: true,
-                message: `Changed to ${remotePath}`
+                success: response.code === ResponseCode.FILE_ACTION_OK,
+                code: response.code,
+                message: response.code === ResponseCode.FILE_ACTION_OK
+                    ? `Changed to ${remotePath}`
+                    : response.message
             };
         }
         catch (error) {
@@ -314,9 +414,10 @@ export class FTP {
     async size(remotePath) {
         this.ensureConnected();
         try {
-            const size = await this.client.size(remotePath);
+            const response = await this.sendCommand(`SIZE ${remotePath}`);
+            const size = parseInt(response.message.split(' ').pop() || '0', 10);
             return {
-                success: true,
+                success: response.code === ResponseCode.FILE_STATUS,
                 data: size
             };
         }
@@ -332,8 +433,10 @@ export class FTP {
         try {
             const parentPath = remotePath.split('/').slice(0, -1).join('/') || '/';
             const fileName = remotePath.split('/').pop() || '';
-            const files = await this.client.list(parentPath);
-            return files.some((f) => f.name === fileName);
+            const result = await this.list(parentPath);
+            if (!result.success || !result.data)
+                return false;
+            return result.data.some((f) => f.name === fileName);
         }
         catch {
             return false;
@@ -345,28 +448,338 @@ export class FTP {
     }
     async close() {
         this.connected = false;
-        this.client.close();
+        if (this.controlSocket) {
+            try {
+                await this.sendCommand('QUIT');
+            }
+            catch {
+            }
+            this.cleanup();
+        }
+    }
+    getSocket() {
+        if (!this.controlSocket) {
+            throw new Error('Not connected. Call connect() first.');
+        }
+        return this.controlSocket;
+    }
+    async connectPlain() {
+        return new Promise((resolve, reject) => {
+            const socket = this.createSocket();
+            socket.setTimeout(this.config.timeout);
+            socket.on('connect', () => {
+                this.controlSocket = socket;
+                resolve();
+            });
+            socket.on('error', (err) => {
+                reject(err);
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                reject(new Error('Connection timeout'));
+            });
+            socket.connect(this.config.port, this.config.host);
+        });
     }
-    getClient() {
-        return this.client;
+    async connectImplicitTLS() {
+        return new Promise((resolve, reject) => {
+            const options = {
+                host: this.config.host,
+                port: this.config.port,
+                timeout: this.config.timeout,
+                rejectUnauthorized: false,
+                ...this.config.tlsOptions,
+            };
+            const socket = tlsConnect(options, () => {
+                this.controlSocket = socket;
+                this.secureConnection = true;
+                resolve();
+            });
+            socket.on('error', reject);
+            socket.setTimeout(this.config.timeout);
+            socket.on('timeout', () => {
+                socket.destroy();
+                reject(new Error('Connection timeout'));
+            });
+        });
+    }
+    async upgradeToTLS() {
+        const authResponse = await this.sendCommand('AUTH TLS');
+        if (authResponse.code !== ResponseCode.AUTH_OK) {
+            throw new Error(`AUTH TLS failed: ${authResponse.message}`);
+        }
+        return new Promise((resolve, reject) => {
+            const options = {
+                socket: this.controlSocket,
+                rejectUnauthorized: false,
+                ...this.config.tlsOptions,
+            };
+            const tlsSocket = tlsConnect(options, () => {
+                this.controlSocket = tlsSocket;
+                this.secureConnection = true;
+                resolve();
+            });
+            tlsSocket.on('error', reject);
+        });
+    }
+    async authenticate() {
+        const userResponse = await this.sendCommand(`USER ${this.config.user}`);
+        if (userResponse.code === ResponseCode.USER_LOGGED_IN) {
+            return;
+        }
+        if (userResponse.code !== ResponseCode.NEED_PASSWORD) {
+            throw new Error(`Authentication failed: ${userResponse.message}`);
+        }
+        const passResponse = await this.sendCommand(`PASS ${this.config.password}`);
+        if (passResponse.code !== ResponseCode.USER_LOGGED_IN) {
+            throw new Error(`Authentication failed: ${passResponse.message}`);
+        }
+        if (this.secureConnection) {
+            await this.sendCommand('PBSZ 0');
+            await this.sendCommand('PROT P');
+        }
+    }
+    async openDataConnection() {
+        const pasvResponse = await this.sendCommand('PASV');
+        if (pasvResponse.code !== ResponseCode.ENTERING_PASSIVE) {
+            throw new Error(`PASV failed: ${pasvResponse.message}`);
+        }
+        const match = pasvResponse.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], 10) * 256 + parseInt(match[6], 10);
+        this.debug('PASV: %s:%d', host, port);
+        return new Promise((resolve, reject) => {
+            if (this.secureConnection) {
+                const options = {
+                    host,
+                    port,
+                    rejectUnauthorized: false,
+                    ...this.config.tlsOptions,
+                };
+                const socket = tlsConnect(options, () => {
+                    resolve(socket);
+                });
+                socket.on('error', reject);
+            }
+            else {
+                const socket = this.createSocket();
+                socket.on('connect', () => resolve(socket));
+                socket.on('error', reject);
+                socket.connect(port, host);
+            }
+        });
+    }
+    async readDataConnection(socket) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            socket.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            socket.on('end', async () => {
+                const data = Buffer.concat(chunks).toString('utf8');
+                try {
+                    const response = await this.readResponse();
+                    if (response.code !== ResponseCode.CLOSING_DATA_CONNECTION &&
+                        response.code !== ResponseCode.FILE_ACTION_OK) {
+                        reject(new Error(response.message));
+                    }
+                    else {
+                        resolve(data);
+                    }
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            socket.on('error', reject);
+        });
+    }
+    async sendCommand(command) {
+        if (!this.controlSocket) {
+            throw new Error('Not connected');
+        }
+        const displayCommand = command.startsWith('PASS ')
+            ? 'PASS ****'
+            : command;
+        this.debug('>>> %s', displayCommand);
+        return new Promise((resolve, reject) => {
+            this.controlSocket.write(command + '\r\n', 'utf8', async (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                try {
+                    const response = await this.readResponse();
+                    if (response.code >= 400) {
+                        reject(new Error(response.message));
+                    }
+                    else {
+                        resolve(response);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async readResponse() {
+        return new Promise((resolve, reject) => {
+            const onData = (data) => {
+                this.responseBuffer += data.toString('utf8');
+                const lines = this.responseBuffer.split('\r\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const line = lines[i];
+                    const match = line.match(/^(\d{3})([ -])(.*)/);
+                    if (match) {
+                        const code = parseInt(match[1], 10);
+                        const isFinal = match[2] === ' ';
+                        const message = match[3];
+                        if (isFinal) {
+                            this.responseBuffer = lines.slice(i + 1).join('\r\n');
+                            this.controlSocket.removeListener('data', onData);
+                            this.controlSocket.removeListener('error', onError);
+                            this.debug('<<< %d %s', code, message);
+                            resolve({ code, message: `${code} ${message}` });
+                            return;
+                        }
+                    }
+                }
+            };
+            const onError = (err) => {
+                this.controlSocket.removeListener('data', onData);
+                reject(err);
+            };
+            this.controlSocket.on('data', onData);
+            this.controlSocket.on('error', onError);
+            onData(Buffer.alloc(0));
+        });
+    }
+    parseDirectoryListing(data) {
+        const lines = data.split('\r\n').filter(Boolean);
+        const items = [];
+        for (const line of lines) {
+            const item = this.parseListLine(line);
+            if (item) {
+                items.push(item);
+            }
+        }
+        return items;
+    }
+    parseListLine(line) {
+        const unixMatch = line.match(/^([d\-l])([rwx\-]{9})\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w{3}\s+\d{1,2}\s+[\d:]+)\s+(.+)$/);
+        if (unixMatch) {
+            const typeChar = unixMatch[1];
+            const permissions = unixMatch[2];
+            const size = parseInt(unixMatch[3], 10);
+            const rawDate = unixMatch[4];
+            const name = unixMatch[5];
+            return {
+                name,
+                type: this.mapFileType(typeChar),
+                size,
+                permissions,
+                rawModifiedAt: rawDate,
+                modifiedAt: this.parseDate(rawDate)
+            };
+        }
+        const dosMatch = line.match(/^(\d{2}-\d{2}-\d{2})\s+(\d{1,2}:\d{2}[AP]M)\s+(<DIR>|\d+)\s+(.+)$/i);
+        if (dosMatch) {
+            const date = dosMatch[1];
+            const time = dosMatch[2];
+            const sizeOrDir = dosMatch[3];
+            const name = dosMatch[4];
+            const isDir = sizeOrDir.toUpperCase() === '<DIR>';
+            return {
+                name,
+                type: isDir ? 'directory' : 'file',
+                size: isDir ? 0 : parseInt(sizeOrDir, 10),
+                rawModifiedAt: `${date} ${time}`,
+                modifiedAt: this.parseDosDate(date, time)
+            };
+        }
+        if (line.trim() && !line.includes(' ')) {
+            return {
+                name: line.trim(),
+                type: 'unknown',
+                size: 0
+            };
+        }
+        return null;
+    }
+    mapFileType(typeChar) {
+        switch (typeChar) {
+            case '-': return 'file';
+            case 'd': return 'directory';
+            case 'l': return 'link';
+            default: return 'unknown';
+        }
+    }
+    parseDate(rawDate) {
+        try {
+            const now = new Date();
+            const parts = rawDate.trim().split(/\s+/);
+            if (parts.length >= 3) {
+                const month = parts[0];
+                const day = parseInt(parts[1], 10);
+                const timeOrYear = parts[2];
+                if (timeOrYear.includes(':')) {
+                    const [hours, minutes] = timeOrYear.split(':').map(Number);
+                    const date = new Date(`${month} ${day} ${now.getFullYear()} ${hours}:${minutes}`);
+                    if (date > now) {
+                        date.setFullYear(date.getFullYear() - 1);
+                    }
+                    return date;
+                }
+                else {
+                    return new Date(`${month} ${day} ${timeOrYear}`);
+                }
+            }
+        }
+        catch {
+        }
+        return undefined;
+    }
+    parseDosDate(date, time) {
+        try {
+            const [month, day, year] = date.split('-').map(Number);
+            const fullYear = year < 70 ? 2000 + year : 1900 + year;
+            const timeMatch = time.match(/(\d{1,2}):(\d{2})([AP]M)/i);
+            if (timeMatch) {
+                let hours = parseInt(timeMatch[1], 10);
+                const minutes = parseInt(timeMatch[2], 10);
+                const isPM = timeMatch[3].toUpperCase() === 'PM';
+                if (isPM && hours < 12)
+                    hours += 12;
+                if (!isPM && hours === 12)
+                    hours = 0;
+                return new Date(fullYear, month - 1, day, hours, minutes);
+            }
+        }
+        catch {
+        }
+        return undefined;
     }
     ensureConnected() {
-        if (!this.connected || this.client.closed) {
+        if (!this.connected || !this.controlSocket || this.controlSocket.destroyed) {
             throw new Error('Not connected to FTP server. Call connect() first.');
         }
     }
-    mapFileType(type) {
-        switch (type) {
-            case 0:
-                return 'unknown';
-            case 1:
-                return 'file';
-            case 2:
-                return 'directory';
-            case 3:
-                return 'link';
-            default:
-                return 'unknown';
+    cleanup() {
+        if (this.controlSocket) {
+            this.controlSocket.destroy();
+            this.controlSocket = null;
+        }
+        this.connected = false;
+        this.secureConnection = false;
+        this.responseBuffer = '';
+    }
+    debug(format, ...args) {
+        if (this.config.verbose) {
+            console.log(`[FTP] ${format}`, ...args);
         }
     }
 }