@cappitolian/http-local-server-swifter 0.0.19 → 0.0.20

package/ios/Sources/HttpLocalServerSwifterPlugin/LocalNetworkPermission.swift

@@ -9,10 +9,12 @@ import UIKit
 /// server.start() will always succeed regardless of permission status.
 ///
 /// Detection strategy:
-///   - Trigger the system dialog by starting a NWBrowser.
-///   - Listen to the browser's state change callback to detect denial.
-///   - Surface the result via a completion handler so the plugin can
-///     reject the Capacitor call with LOCAL_NETWORK_PERMISSION_DENIED.
+///   - Send a UDP probe to the mDNS multicast address (224.0.0.251:5353).
+///   - This triggers the system permission dialog without requiring any
+///     NSBonjourServices entry in Info.plist.
+///   - NWBrowser was avoided because it requires the browsed service type
+///     to be declared in NSBonjourServices, causing false NoAuth(-65555)
+///     failures even when the permission is actually granted.
 @objc public class LocalNetworkPermission: NSObject {
 
     // MARK: - Types
@@ -25,76 +27,83 @@ import UIKit
 
     // MARK: - Private state
 
-    private var browser: NWBrowser?
+    private var connection: NWConnection?
 
     // MARK: - Permission check
 
-    /// Triggers the Local Network permission dialog and returns the result
-    /// asynchronously via the completion handler.
+    /// Probes the local network to trigger the permission dialog and detect the result.
+    ///
+    /// Sends a UDP packet to the mDNS multicast address. iOS intercepts this at the
+    /// network layer and either allows it (granted) or blocks it with a policy error (denied).
     ///
     /// - Parameter completion: Called on the main thread with the permission status.
-    ///   Will be called with `.granted` or `.denied` once iOS responds,
-    ///   or `.unknown` if the result could not be determined within the timeout.
+    ///   `.granted` / `.denied` once iOS responds, or `.unknown` on timeout
+    ///   (simulator, permission already granted and cached by the OS, etc.).
     ///
-    /// - Note: iOS shows the dialog only once. On subsequent calls this method
-    ///   will return the previously stored decision immediately (no dialog shown).
+    /// - Note: iOS shows the dialog only once. Subsequent calls return the cached decision.
     public func checkPermission(completion: @escaping (PermissionStatus) -> Void) {
-        let parameters = NWParameters()
-        parameters.includePeerToPeer = true
+        // mDNS multicast address — probing this triggers the Local Network permission dialog.
+        // This approach does NOT require NSBonjourServices in Info.plist.
+        let host = NWEndpoint.Host("224.0.0.251")
+        let port = NWEndpoint.Port(rawValue: 5353)!
 
-        let browser = NWBrowser(
-            for: .bonjour(type: "_http._tcp", domain: "local."),
-            using: parameters
-        )
-        self.browser = browser
+        let conn = NWConnection(host: host, port: port, using: .udp)
+        self.connection = conn
 
-        // Timeout fallback — if iOS doesn't respond in 3 seconds, assume unknown
-        // (e.g. on simulator or when the user has already granted permission)
         var completed = false
-        let timeout = DispatchWorkItem {
+
+        // Timeout fallback — treat unresolved state as unknown and allow server startup.
+        // This covers: simulator, permission already granted (OS may skip the callback),
+        // and edge cases where iOS doesn't fire stateUpdateHandler promptly.
+        let timeout = DispatchWorkItem { [weak self] in
             guard !completed else { return }
             completed = true
-            browser.cancel()
+            self?.connection?.cancel()
+            self?.connection = nil
             DispatchQueue.main.async { completion(.unknown) }
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 3.0, execute: timeout)
 
-        browser.stateUpdateHandler = { state in
+        conn.stateUpdateHandler = { [weak self] state in
             guard !completed else { return }
 
             switch state {
             case .ready:
-                // Browser started successfully — permission is granted
+                // UDP connection reached the network layer — permission is granted.
                 completed = true
                 timeout.cancel()
-                browser.cancel()
+                self?.connection?.cancel()
+                self?.connection = nil
                 DispatchQueue.main.async { completion(.granted) }
 
-            case .failed(let error):
-                // Check for policy denial errors:
-                //   kDNSServiceErr_PolicyDenied = -65570
-                //   kDNSServiceErr_NoAuth       = -65555
-                let nsError = error as NSError
-                let isDenied = nsError.code == -65570
-                    || nsError.code == -65555
-                    || error.localizedDescription.lowercased().contains("policy")
+            case .waiting(let error):
+                // .waiting with a policy error = permission denied.
+                // Other .waiting errors (no route, offline) are transient — keep waiting.
+                if Self.isPolicyDenied(error) {
+                    completed = true
+                    timeout.cancel()
+                    self?.connection?.cancel()
+                    self?.connection = nil
+                    DispatchQueue.main.async { completion(.denied) }
+                }
 
+            case .failed(let error):
+                let status: PermissionStatus = Self.isPolicyDenied(error) ? .denied : .unknown
                 completed = true
                 timeout.cancel()
-                browser.cancel()
-                DispatchQueue.main.async {
-                    completion(isDenied ? .denied : .unknown)
-                }
+                self?.connection?.cancel()
+                self?.connection = nil
+                DispatchQueue.main.async { completion(status) }
 
             case .cancelled:
-                break // Expected when we cancel it ourselves
+                break // Expected — we cancelled it ourselves above
 
             default:
-                break // .setup, .waiting — keep waiting
+                break // .setup, .preparing — keep waiting
             }
         }
 
-        browser.start(queue: .main)
+        conn.start(queue: .main)
     }
 
     // MARK: - Recovery
@@ -111,4 +120,19 @@ import UIKit
             UIApplication.shared.open(url)
         }
     }
+
+    // MARK: - Private helpers
+
+    /// Returns true if the NWError indicates a Local Network policy denial.
+    ///
+    /// Known denial error codes:
+    ///   - kDNSServiceErr_PolicyDenied = -65570
+    ///   - kDNSServiceErr_NoAuth       = -65555
+    private static func isPolicyDenied(_ error: NWError) -> Bool {
+        let nsError = error as NSError
+        if nsError.code == -65570 || nsError.code == -65555 { return true }
+
+        let desc = error.localizedDescription.lowercased()
+        return desc.contains("policy") || desc.contains("denied") || desc.contains("noauth")
+    }
 }

package/package.json

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