react-native-kookit 0.2.6 → 0.2.8

package/ios/ReactNativeKookitModule.swift

@@ -4,6 +4,7 @@ import MediaPlayer
 import AVFoundation
 import Foundation
 import Network
+import SMBClient
 
 // MARK: - FTP Related Types and Classes
 
@@ -292,10 +293,17 @@ class FtpClient: @unchecked Sendable {
         }
         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)")
+        // Check if the response already contained the completion message (226)
+        if response.contains("226") {
+            print("FTP DEBUG: Transfer completion already received in LIST response - skipping final response read")
+        } else {
+            print("FTP DEBUG: Reading final response...")
+            let finalResponse = try await readResponse()
+            let finalFirstLine = finalResponse.components(separatedBy: .newlines).first ?? finalResponse
+            print("FTP DEBUG: Final response: \(finalFirstLine)")
+            guard finalFirstLine.hasPrefix("226") else {
+                throw FtpError.commandFailed("LIST completion failed: \(finalFirstLine)")
+            }
         }
 
         let files = parseListingData(data)
@@ -796,7 +804,171 @@ class FtpClient: @unchecked Sendable {
     }
 }
 
-// MARK: - Main Module
+// MARK: - SMB Client with SMBClient library
+
+struct SmbFileInfo {
+    let name: String
+    let isDirectory: Bool
+    let size: Int64
+    let lastModified: String
+    let attributes: String?
+}
+
+class SmbClient: @unchecked Sendable {
+    private var client: SMBClient?
+    private(set) var isConnected: Bool = false
+    private var currentShare: String?
+    private weak var progressDelegate: SmbProgressDelegate?
+    
+    func connect(host: String, username: String, password: String, domain: String? = nil, share: String? = nil, timeout: TimeInterval = 10.0) async throws {
+        client = SMBClient(host: host)
+        
+        try await client!.login(username: username, password: password)
+        isConnected = true
+        
+        if let share = share {
+            try await client!.connectShare(share)
+            currentShare = share
+        }
+    }
+    
+    func connectShare(_ shareName: String) async throws {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        if currentShare != nil {
+            try await client.disconnectShare()
+        }
+        
+        try await client.connectShare(shareName)
+        currentShare = shareName
+    }
+    
+    func listFiles(path: String? = nil) async throws -> [SmbFileInfo] {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        guard currentShare != nil else {
+            throw FtpError.commandFailed("No share connected. Connect to a share first.")
+        }
+        
+        let directoryPath = path?.isEmpty == false ? path! : ""
+        let files = try await client.listDirectory(path: directoryPath)
+        
+        return files.map { file in
+            SmbFileInfo(
+                name: file.name,
+                isDirectory: file.isDirectory,
+                size: Int64(file.size),
+                lastModified: formatDate(file.lastWriteTime),
+                attributes: nil
+            )
+        }
+    }
+    
+    func downloadFile(remotePath: String, localPath: String) async throws {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        guard currentShare != nil else {
+            throw FtpError.commandFailed("No share connected. Connect to a share first.")
+        }
+        
+        let localURL = URL(fileURLWithPath: localPath)
+        try FileManager.default.createDirectory(at: localURL.deletingLastPathComponent(),
+                                              withIntermediateDirectories: true,
+                                              attributes: nil)
+        
+        let data = try await client.download(path: remotePath)
+        try data.write(to: localURL)
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func uploadFile(localPath: String, remotePath: String) async throws {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        guard currentShare != nil else {
+            throw FtpError.commandFailed("No share connected. Connect to a share first.")
+        }
+        
+        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)
+        try await client.upload(content: data, path: remotePath)
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func deleteFile(remotePath: String, isDirectory: Bool = false) async throws {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        guard currentShare != nil else {
+            throw FtpError.commandFailed("No share connected. Connect to a share first.")
+        }
+        
+        if isDirectory {
+            try await client.deleteDirectory(path: remotePath)
+        } else {
+            try await client.deleteFile(path: remotePath)
+        }
+    }
+    
+    func createDirectory(remotePath: String) async throws {
+        guard let client = client, isConnected else {
+            throw FtpError.notConnected
+        }
+        
+        guard currentShare != nil else {
+            throw FtpError.commandFailed("No share connected. Connect to a share first.")
+        }
+        
+        try await client.createDirectory(path: remotePath)
+    }
+    
+    func disconnect() async {
+        guard let client = client else { return }
+        
+        do {
+            if currentShare != nil {
+                try await client.disconnectShare()
+            }
+            try await client.logoff()
+        } catch {
+            // Ignore errors during disconnect
+        }
+        
+        self.client = nil
+        isConnected = false
+        currentShare = nil
+    }
+    
+    func setProgressDelegate(_ delegate: SmbProgressDelegate?) {
+        self.progressDelegate = delegate
+    }
+    
+    private func formatDate(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "MMM dd HH:mm"
+        return formatter.string(from: date)
+    }
+}
+
+protocol SmbProgressDelegate: AnyObject {
+    func onProgress(transferred: Int64, total: Int64)
+    func onComplete()
+    func onError(error: String)
+}// MARK: - Main Module
 
 public class ReactNativeKookitModule: Module {
   private var volumeView: MPVolumeView?
@@ -804,6 +976,7 @@ public class ReactNativeKookitModule: Module {
   private var isVolumeKeyInterceptionEnabled = false
   private var previousVolume: Float = 0.0
   private var ftpClients: [String: FtpClient] = [:]  // Store multiple FTP clients by ID
+  private var smbClients: [String: SmbClient] = [:]  // Store multiple SMB clients by ID
   
   // Each module class must implement the definition function. The definition consists of components
   // that describes the module's functionality and behavior.
@@ -820,7 +993,9 @@ public class ReactNativeKookitModule: Module {
     ])
 
     // Defines event names that the module can send to JavaScript.
-    Events("onChange", "onVolumeButtonPressed", "onFtpProgress", "onFtpComplete", "onFtpError")
+  Events("onChange", "onVolumeButtonPressed",
+       "onFtpProgress", "onFtpComplete", "onFtpError",
+       "onSmbProgress", "onSmbComplete", "onSmbError")
 
     // Defines a JavaScript synchronous function that runs the native code on the JavaScript thread.
     Function("hello") {
@@ -1109,6 +1284,209 @@ public class ReactNativeKookitModule: Module {
       ])
     }
 
+    // MARK: - SMB Client API
+
+    AsyncFunction("createSmbClient") { (clientId: String, promise: Promise) in
+      if self.smbClients[clientId] != nil {
+        promise.reject("SMB_CLIENT_EXISTS", "SMB client with ID '\(clientId)' already exists")
+        return
+      }
+      self.smbClients[clientId] = SmbClient()
+      promise.resolve(["clientId": clientId])
+    }
+
+    AsyncFunction("disposeSmbClient") { (clientId: String, promise: Promise) in
+      if let client = self.smbClients[clientId] {
+        Task {
+          await client.disconnect()
+          self.smbClients.removeValue(forKey: clientId)
+          promise.resolve([:])
+        }
+      } else {
+        promise.resolve([:])
+      }
+    }
+
+    AsyncFunction("getSmbClientStatus") { (clientId: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.resolve(["exists": false, "connected": false])
+        return
+      }
+      promise.resolve(["exists": true, "connected": client.isConnected])
+    }
+
+    AsyncFunction("listSmbClients") { (promise: Promise) in
+      let clientsInfo = self.smbClients.mapValues { client in
+        ["connected": client.isConnected]
+      }
+      promise.resolve(["clients": clientsInfo, "count": self.smbClients.count])
+    }
+
+    AsyncFunction("smbClientConnect") { (clientId: String, config: [String: Any], promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      let host = config["host"] as? String ?? ""
+      let username = config["username"] as? String ?? ""
+      let password = config["password"] as? String ?? ""
+      let domain = config["domain"] as? String
+      let share = config["share"] as? String
+      let timeout = (config["timeout"] as? TimeInterval) ?? 10.0
+      if host.isEmpty || username.isEmpty {
+        promise.reject("SMB_INVALID_CONFIG", "Missing host or username")
+        return
+      }
+      Task {
+        do {
+          try await client.connect(host: host, username: username, password: password, domain: domain, share: share, timeout: timeout)
+          promise.resolve(["clientId": clientId, "connected": true])
+        } catch {
+          promise.reject("SMB_CONNECT_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("smbClientDisconnect") { (clientId: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        await client.disconnect()
+        promise.resolve(["clientId": clientId, "disconnected": true])
+      }
+    }
+
+    AsyncFunction("smbClientConnectShare") { (clientId: String, shareName: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          try await client.connectShare(shareName)
+          promise.resolve(["clientId": clientId, "share": shareName, "connected": true])
+        } catch {
+          promise.reject("SMB_CONNECT_SHARE_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("smbClientList") { (clientId: String, path: String?, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          let files = try await client.listFiles(path: path)
+          let result = files.map { file in
+            [
+              "name": file.name,
+              "isDirectory": file.isDirectory,
+              "size": file.size,
+              "lastModified": file.lastModified,
+              "attributes": file.attributes as Any
+            ]
+          }
+          promise.resolve(result)
+        } catch {
+          promise.reject("SMB_LIST_ERROR", error.localizedDescription)
+        }
+      }
+    }
+    
+    AsyncFunction("smbClientDownload") { (clientId: String, remotePath: String, localPath: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          let progressDelegate = SmbProgressDelegateImpl(module: self, clientId: clientId)
+          client.setProgressDelegate(progressDelegate)
+          try await client.downloadFile(remotePath: remotePath, localPath: localPath)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "localPath": localPath,
+            "downloaded": true
+          ])
+        } catch {
+          self.sendEvent("onSmbError", [
+            "clientId": clientId,
+            "error": error.localizedDescription
+          ])
+          promise.reject("SMB_DOWNLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+    
+    AsyncFunction("smbClientUpload") { (clientId: String, localPath: String, remotePath: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          let progressDelegate = SmbProgressDelegateImpl(module: self, clientId: clientId)
+          client.setProgressDelegate(progressDelegate)
+          try await client.uploadFile(localPath: localPath, remotePath: remotePath)
+          promise.resolve([
+            "clientId": clientId,
+            "localPath": localPath,
+            "remotePath": remotePath,
+            "uploaded": true
+          ])
+        } catch {
+          self.sendEvent("onSmbError", [
+            "clientId": clientId,
+            "error": error.localizedDescription
+          ])
+          promise.reject("SMB_UPLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+    
+    AsyncFunction("smbClientDelete") { (clientId: String, remotePath: String, isDirectory: Bool?, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          try await client.deleteFile(remotePath: remotePath, isDirectory: isDirectory ?? false)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "deleted": true
+          ])
+        } catch {
+          promise.reject("SMB_DELETE_ERROR", error.localizedDescription)
+        }
+      }
+    }
+    
+    AsyncFunction("smbClientCreateDirectory") { (clientId: String, remotePath: String, promise: Promise) in
+      guard let client = self.smbClients[clientId] else {
+        promise.reject("SMB_CLIENT_NOT_FOUND", "SMB client with ID '\(clientId)' not found")
+        return
+      }
+      Task {
+        do {
+          try await client.createDirectory(remotePath: remotePath)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "created": true
+          ])
+        } catch {
+          promise.reject("SMB_CREATE_DIR_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) {
@@ -1236,4 +1614,38 @@ private class FtpProgressDelegateImpl: FtpProgressDelegate {
       "error": error
     ])
   }
+}
+
+// Helper class to handle SMB progress callbacks
+private class SmbProgressDelegateImpl: SmbProgressDelegate {
+  weak var module: ReactNativeKookitModule?
+  let clientId: String
+  
+  init(module: ReactNativeKookitModule, clientId: String) {
+    self.module = module
+    self.clientId = clientId
+  }
+  
+  func onProgress(transferred: Int64, total: Int64) {
+    let percentage = total > 0 ? Int((transferred * 100) / total) : 0
+    module?.sendEvent("onSmbProgress", [
+      "clientId": clientId,
+      "transferred": transferred,
+      "total": total,
+      "percentage": percentage
+    ])
+  }
+  
+  func onComplete() {
+    module?.sendEvent("onSmbComplete", [
+      "clientId": clientId
+    ])
+  }
+  
+  func onError(error: String) {
+    module?.sendEvent("onSmbError", [
+      "clientId": clientId,
+      "error": error
+    ])
+  }
 }

package/ios/SMBClient.podspec

@@ -0,0 +1,18 @@
+Pod::Spec.new do |s|
+  s.name             = 'SMBClient'
+  s.version          = '0.3.1'
+  s.summary          = 'SMB2/3 client implementation for iOS/macOS'
+  s.description      = 'A Swift implementation of SMB2/3 client protocol for iOS and macOS'
+  s.homepage         = 'https://github.com/kishikawakatsumi/SMBClient'
+  s.license          = { :type => 'MIT', :file => 'LICENSE' }
+  s.author           = { 'Kishikawa Katsumi' => 'kishikawakatsumi@mac.com' }
+  s.source           = { :git => 'https://github.com/kishikawakatsumi/SMBClient.git', :tag => s.version.to_s }
+
+  s.ios.deployment_target = '13.0'
+  s.osx.deployment_target = '10.15'
+  s.swift_version = '5.9'
+
+  s.source_files = 'Sources/SMBClient/**/*'
+  
+  s.frameworks = 'Foundation', 'Network'
+end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-kookit",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "React Native module for intercepting volume button presses on iOS and Android, with FTP client functionality",
   "main": "build/index.js",
   "types": "build/index.d.ts",