@cappitolian/http-local-server-swifter 0.0.26 → 0.0.28

package/android/src/main/java/com/cappitolian/plugins/httplocalserviceswifter/HttpLocalServerSwifter.java

@@ -219,6 +219,9 @@ public class HttpLocalServerSwifter {
             response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
             response.addHeader("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization, X-Requested-With");
             response.addHeader("Access-Control-Max-Age", "3600");
+            // Prevents TCP connection reuse. NanoHTTPD does not handle keep-alive
+            // correctly under rapid sequential requests, causing ERR_INVALID_HTTP_RESPONSE.
+            response.addHeader("Connection", "close");
         }
 
         private Response createErrorResponse(String message, Response.Status status) {

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifter.swift

@@ -9,161 +9,201 @@ public protocol HttpLocalServerSwifterDelegate: AnyObject {
 @objc public class HttpLocalServerSwifter: NSObject {
     private var webServer: HttpServer?
     private weak var delegate: HttpLocalServerSwifterDelegate?
-    
+
     private static var pendingResponses = [String: (String) -> Void]()
-    private static let queue = DispatchQueue(label: "com.cappitolian.HttpLocalServerSwifter.pendingResponses", qos: .userInitiated)
-    
+    private static let queue = DispatchQueue(
+        label: "com.cappitolian.HttpLocalServerSwifter.pendingResponses",
+        qos: .userInitiated
+    )
+
     private let defaultTimeout: TimeInterval = 10.0
     private let defaultPort: UInt16 = 8080
-    
+
     public init(delegate: HttpLocalServerSwifterDelegate) {
         self.delegate = delegate
         super.init()
     }
-    
+
+    // MARK: - Public API
+
     @objc public func connect(_ call: CAPPluginCall) {
-        // IMPORTANT: Move execution to a background thread immediately
         DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-            guard let self = self else { return }
-            
-            self.disconnect()
+            guard let self else { return }
+
+            self.stopServer()
+
             let server = HttpServer()
             self.webServer = server
-            
-            // Use middleware to catch ALL requests and avoid route misses
+
             server.middleware.append { [weak self] request in
+                guard let self else { return .raw(503, "Service Unavailable", nil, nil) }
+
                 if request.method == "OPTIONS" {
-                    return self?.corsResponse() ?? .raw(204, "No Content", nil, nil)
+                    return self.corsResponse()
                 }
-                return self?.processRequest(request) ?? .raw(500, "Internal Server Error", nil, nil)
+                return self.processRequest(request)
             }
-            
+
             do {
-                // We start the server. This call is non-blocking in Swifter but 
-                // it's safer to do it here.
                 try server.start(self.defaultPort, forceIPv4: true)
                 let ip = Self.getWiFiAddress() ?? "127.0.0.1"
-                
+
                 print("🚀 SWIFTER: Server running on http://\(ip):\(self.defaultPort)")
-                
-                // Resolve back to Angular
+
                 call.resolve([
                     "ip": ip,
                     "port": Int(self.defaultPort)
                 ])
             } catch {
                 print("❌ SWIFTER ERROR: \(error)")
-                call.reject("Could not start server")
+                call.reject("Could not start server: \(error.localizedDescription)")
             }
         }
     }
-    
-    @objc public func disconnect(_ call: CAPPluginCall? = nil) {
+
+    /// Stops the server and clears state. Does NOT resolve/reject any call.
+    @objc public func stopServer() {
         webServer?.stop()
         webServer = nil
-        Self.queue.async { Self.pendingResponses.removeAll() }
-        call?.resolve()
+        // Drain pending futures so blocked threads can unblock on their semaphore timeout.
+        Self.queue.sync { Self.pendingResponses.removeAll() }
+    }
+
+    /// Stops the server and resolves the Capacitor call.
+    @objc public func disconnect(resolving call: CAPPluginCall) {
+        stopServer()
+        call.resolve()
     }
 
+    // MARK: - JS → Native response bridge
+
+    static func handleJsResponse(requestId: String, responseData: [String: Any]) {
+        // sync: guarantees the callback executes (and signals the semaphore) before
+        // this function returns, which eliminates the race condition where the
+        // semaphore wait could time out while the callback is still queued.
+        queue.sync {
+            guard let callback = pendingResponses.removeValue(forKey: requestId) else { return }
+
+            guard
+                let jsonData = try? JSONSerialization.data(withJSONObject: responseData),
+                let jsonString = String(data: jsonData, encoding: .utf8)
+            else { return }
+
+            callback(jsonString)
+        }
+    }
+
+    // MARK: - Request processing
+
     private func processRequest(_ request: HttpRequest) -> HttpResponse {
         let requestId = UUID().uuidString
+
+        // Use a protected local variable written only inside `queue.sync` inside
+        // the callback, and read only after the semaphore is signalled — the
+        // happens-before guarantee of DispatchSemaphore makes this safe.
         var responseString: String?
         let semaphore = DispatchSemaphore(value: 0)
-        
-        Self.queue.async {
+
+        Self.queue.sync {
             Self.pendingResponses[requestId] = { jsResponse in
                 responseString = jsResponse
                 semaphore.signal()
             }
         }
-        
+
         let requestData: [String: Any] = [
             "requestId": requestId,
-            "method": request.method,
-            "path": request.path,
-            "headers": request.headers,
-            "query": request.queryParams,
-            "body": String(bytes: request.body, encoding: .utf8) ?? ""
+            "method":    request.method,
+            "path":      request.path,
+            "headers":   request.headers,
+            "query":     request.queryParams,
+            "body":      String(bytes: request.body, encoding: .utf8) ?? ""
         ]
-        
-        // CRITICAL: notifyListeners MUST be called from the Main Thread
+
+        // notifyListeners MUST be called from the main thread.
         DispatchQueue.main.async {
             self.delegate?.httpLocalServerSwifterDidReceiveRequest(requestData)
         }
-        
+
         let result = semaphore.wait(timeout: .now() + defaultTimeout)
-        
+
         if result == .timedOut {
-            Self.queue.async { Self.pendingResponses.removeValue(forKey: requestId) }
+            // Remove callback in case handleJsResponse fires late.
+            Self.queue.sync { Self.pendingResponses.removeValue(forKey: requestId) }
             return .raw(408, "Request Timeout", nil, nil)
         }
-        
+
         return createDynamicResponse(responseString ?? "")
     }
 
-    static func handleJsResponse(requestId: String, responseData: [String: Any]) {
-        queue.async {
-            if let callback = pendingResponses[requestId] {
-                // Extract body, status and headers to pass as a JSON string to the semaphore
-                if let jsonData = try? JSONSerialization.data(withJSONObject: responseData),
-                   let jsonString = String(data: jsonData, encoding: .utf8) {
-                    callback(jsonString)
-                }
-                pendingResponses.removeValue(forKey: requestId)
-            }
-        }
-    }
+    // MARK: - Response builders
 
     private func createDynamicResponse(_ jsonResponse: String) -> HttpResponse {
         var finalStatus = 200
-        var finalBody = jsonResponse
+        var finalBody   = jsonResponse
         var headers: [String: String] = [
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-            "Access-Control-Allow-Headers": "Origin, Content-Type, Accept, Authorization, X-Requested-With"
+            "Content-Type":                     "application/json",
+            "Access-Control-Allow-Origin":      "*",
+            "Access-Control-Allow-Methods":     "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers":     "Origin, Content-Type, Accept, Authorization, X-Requested-With"
         ]
-        
-        if let data = jsonResponse.data(using: .utf8),
-           let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
-            finalBody = dict["body"] as? String ?? ""
-            finalStatus = dict["status"] as? Int ?? 200
+
+        if
+            let data = jsonResponse.data(using: .utf8),
+            let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        {
+            finalBody   = dict["body"]   as? String ?? ""
+            finalStatus = dict["status"] as? Int    ?? 200
+
             if let customHeaders = dict["headers"] as? [String: String] {
                 for (key, value) in customHeaders { headers[key] = value }
             }
         }
-        
-        return .raw(finalStatus, "OK", headers) { try $0.write([UInt8](finalBody.utf8)) }
+
+        return .raw(finalStatus, "OK", headers) { writer in
+            try writer.write([UInt8](finalBody.utf8))
+        }
     }
 
     private func corsResponse() -> HttpResponse {
         return .raw(204, "No Content", [
-            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Origin":  "*",
             "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
             "Access-Control-Allow-Headers": "Origin, Content-Type, Accept, Authorization, X-Requested-With",
-            "Access-Control-Max-Age": "86400"
+            "Access-Control-Max-Age":       "86400"
         ], nil)
     }
 
+    // MARK: - Network helpers
+
     static func getWiFiAddress() -> String? {
         var address: String?
         var ifaddr: UnsafeMutablePointer<ifaddrs>?
-        if getifaddrs(&ifaddr) == 0 {
-            var ptr = ifaddr
-            while ptr != nil {
-                let interface = ptr!.pointee
-                if interface.ifa_addr.pointee.sa_family == UInt8(AF_INET) {
-                    let name = String(cString: interface.ifa_name)
-                    if name == "en0" {
-                        var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
-                        getnameinfo(interface.ifa_addr, socklen_t(interface.ifa_addr.pointee.sa_len), &hostname, socklen_t(hostname.count), nil, 0, NI_NUMERICHOST)
-                        address = String(cString: hostname)
-                    }
-                }
-                ptr = interface.ifa_next
+
+        guard getifaddrs(&ifaddr) == 0 else { return nil }
+        defer { freeifaddrs(ifaddr) }
+
+        var ptr = ifaddr
+        while let current = ptr {
+            let interface = current.pointee
+            if interface.ifa_addr.pointee.sa_family == UInt8(AF_INET),
+               String(cString: interface.ifa_name) == "en0"
+            {
+                var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+                getnameinfo(
+                    interface.ifa_addr,
+                    socklen_t(interface.ifa_addr.pointee.sa_len),
+                    &hostname,
+                    socklen_t(hostname.count),
+                    nil, 0,
+                    NI_NUMERICHOST
+                )
+                address = String(cString: hostname)
+                break
             }
-            freeifaddrs(ifaddr)
+            ptr = interface.ifa_next
         }
+
         return address
     }
 }

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifterPlugin.swift

@@ -3,42 +3,49 @@ import Capacitor
 
 @objc(HttpLocalServerSwifterPlugin)
 public class HttpLocalServerSwifterPlugin: CAPPlugin, CAPBridgedPlugin, HttpLocalServerSwifterDelegate {
-    public let identifier = "HttpLocalServerSwifterPlugin"
-    public let jsName = "HttpLocalServerSwifter"
+    public let identifier   = "HttpLocalServerSwifterPlugin"
+    public let jsName       = "HttpLocalServerSwifter"
     public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "connect", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "disconnect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "connect",      returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "disconnect",   returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "sendResponse", returnType: CAPPluginReturnPromise)
     ]
-    
+
     private var localServer: HttpLocalServerSwifter?
-    
+
+    // MARK: - Plugin methods
+
     @objc func connect(_ call: CAPPluginCall) {
-        if localServer == nil { localServer = HttpLocalServerSwifter(delegate: self) }
+        if localServer == nil {
+            localServer = HttpLocalServerSwifter(delegate: self)
+        }
         localServer?.connect(call)
     }
-    
+
     @objc func disconnect(_ call: CAPPluginCall) {
-        localServer?.disconnect(call)
+        // Use the dedicated method that accepts a call to resolve so the
+        // ambiguous no-argument overload is gone entirely.
+        localServer?.disconnect(resolving: call)
         localServer = nil
     }
-    
-  @objc func sendResponse(_ call: CAPPluginCall) {
-      guard let requestId = call.getString("requestId") else {
-          call.reject("Missing requestId")
-          return
-      }
-      
-      // Cast dictionaryRepresentation explicitly to [String: Any]
-      if let responseData = call.dictionaryRepresentation as? [String: Any] {
-          HttpLocalServerSwifter.handleJsResponse(requestId: requestId, responseData: responseData)
-          call.resolve()
-      } else {
-          call.reject("Could not parse response data")
-      }
-  }
-    
+
+    @objc func sendResponse(_ call: CAPPluginCall) {
+        guard let requestId = call.getString("requestId"), !requestId.isEmpty else {
+            call.reject("Missing requestId")
+            return
+        }
+
+        // dictionaryRepresentation already returns [String: Any] — no cast needed.
+        HttpLocalServerSwifter.handleJsResponse(
+            requestId:    requestId,
+            responseData: call.dictionaryRepresentation
+        )
+        call.resolve()
+    }
+
+    // MARK: - Delegate
+
     public func httpLocalServerSwifterDidReceiveRequest(_ data: [String: Any]) {
         notifyListeners("onRequest", data: data)
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cappitolian/http-local-server-swifter",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Runs a local HTTP server on your device, accessible over LAN. Supports connect, disconnect, GET, and POST methods with IP and port discovery.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",