@cappitolian/http-local-server-swifter 0.0.13 → 0.0.15

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifter.swift

@@ -2,338 +2,168 @@ import Foundation
 import Swifter
 import Capacitor
 
-// MARK: - Protocol
 public protocol HttpLocalServerSwifterDelegate: AnyObject {
     func httpLocalServerSwifterDidReceiveRequest(_ data: [String: Any])
 }
 
-// MARK: - HttpLocalServerSwifter
 @objc public class HttpLocalServerSwifter: NSObject {
-    // MARK: - Properties
     private var webServer: HttpServer?
     private weak var delegate: HttpLocalServerSwifterDelegate?
     
+    // Store callbacks that expect a JSON String containing the full response object
     private static var pendingResponses = [String: (String) -> Void]()
     private static let queue = DispatchQueue(label: "com.cappitolian.HttpLocalServerSwifter.pendingResponses", qos: .userInitiated)
     
-    private let defaultTimeout: TimeInterval = 30.0 // Aumentado para debugging
+    private let defaultTimeout: TimeInterval = 10.0
     private let defaultPort: UInt16 = 8080
     
-    // MARK: - Initialization
     public init(delegate: HttpLocalServerSwifterDelegate) {
         self.delegate = delegate
         super.init()
     }
     
-    deinit {
-        disconnect()
-    }
-    
-    // MARK: - Public Methods
     @objc public func connect(_ call: CAPPluginCall) {
-        // Stop existing server if running
         self.disconnect()
-        
         self.webServer = HttpServer()
         self.setupHandlers()
-        
         do {
-            try self.startServer()
+            try self.webServer?.start(defaultPort, forceIPv4: true)
             let ip = Self.getWiFiAddress() ?? "127.0.0.1"
-            
-            print("✅ HttpLocalServerSwifter: Server started on \(ip):\(self.defaultPort)")
-            
-            call.resolve([
-                "ip": ip,
-                "port": self.defaultPort
-            ])
+            call.resolve(["ip": ip, "port": self.defaultPort])
         } catch {
-            print("❌ HttpLocalServerSwifter: Failed to start server - \(error.localizedDescription)")
             call.reject("Failed to start server: \(error.localizedDescription)")
         }
     }
     
     @objc public func disconnect(_ call: CAPPluginCall? = nil) {
-        disconnect()
+        webServer?.stop()
+        webServer = nil
+        Self.queue.async { Self.pendingResponses.removeAll() }
         call?.resolve()
     }
     
-    // MARK: - Static Methods
-    static func handleJsResponse(requestId: String, body: String) {
+    /**
+     * Serializes the JS response dictionary to JSON to pass it back to the processing thread
+     */
+    static func handleJsResponse(requestId: String, responseData: [String: Any]) {
         queue.async {
             if let callback = pendingResponses[requestId] {
-                callback(body)
+                if let jsonData = try? JSONSerialization.data(withJSONObject: responseData),
+                   let jsonString = String(data: jsonData, encoding: .utf8) {
+                    callback(jsonString)
+                }
                 pendingResponses.removeValue(forKey: requestId)
-                print("✅ HttpLocalServerSwifter: Response sent for requestId: \(requestId)")
-            } else {
-                print("⚠️ HttpLocalServerSwifter: No pending callback for requestId: \(requestId)")
             }
         }
     }
     
-    // MARK: - Private Methods
-    private func disconnect() {
-        webServer?.stop()
-        webServer = nil
-        
-        // Clear pending responses
-        Self.queue.async {
-            Self.pendingResponses.removeAll()
-        }
-        
-        print("🛑 HttpLocalServerSwifter: Server stopped")
-    }
-    
     private func setupHandlers() {
         guard let server = webServer else { return }
-
-        server["/"] = { [weak self] request in
-            return self?.handleRequest(request) ?? self?.errorResponse() ?? .internalServerError
-        }
-
-        server["/:path"] = { [weak self] request in
-            return self?.handleRequest(request) ?? self?.errorResponse() ?? .internalServerError
-        }
-
-        server["/:first/:second"] = { [weak self] request in
-            return self?.handleRequest(request) ?? self?.errorResponse() ?? .internalServerError
-        }
-
-        server["/:first/:second/:third"] = { [weak self] request in
-            return self?.handleRequest(request) ?? self?.errorResponse() ?? .internalServerError
+        
+        // This closure handles EVERY request regardless of the path
+        let handler: ((HttpRequest) -> HttpResponse) = { [weak self] request in
+            if request.method == "OPTIONS" { 
+                return self?.corsResponse() ?? .raw(204, "No Content", nil, nil) 
+            }
+            return self?.processRequest(request) ?? .raw(500, "Internal Server Error", nil, nil)
         }
 
-        print("✅ HttpLocalServerSwifter: Handlers configured")
-    }
-    
-    private func handleRequest(_ request: HttpRequest) -> HttpResponse {
-        print("📨 HttpLocalServerSwifter: Received \(request.method) request to \(request.path)")
-        
-        // Handle OPTIONS (CORS preflight)
-        if request.method == "OPTIONS" {
-            print("🔄 HttpLocalServerSwifter: Handling CORS preflight")
-            return corsResponse()
+        // Swifter needs a wildcard to catch everything including subpaths like /orders/123
+        server.middleware.append { request in
+            return handler(request)
         }
-        
-        return processRequest(request)
     }
     
     private func processRequest(_ request: HttpRequest) -> HttpResponse {
-        let method = request.method
-        let path = request.path
-        let body = extractBody(from: request)
-        let headers = extractHeaders(from: request)
-        let query = extractQuery(from: request)
-        
         let requestId = UUID().uuidString
         var responseString: String?
-        
-        // Setup semaphore for synchronous waiting
         let semaphore = DispatchSemaphore(value: 0)
         
         Self.queue.async {
-            Self.pendingResponses[requestId] = { responseBody in
-                responseString = responseBody
+            Self.pendingResponses[requestId] = { jsResponse in
+                responseString = jsResponse
                 semaphore.signal()
             }
         }
         
-        // Notify delegate with request info
-        var requestData: [String: Any] = [
+        // Map request to dictionary for TS
+        let requestData: [String: Any] = [
             "requestId": requestId,
-            "method": method,
-            "path": path
+            "method": request.method,
+            "path": request.path,
+            "headers": request.headers,
+            "query": request.queryParams,
+            "body": String(bytes: request.body, encoding: .utf8) ?? ""
         ]
         
-        // Only add if they exist (consistent with TypeScript and Android)
-        if let body = body, !body.isEmpty {
-            requestData["body"] = body
-        }
-        
-        if !headers.isEmpty {
-            requestData["headers"] = headers
-        }
-        
-        if !query.isEmpty {
-            requestData["query"] = query
-        }
-        
-        print("📤 HttpLocalServerSwifter: Notifying delegate with requestId: \(requestId)")
+        DispatchQueue.main.async { self.delegate?.httpLocalServerSwifterDidReceiveRequest(requestData) }
         
-        // Notify on main thread to ensure proper event delivery
-        DispatchQueue.main.async { [weak self] in
-            self?.delegate?.httpLocalServerSwifterDidReceiveRequest(requestData)
-        }
-        
-        // Wait for JS response or timeout
         let result = semaphore.wait(timeout: .now() + defaultTimeout)
         
-        // Cleanup
-        Self.queue.async {
-            Self.pendingResponses.removeValue(forKey: requestId)
-        }
-        
-        // Handle timeout
         if result == .timedOut {
-            print("⏱️ HttpLocalServerSwifter: Request timeout for requestId: \(requestId)")
-            let timeoutResponse = "{\"error\":\"Request timeout\",\"requestId\":\"\(requestId)\"}"
-            return createJsonResponse(timeoutResponse, statusCode: 408)
+            return createDynamicResponse("{\"error\":\"timeout\"}", statusCode: 408)
         }
         
-        let reply = responseString ?? "{\"error\":\"No response from handler\"}"
-        print("✅ HttpLocalServerSwifter: Sending response for requestId: \(requestId)")
-        return createJsonResponse(reply)
+        return createDynamicResponse(responseString ?? "{\"error\":\"no_response\"}")
     }
     
-    private func extractBody(from request: HttpRequest) -> String? {
-        let bodyBytes = request.body
-    
-        guard !bodyBytes.isEmpty else {
-            return nil
-        }
-    
-        return String(bytes: bodyBytes, encoding: .utf8)
-    }
-    
-    private func extractHeaders(from request: HttpRequest) -> [String: String] {
-        var headersDict: [String: String] = [:]
-        for (key, value) in request.headers {
-            headersDict[key] = value
-        }
-        return headersDict
-    }
-    
-    private func extractQuery(from request: HttpRequest) -> [String: String] {
-        var queryDict: [String: String] = [:]
-        for (key, value) in request.queryParams {
-            queryDict[key] = value
-        }
-        return queryDict
-    }
-    
-    private func createJsonResponse(_ body: String, statusCode: Int = 200) -> HttpResponse {
-        let headers: [String: String] = [
+    /**
+     * Extracts status, headers, and body from the JSON string provided by TypeScript
+     */
+    private func createDynamicResponse(_ jsonResponse: String, statusCode defaultStatus: Int = 200) -> HttpResponse {
+        var finalStatus = defaultStatus
+        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",
-            "Access-Control-Allow-Credentials": "true",
+            "Access-Control-Allow-Headers": "Origin, Content-Type, Accept, Authorization, X-Requested-With",
             "Access-Control-Max-Age": "3600"
         ]
         
-        let bodyData = [UInt8](body.utf8)
-        
-        return HttpResponse.raw(statusCode, statusDescription(for: statusCode), headers) { writer in
-            try writer.write(bodyData)
+        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 }
+            }
         }
+        
+        let bodyData = [UInt8](finalBody.utf8)
+        return HttpResponse.raw(finalStatus, "OK", headers) { try $0.write(bodyData) }
     }
     
     private func corsResponse() -> HttpResponse {
-        let headers: [String: String] = [
+        return HttpResponse.raw(204, "No Content", [
             "Access-Control-Allow-Origin": "*",
             "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-            "Access-Control-Allow-Headers": "Origin, Content-Type, Accept, Authorization",
-            "Access-Control-Allow-Credentials": "true",
+            "Access-Control-Allow-Headers": "Origin, Content-Type, Accept, Authorization, X-Requested-With",
             "Access-Control-Max-Age": "3600"
-        ]
-        
-        return HttpResponse.raw(204, "No Content", headers, nil)
-    }
-    
-    private func errorResponse() -> HttpResponse {
-        return createJsonResponse("{\"error\":\"Server error\"}", statusCode: 500)
+        ], nil)
     }
-    
-    private func statusDescription(for code: Int) -> String {
-        switch code {
-        case 200: return "OK"
-        case 201: return "Created"
-        case 202: return "Accepted"
-        case 204: return "No Content"
-        case 400: return "Bad Request"
-        case 401: return "Unauthorized"
-        case 403: return "Forbidden"
-        case 404: return "Not Found"
-        case 408: return "Request Timeout"
-        case 500: return "Internal Server Error"
-        default: return "Unknown"
-        }
-    }
-    
-    private func startServer() throws {
-        guard let server = webServer else {
-            throw NSError(
-                domain: "HttpLocalServerSwifter",
-                code: -1,
-                userInfo: [NSLocalizedDescriptionKey: "WebServer not initialized"]
-            )
-        }
-        
-        // Try to start on the default port
-        do {
-            try server.start(defaultPort, forceIPv4: true)
-            print("✅ HttpLocalServerSwifter: Server listening on port \(defaultPort)")
-        } catch {
-            print("❌ HttpLocalServerSwifter: Failed to bind to port \(defaultPort): \(error)")
-            throw error
-        }
-    }
-    
-    // MARK: - Network Utilities
+
+    // WiFi address logic remains the same...
     static func getWiFiAddress() -> String? {
         var address: String?
         var ifaddr: UnsafeMutablePointer<ifaddrs>?
-        
-        guard getifaddrs(&ifaddr) == 0 else {
-            print("❌ HttpLocalServerSwifter: Failed to get network interfaces")
-            return nil
-        }
-        
-        defer {
-            freeifaddrs(ifaddr)
-        }
-        
-        var ptr = ifaddr
-        while ptr != nil {
-            defer { ptr = ptr?.pointee.ifa_next }
-            
-            guard let interface = ptr?.pointee else { continue }
-            
-            let addrFamily = interface.ifa_addr.pointee.sa_family
-            
-            // Check for IPv4 interface
-            guard addrFamily == UInt8(AF_INET) else { continue }
-            
-            let name = String(cString: interface.ifa_name)
-            
-            // WiFi interface (en0) or cellular (pdp_ip0)
-            guard name == "en0" || name == "pdp_ip0" else { continue }
-            
-            var addr = interface.ifa_addr.pointee
-            var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
-            
-            let result = getnameinfo(
-                &addr,
-                socklen_t(interface.ifa_addr.pointee.sa_len),
-                &hostname,
-                socklen_t(hostname.count),
-                nil,
-                0,
-                NI_NUMERICHOST
-            )
-            
-            guard result == 0 else { continue }
-            
-            address = String(cString: hostname)
-            
-            print("📡 HttpLocalServerSwifter: Found \(name) interface with IP: \(address ?? "unknown")")
-            
-            // Prefer en0 (WiFi) over pdp_ip0 (cellular)
-            if name == "en0" {
-                break
+        if getifaddrs(&ifaddr) == 0 {
+            var ptr = ifaddr
+            while ptr != nil {
+                let interface = ptr!.pointee
+                let addrFamily = interface.ifa_addr.pointee.sa_family
+                if addrFamily == 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
             }
+            freeifaddrs(ifaddr)
         }
-        
         return address
     }
-}
+}

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifterPlugin.swift

@@ -3,7 +3,6 @@ import Capacitor
 
 @objc(HttpLocalServerSwifterPlugin)
 public class HttpLocalServerSwifterPlugin: CAPPlugin, CAPBridgedPlugin, HttpLocalServerSwifterDelegate {
-    // MARK: - CAPBridgedPlugin Properties
     public let identifier = "HttpLocalServerSwifterPlugin"
     public let jsName = "HttpLocalServerSwifter"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -12,59 +11,34 @@ public class HttpLocalServerSwifterPlugin: CAPPlugin, CAPBridgedPlugin, HttpLoca
         CAPPluginMethod(name: "sendResponse", returnType: CAPPluginReturnPromise)
     ]
     
-    // MARK: - Properties
     private var localServer: HttpLocalServerSwifter?
     
-    // MARK: - Lifecycle
-    public override func load() {
-        print("✅ HttpLocalServerSwifterPlugin: Plugin loaded")
-    }
-    
-    // MARK: - Plugin Methods
     @objc func connect(_ call: CAPPluginCall) {
-        print("📞 HttpLocalServerSwifterPlugin: connect() called")
-        
-        if localServer == nil {
-            localServer = HttpLocalServerSwifter(delegate: self)
-            print("✅ HttpLocalServerSwifterPlugin: Server instance created")
-        }
-        
+        if localServer == nil { localServer = HttpLocalServerSwifter(delegate: self) }
         localServer?.connect(call)
     }
     
     @objc func disconnect(_ call: CAPPluginCall) {
-        print("📞 HttpLocalServerSwifterPlugin: disconnect() called")
-        
-        if localServer != nil {
-            localServer?.disconnect(call)
-            localServer = nil
-        } else {
-            call.resolve()
-        }
+        localServer?.disconnect(call)
+        localServer = nil
     }
     
-    @objc func sendResponse(_ call: CAPPluginCall) {
-        guard let requestId = call.getString("requestId") else {
-            print("❌ HttpLocalServerSwifterPlugin: Missing requestId")
-            call.reject("Missing requestId")
-            return
-        }
-        
-        guard let body = call.getString("body") else {
-            print("❌ HttpLocalServerSwifterPlugin: Missing body")
-            call.reject("Missing body")
-            return
-        }
-        
-        print("📤 HttpLocalServerSwifterPlugin: sendResponse for requestId: \(requestId)")
-        HttpLocalServerSwifter.handleJsResponse(requestId: requestId, body: body)
-        call.resolve()
-    }
+  @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")
+      }
+  }
     
-    // MARK: - HttpLocalServerSwifterDelegate
     public func httpLocalServerSwifterDidReceiveRequest(_ data: [String: Any]) {
-        print("📨 HttpLocalServerSwifterPlugin: Received request, notifying listeners")
-        print("   Request data: \(data)")
         notifyListeners("onRequest", data: data)
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cappitolian/http-local-server-swifter",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "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",