react-native-kookit 0.2.1 → 0.2.3

package/ios/ReactNativeKookitModule.swift

@@ -2,12 +2,753 @@ import ExpoModulesCore
 import UIKit
 import MediaPlayer
 import AVFoundation
+import Foundation
+import Network
+
+// MARK: - FTP Related Types and Classes
+
+struct FtpConnectionConfig {
+    let host: String
+    let port: Int
+    let username: String
+    let password: String
+    let passive: Bool
+    let timeout: TimeInterval
+    
+    init(host: String, port: Int = 21, username: String, password: String, passive: Bool = true, timeout: TimeInterval = 30.0) {
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.passive = passive
+        self.timeout = timeout
+    }
+}
+
+struct FtpFileInfo {
+    let name: String
+    let isDirectory: Bool
+    let size: Int64
+    let lastModified: String
+    let permissions: String?
+}
+
+protocol FtpProgressDelegate: AnyObject {
+    func onProgress(transferred: Int64, total: Int64)
+    func onComplete()
+    func onError(error: String)
+}
+
+enum FtpError: Error, LocalizedError {
+    case notConnected
+    case connectionTimeout
+    case connectionCancelled
+    case authenticationFailed(String)
+    case commandFailed(String)
+    case fileNotFound(String)
+    case invalidResponse
+    
+    var errorDescription: String? {
+        switch self {
+        case .notConnected:
+            return "Not connected to FTP server"
+        case .connectionTimeout:
+            return "Connection timeout"
+        case .connectionCancelled:
+            return "Connection cancelled"
+        case .authenticationFailed(let message):
+            return "Authentication failed: \(message)"
+        case .commandFailed(let message):
+            return "Command failed: \(message)"
+        case .fileNotFound(let message):
+            return "File not found: \(message)"
+        case .invalidResponse:
+            return "Invalid response from server"
+        }
+    }
+}
+
+// Helper class to safely manage continuation resumption
+private class ConnectionBox<T>: @unchecked Sendable {
+    private let continuation: CheckedContinuation<T, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "ConnectionBox")
+    
+    init(continuation: CheckedContinuation<T, Error>) {
+        self.continuation = continuation
+    }
+    
+    func resume(returning value: T) {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume(returning: value)
+        }
+    }
+    
+    func resume(throwing error: Error) {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume(throwing: error)
+        }
+    }
+    
+    func resume() where T == Void {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume()
+        }
+    }
+}
+
+// Helper class specifically for NWConnection state handling
+private class NWConnectionBox: @unchecked Sendable {
+    private let connection: NWConnection
+    private let continuation: CheckedContinuation<NWConnection, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "NWConnectionBox")
+    
+    init(connection: NWConnection, continuation: CheckedContinuation<NWConnection, Error>) {
+        self.connection = connection
+        self.continuation = continuation
+    }
+    
+    func handleStateUpdate(_ state: NWConnection.State) {
+        queue.sync {
+            guard !hasResumed else { return }
+            
+            switch state {
+            case .ready:
+                hasResumed = true
+                continuation.resume(returning: connection)
+            case .failed(let error):
+                hasResumed = true
+                continuation.resume(throwing: error)
+            case .cancelled:
+                hasResumed = true
+                continuation.resume(throwing: FtpError.connectionCancelled)
+            default:
+                break
+            }
+        }
+    }
+}
+
+// Helper class for FTP connection authentication
+private class FtpConnectionBox: @unchecked Sendable {
+    private let ftpClient: FtpClient
+    private let continuation: CheckedContinuation<Void, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "FtpConnectionBox")
+    private var timeoutTask: DispatchWorkItem?
+    
+    init(ftpClient: FtpClient, continuation: CheckedContinuation<Void, Error>) {
+        self.ftpClient = ftpClient
+        self.continuation = continuation
+    }
+    
+    func setTimeoutTask(_ task: DispatchWorkItem) {
+        self.timeoutTask = task
+    }
+    
+    func handleStateUpdate(_ state: NWConnection.State) {
+        queue.async {
+            guard !self.hasResumed else { return }
+            
+            switch state {
+            case .ready:
+                self.timeoutTask?.cancel()
+                Task {
+                    do {
+                        try await self.ftpClient.performAuthentication()
+                        self.ftpClient.isConnected = true
+                        self.queue.sync {
+                            if !self.hasResumed {
+                                self.hasResumed = true
+                                self.continuation.resume()
+                            }
+                        }
+                    } catch {
+                        self.queue.sync {
+                            if !self.hasResumed {
+                                self.hasResumed = true
+                                self.continuation.resume(throwing: error)
+                            }
+                        }
+                    }
+                }
+            case .failed(let error):
+                self.timeoutTask?.cancel()
+                self.queue.sync {
+                    if !self.hasResumed {
+                        self.hasResumed = true
+                        self.continuation.resume(throwing: error)
+                    }
+                }
+            case .cancelled:
+                self.timeoutTask?.cancel()
+                self.queue.sync {
+                    if !self.hasResumed {
+                        self.hasResumed = true
+                        self.continuation.resume(throwing: FtpError.connectionCancelled)
+                    }
+                }
+            default:
+                break
+            }
+        }
+    }
+    
+    func handleTimeout() {
+        queue.sync {
+            if !hasResumed {
+                hasResumed = true
+                continuation.resume(throwing: FtpError.connectionTimeout)
+            }
+        }
+    }
+}
+
+class FtpClient: @unchecked Sendable {
+    private var controlConnection: NWConnection?
+    var isConnected = false
+    private var config: FtpConnectionConfig?
+    private weak var progressDelegate: FtpProgressDelegate?
+    
+    func connect(config: FtpConnectionConfig) async throws {
+        self.config = config
+        
+        let host = NWEndpoint.Host(config.host)
+        let port = NWEndpoint.Port(integerLiteral: UInt16(config.port))
+        let endpoint = NWEndpoint.hostPort(host: host, port: port)
+        
+        controlConnection = NWConnection(to: endpoint, using: .tcp)
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = FtpConnectionBox(ftpClient: self, continuation: continuation)
+            
+            let timeoutTask = DispatchWorkItem {
+                if !self.isConnected {
+                    self.controlConnection?.cancel()
+                }
+            }
+            
+            connectionBox.setTimeoutTask(timeoutTask)
+            
+            controlConnection?.stateUpdateHandler = { state in
+                connectionBox.handleStateUpdate(state)
+            }
+            
+            controlConnection?.start(queue: .global())
+            
+            // Set timeout
+            DispatchQueue.global().asyncAfter(deadline: .now() + config.timeout, execute: timeoutTask)
+        }
+    }
+    
+    func disconnect() async {
+        if isConnected {
+            do {
+                _ = try await sendCommand("QUIT")
+            } catch {
+                // Ignore errors during disconnect
+            }
+        }
+        
+        controlConnection?.cancel()
+        controlConnection = nil
+        isConnected = false
+    }
+    
+    func listFiles(path: String? = nil) async throws -> [FtpFileInfo] {
+        guard isConnected else { throw FtpError.notConnected }
+
+        // Set ASCII mode for directory listings
+        print("FTP DEBUG: Setting ASCII mode for directory listing")
+        let asciiResponse = try await sendCommand("TYPE A")
+        print("FTP DEBUG: ASCII mode response: \(asciiResponse)")
+        if !asciiResponse.hasPrefix("200") {
+            print("FTP DEBUG: Warning - Failed to set ASCII mode: \(asciiResponse)")
+        }
+
+        let dataConnection = try await enterPassiveMode()
+
+        let command = path != nil ? "LIST \(path!)" : "LIST"
+        print("FTP DEBUG: Sending command: \(command)")
+        let response = try await sendCommand(command)
+        print("FTP DEBUG: LIST command response: \(response)")
+
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("LIST failed: \(response)")
+        }
+
+        let data = try await receiveData(from: dataConnection)
+        print("FTP DEBUG: Received data length: \(data.count) bytes")
+        if let dataString = String(data: data, encoding: .utf8) {
+            print("FTP DEBUG: Received data content: '\(dataString)'")
+        }
+        dataConnection.cancel()
+
+        let finalResponse = try await readResponse()
+        print("FTP DEBUG: Final response: \(finalResponse)")
+        guard finalResponse.hasPrefix("226") else {
+            throw FtpError.commandFailed("LIST completion failed: \(finalResponse)")
+        }
+
+        let files = parseListingData(data)
+        print("FTP DEBUG: Parsed \(files.count) files")
+        
+        // Reset to binary mode for file transfers
+        let binaryResponse = try await sendCommand("TYPE I")
+        print("FTP DEBUG: Reset to binary mode response: \(binaryResponse)")
+        
+        return files
+    }
+    
+    func downloadFile(remotePath: String, localPath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let dataConnection = try await enterPassiveMode()
+        
+        let response = try await sendCommand("RETR \(remotePath)")
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("Download failed: \(response)")
+        }
+        
+        let localURL = URL(fileURLWithPath: localPath)
+        
+        // Create parent directories if needed
+        try FileManager.default.createDirectory(at: localURL.deletingLastPathComponent(),
+                                              withIntermediateDirectories: true,
+                                              attributes: nil)
+        
+        let data = try await receiveData(from: dataConnection, reportProgress: true)
+        dataConnection.cancel()
+        
+        try data.write(to: localURL)
+        
+        let finalResponse = try await readResponse()
+        guard finalResponse.hasPrefix("226") else {
+            try? FileManager.default.removeItem(at: localURL)
+            throw FtpError.commandFailed("Download completion failed: \(finalResponse)")
+        }
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func uploadFile(localPath: String, remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let localURL = URL(fileURLWithPath: localPath)
+        guard FileManager.default.fileExists(atPath: localPath) else {
+            throw FtpError.fileNotFound("Local file not found: \(localPath)")
+        }
+        
+        let data = try Data(contentsOf: localURL)
+        let dataConnection = try await enterPassiveMode()
+        
+        let response = try await sendCommand("STOR \(remotePath)")
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("Upload failed: \(response)")
+        }
+        
+        try await sendData(data, to: dataConnection, reportProgress: true)
+        dataConnection.cancel()
+        
+        let finalResponse = try await readResponse()
+        guard finalResponse.hasPrefix("226") else {
+            throw FtpError.commandFailed("Upload completion failed: \(finalResponse)")
+        }
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func deleteFile(remotePath: String, isDirectory: Bool = false) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let command = isDirectory ? "RMD \(remotePath)" : "DELE \(remotePath)"
+        let response = try await sendCommand(command)
+        
+        guard response.hasPrefix("250") else {
+            throw FtpError.commandFailed("Delete failed: \(response)")
+        }
+    }
+    
+    func createDirectory(remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("MKD \(remotePath)")
+        guard response.hasPrefix("257") else {
+            throw FtpError.commandFailed("Create directory failed: \(response)")
+        }
+    }
+    
+    func changeDirectory(remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("CWD \(remotePath)")
+        guard response.hasPrefix("250") else {
+            throw FtpError.commandFailed("Change directory failed: \(response)")
+        }
+    }
+    
+    func getCurrentDirectory() async throws -> String {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("PWD")
+        guard response.hasPrefix("257") else {
+            throw FtpError.commandFailed("Get current directory failed: \(response)")
+        }
+        
+        // Extract directory from response like: 257 "/home/user" is current directory
+        let pattern = #""([^"]+)""#
+        if let range = response.range(of: pattern, options: .regularExpression) {
+            let match = String(response[range])
+            return String(match.dropFirst().dropLast())
+        }
+        
+        throw FtpError.commandFailed("Failed to parse current directory response: \(response)")
+    }
+    
+    func setProgressDelegate(_ delegate: FtpProgressDelegate?) {
+        self.progressDelegate = delegate
+    }
+    
+    // MARK: - Private Methods
+    
+    func performAuthentication() async throws {
+        // Read welcome message
+        let welcome = try await readResponse()
+        guard welcome.hasPrefix("220") else {
+            throw FtpError.authenticationFailed("Server not ready: \(welcome)")
+        }
+        
+        // Send username
+        let userResponse = try await sendCommand("USER \(config!.username)")
+        guard userResponse.hasPrefix("331") || userResponse.hasPrefix("230") else {
+            throw FtpError.authenticationFailed("Username rejected: \(userResponse)")
+        }
+        
+        // Send password if needed
+        if userResponse.hasPrefix("331") {
+            let passResponse = try await sendCommand("PASS \(config!.password)")
+            guard passResponse.hasPrefix("230") else {
+                throw FtpError.authenticationFailed("Authentication failed: \(passResponse)")
+            }
+        }
+        
+        // Set binary mode
+        let typeResponse = try await sendCommand("TYPE I")
+        guard typeResponse.hasPrefix("200") else {
+            throw FtpError.commandFailed("Failed to set binary mode: \(typeResponse)")
+        }
+    }
+    
+    private func sendCommand(_ command: String) async throws -> String {
+        guard let connection = controlConnection else {
+            throw FtpError.notConnected
+        }
+        
+        let commandData = "\(command)\r\n".data(using: .utf8)!
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = ConnectionBox<String>(continuation: continuation)
+            
+            connection.send(content: commandData, completion: .contentProcessed { error in
+                if let error = error {
+                    connectionBox.resume(throwing: error)
+                } else {
+                    Task {
+                        do {
+                            let response = try await self.readResponse()
+                            connectionBox.resume(returning: response)
+                        } catch {
+                            connectionBox.resume(throwing: error)
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    private func readResponse() async throws -> String {
+        guard let connection = controlConnection else {
+            throw FtpError.notConnected
+        }
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = ConnectionBox<String>(continuation: continuation)
+            
+            connection.receive(minimumIncompleteLength: 1, maximumLength: 4096) { data, _, isComplete, error in
+                if let error = error {
+                    connectionBox.resume(throwing: error)
+                } else if let data = data {
+                    // Try multiple encodings for FTP responses
+                    var response: String?
+                    
+                    // Try UTF-8 first
+                    if let utf8Response = String(data: data, encoding: .utf8) {
+                        response = utf8Response
+                    }
+                    // Try GBK for Chinese FTP servers
+                    else if let gbkResponse = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))) {
+                        response = gbkResponse
+                    }
+                    // Try ASCII as fallback
+                    else if let asciiResponse = String(data: data, encoding: .ascii) {
+                        response = asciiResponse
+                    }
+                    
+                    if let validResponse = response {
+                        connectionBox.resume(returning: validResponse.trimmingCharacters(in: .whitespacesAndNewlines))
+                    } else {
+                        connectionBox.resume(throwing: FtpError.invalidResponse)
+                    }
+                } else {
+                    connectionBox.resume(throwing: FtpError.invalidResponse)
+                }
+            }
+        }
+    }
+    
+    private func enterPassiveMode() async throws -> NWConnection {
+        let response = try await sendCommand("PASV")
+        guard response.hasPrefix("227") else {
+            throw FtpError.commandFailed("Failed to enter passive mode: \(response)")
+        }
+        
+        // Parse passive mode response: 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)
+        let pattern = #"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)"#
+        let regex = try NSRegularExpression(pattern: pattern)
+        let nsString = response as NSString
+        
+        guard let match = regex.firstMatch(in: response, range: NSRange(location: 0, length: nsString.length)) else {
+            throw FtpError.commandFailed("Failed to parse passive mode response: \(response)")
+        }
+        
+        let h1 = Int(nsString.substring(with: match.range(at: 1)))!
+        let h2 = Int(nsString.substring(with: match.range(at: 2)))!
+        let h3 = Int(nsString.substring(with: match.range(at: 3)))!
+        let h4 = Int(nsString.substring(with: match.range(at: 4)))!
+        let p1 = Int(nsString.substring(with: match.range(at: 5)))!
+        let p2 = Int(nsString.substring(with: match.range(at: 6)))!
+        
+        let host = "\(h1).\(h2).\(h3).\(h4)"
+        let port = p1 * 256 + p2
+        
+        let dataHost = NWEndpoint.Host(host)
+        let dataPort = NWEndpoint.Port(integerLiteral: UInt16(port))
+        let dataEndpoint = NWEndpoint.hostPort(host: dataHost, port: dataPort)
+        
+        let dataConnection = NWConnection(to: dataEndpoint, using: .tcp)
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = NWConnectionBox(connection: dataConnection, continuation: continuation)
+            
+            dataConnection.stateUpdateHandler = { state in
+                connectionBox.handleStateUpdate(state)
+            }
+            
+            dataConnection.start(queue: .global())
+        }
+    }
+    
+    private func receiveData(from connection: NWConnection, reportProgress: Bool = false) async throws -> Data {
+        var receivedData = Data()
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = ConnectionBox<Data>(continuation: continuation)
+            
+            func receiveMore() {
+                connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { data, _, isComplete, error in
+                    if let error = error {
+                        connectionBox.resume(throwing: error)
+                        return
+                    }
+                    
+                    if let data = data {
+                        receivedData.append(data)
+                        if reportProgress {
+                            DispatchQueue.main.async {
+                                self.progressDelegate?.onProgress(transferred: Int64(receivedData.count), total: -1)
+                            }
+                        }
+                    }
+                    
+                    if isComplete {
+                        connectionBox.resume(returning: receivedData)
+                    } else {
+                        receiveMore()
+                    }
+                }
+            }
+            receiveMore()
+        }
+    }
+    
+    private func sendData(_ data: Data, to connection: NWConnection, reportProgress: Bool = false) async throws {
+        let chunkSize = 8192
+        let totalSize = data.count
+        var sentBytes = 0
+        
+        for i in stride(from: 0, to: totalSize, by: chunkSize) {
+            let endIndex = min(i + chunkSize, totalSize)
+            let chunk = data.subdata(in: i..<endIndex)
+            
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+                let connectionBox = ConnectionBox<Void>(continuation: continuation)
+                
+                connection.send(content: chunk, completion: .contentProcessed { error in
+                    if let error = error {
+                        connectionBox.resume(throwing: error)
+                    } else {
+                        sentBytes += chunk.count
+                        if reportProgress {
+                            DispatchQueue.main.async {
+                                self.progressDelegate?.onProgress(transferred: Int64(sentBytes), total: Int64(totalSize))
+                            }
+                        }
+                        connectionBox.resume()
+                    }
+                })
+            }
+        }
+    }
+    
+    private func parseListingData(_ data: Data) -> [FtpFileInfo] {
+        print("FTP DEBUG: Raw data length: \(data.count) bytes")
+        print("FTP DEBUG: Raw data hex: \(data.map { String(format: "%02x", $0) }.joined())")
+        
+        // Try different encodings, prioritizing Chinese encodings
+        var string: String?
+        var encoding: String.Encoding = .utf8
+        
+        // Try UTF-8 first
+        if let utf8String = String(data: data, encoding: .utf8) {
+            string = utf8String
+            encoding = .utf8
+            print("FTP DEBUG: Successfully decoded with UTF-8")
+        }
+        // Try GBK/GB2312 for Chinese
+        else if let gbkString = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))) {
+            string = gbkString
+            encoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))
+            print("FTP DEBUG: Successfully decoded with GBK/GB18030")
+        }
+        // Try Big5 for Traditional Chinese
+        else if let big5String = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.big5.rawValue)))) {
+            string = big5String
+            encoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.big5.rawValue)))
+            print("FTP DEBUG: Successfully decoded with Big5")
+        }
+        // Try ASCII
+        else if let asciiString = String(data: data, encoding: .ascii) {
+            string = asciiString
+            encoding = .ascii
+            print("FTP DEBUG: Successfully decoded with ASCII")
+        }
+        // Try Latin1 (ISO-8859-1)
+        else if let latin1String = String(data: data, encoding: .isoLatin1) {
+            string = latin1String
+            encoding = .isoLatin1
+            print("FTP DEBUG: Successfully decoded with Latin1")
+        }
+        // Try Windows-1252
+        else if let windowsString = String(data: data, encoding: .windowsCP1252) {
+            string = windowsString
+            encoding = .windowsCP1252
+            print("FTP DEBUG: Successfully decoded with Windows-1252")
+        }
+        else {
+            print("FTP DEBUG: Failed to decode data with any encoding")
+            print("FTP DEBUG: Raw bytes: \(Array(data))")
+            return []
+        }
+
+        guard let decodedString = string else {
+            print("FTP DEBUG: No valid string found")
+            return []
+        }
+
+        print("FTP DEBUG: Decoded string with \(encoding): '\(decodedString)'")
+        print("FTP DEBUG: String length: \(decodedString.count) characters")
+        
+        let lines = decodedString.components(separatedBy: .newlines)
+        print("FTP DEBUG: Found \(lines.count) lines")
+        var files: [FtpFileInfo] = []
+
+        for (index, line) in lines.enumerated() {
+            print("FTP DEBUG: Processing line \(index): '\(line)'")
+            if let fileInfo = parseListing(line) {
+                files.append(fileInfo)
+                print("FTP DEBUG: Parsed file: \(fileInfo.name), isDirectory: \(fileInfo.isDirectory)")
+            } else {
+                print("FTP DEBUG: Failed to parse line \(index)")
+            }
+        }
+
+        print("FTP DEBUG: Successfully parsed \(files.count) files")
+        return files
+    }
+    
+    private func parseListing(_ line: String) -> FtpFileInfo? {
+        let trimmedLine = line.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmedLine.isEmpty else {
+            print("FTP DEBUG: Line is empty after trimming")
+            return nil
+        }
+
+        print("FTP DEBUG: Parsing line: '\(trimmedLine)'")
+
+        // Parse Unix-style listing: drwxr-xr-x 3 user group 4096 Mar 15 10:30 dirname
+        let components = trimmedLine.components(separatedBy: .whitespaces).filter { !$0.isEmpty }
+        print("FTP DEBUG: Components count: \(components.count), components: \(components)")
+
+        guard components.count >= 9 else {
+            print("FTP DEBUG: Not enough components (\(components.count)), expected at least 9")
+            return nil
+        }
+
+        let permissions = components[0]
+        let isDirectory = permissions.hasPrefix("d")
+        let size = isDirectory ? 0 : Int64(components[4]) ?? 0
+
+        // Reconstruct filename (can contain spaces)
+        let name = components[8...].joined(separator: " ")
+
+        // Parse date
+        let month = components[5]
+        let day = components[6]
+        let yearOrTime = components[7]
+        let lastModified = "\(month) \(day) \(yearOrTime)"
+
+        let fileInfo = FtpFileInfo(
+            name: name,
+            isDirectory: isDirectory,
+            size: size,
+            lastModified: lastModified,
+            permissions: permissions
+        )
+
+        print("FTP DEBUG: Successfully parsed file: \(fileInfo)")
+        return fileInfo
+    }
+}
+
+// MARK: - Main Module
 
 public class ReactNativeKookitModule: Module {
   private var volumeView: MPVolumeView?
   private var volumeObserver: NSKeyValueObservation?
   private var isVolumeKeyInterceptionEnabled = false
   private var previousVolume: Float = 0.0
+  private var ftpClient: FtpClient?
+  
   // Each module class must implement the definition function. The definition consists of components
   // that describes the module's functionality and behavior.
   // See https://docs.expo.dev/modules/module-api for more details about available components.
@@ -23,7 +764,7 @@ public class ReactNativeKookitModule: Module {
     ])
 
     // Defines event names that the module can send to JavaScript.
-    Events("onChange", "onVolumeButtonPressed")
+    Events("onChange", "onVolumeButtonPressed", "onFtpProgress", "onFtpComplete", "onFtpError")
 
     // Defines a JavaScript synchronous function that runs the native code on the JavaScript thread.
     Function("hello") {
@@ -49,8 +790,127 @@ public class ReactNativeKookitModule: Module {
       self.disableVolumeKeyInterception()
     }
 
-    // Enables the module to be used as a native view. Definition components that are accepted as part of the
-    // view definition: Prop, Events.
+    // FTP Functions
+    AsyncFunction("ftpConnect") { (config: [String: Any], promise: Promise) in
+      Task {
+        do {
+          let ftpConfig = FtpConnectionConfig(
+            host: config["host"] as! String,
+            port: config["port"] as? Int ?? 21,
+            username: config["username"] as! String,
+            password: config["password"] as! String,
+            passive: config["passive"] as? Bool ?? true,
+            timeout: config["timeout"] as? TimeInterval ?? 30.0
+          )
+          
+          self.ftpClient = FtpClient()
+          let progressDelegate = FtpProgressDelegateImpl(module: self)
+          self.ftpClient?.setProgressDelegate(progressDelegate)
+          
+          try await self.ftpClient?.connect(config: ftpConfig)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_CONNECT_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDisconnect") { (promise: Promise) in
+      Task {
+        await self.ftpClient?.disconnect()
+        self.ftpClient = nil
+        promise.resolve()
+      }
+    }
+
+    AsyncFunction("ftpList") { (path: String?, promise: Promise) in
+      Task {
+        do {
+          let files = try await self.ftpClient?.listFiles(path: path) ?? []
+          let result = files.map { file in
+            [
+              "name": file.name,
+              "isDirectory": file.isDirectory,
+              "size": file.size,
+              "lastModified": file.lastModified,
+              "permissions": file.permissions as Any
+            ]
+          }
+          promise.resolve(result)
+        } catch {
+          promise.reject("FTP_LIST_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDownload") { (remotePath: String, localPath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.downloadFile(remotePath: remotePath, localPath: localPath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_DOWNLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpUpload") { (localPath: String, remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.uploadFile(localPath: localPath, remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_UPLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDelete") { (remotePath: String, isDirectory: Bool?, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.deleteFile(remotePath: remotePath, isDirectory: isDirectory ?? false)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_DELETE_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpCreateDirectory") { (remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.createDirectory(remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_CREATE_DIR_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpChangeDirectory") { (remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.changeDirectory(remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_CHANGE_DIR_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpGetCurrentDirectory") { (promise: Promise) in
+      Task {
+        do {
+          let currentDir = try await self.ftpClient?.getCurrentDirectory() ?? "/"
+          promise.resolve(currentDir)
+        } catch {
+          promise.reject("FTP_PWD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    // Enables the module to be used as a native view. Definition components that are accepted as part of
+    // the view definition: Prop, Events.
     View(ReactNativeKookitView.self) {
       // Defines a setter for the `url` prop.
       Prop("url") { (view: ReactNativeKookitView, url: URL) in
@@ -142,4 +1002,30 @@ public class ReactNativeKookitModule: Module {
       }
     }
   }
+}
+
+// Helper class to handle FTP progress callbacks
+private class FtpProgressDelegateImpl: FtpProgressDelegate {
+  weak var module: ReactNativeKookitModule?
+  
+  init(module: ReactNativeKookitModule) {
+    self.module = module
+  }
+  
+  func onProgress(transferred: Int64, total: Int64) {
+    let percentage = total > 0 ? Int((transferred * 100) / total) : 0
+    module?.sendEvent("onFtpProgress", [
+      "transferred": transferred,
+      "total": total,
+      "percentage": percentage
+    ])
+  }
+  
+  func onComplete() {
+    module?.sendEvent("onFtpComplete")
+  }
+  
+  func onError(error: String) {
+    module?.sendEvent("onFtpError", ["error": error])
+  }
 }