@cappitolian/http-local-server-swifter 0.0.23 → 0.0.24

package/ios/Sources/HttpLocalServerSwifterPlugin/LocalNetworkPermission.swift

@@ -8,12 +8,11 @@ import UIKit
 /// It only blocks mDNS/Bonjour service discovery. This means Swifter's
 /// server.start() will always succeed regardless of permission status.
 ///
-/// Detection strategy — NWListener with Bonjour advertising:
-///   NWBrowser returns .ready even when permission is revoked (iOS bug).
-///   NWListener advertising a Bonjour service correctly fails with PolicyDenied
-///   when Local Network permission is OFF, including previously-revoked cases.
-///
-///   The service type MUST match NSBonjourServices in Info.plist exactly.
+/// Detection strategy — NWListener with serviceRegistrationUpdateHandler:
+///   The PolicyDenied error for a revoked Local Network permission surfaces
+///   in NWListener.serviceRegistrationUpdateHandler, not in stateUpdateHandler.
+///   A connection handler must also be set or NWListener fails with error 22
+///   before iOS even evaluates the permission.
 @objc public class LocalNetworkPermission: NSObject {
 
     // MARK: - Types
@@ -37,14 +36,11 @@ import UIKit
 
     /// Checks Local Network permission by advertising a Bonjour service via NWListener.
     ///
-    /// NWListener is the only iOS API that correctly detects a revoked Local Network
-    /// permission. NWBrowser incorrectly returns .ready in that case (iOS bug).
+    /// The permission denial for a revoked permission surfaces in
+    /// serviceRegistrationUpdateHandler — not in stateUpdateHandler.
+    /// A dummy connection handler is required to prevent error 22 (Invalid argument).
     ///
     /// - Parameter completion: Called on the main thread with the permission status.
-    ///   `.granted` / `.denied` once iOS responds, or `.unknown` on timeout.
-    ///
-    /// - Note: iOS shows the system dialog only on the first call. Subsequent calls
-    ///   return the cached decision immediately without prompting the user.
     public func checkPermission(completion: @escaping (PermissionStatus) -> Void) {
         var completed = false
 
@@ -59,61 +55,69 @@ import UIKit
             }
         }
 
-        // Timeout fallback — allow startup if iOS never calls the state handler.
-        // Covers: simulator, and rare edge cases where the OS skips the callback.
         let timeout = DispatchWorkItem {
             print("⚠️ LocalNetworkPermission: timeout — resolving as .unknown")
             finish(.unknown)
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 5.0, execute: timeout)
 
-        // Create a TCP listener and advertise it as a Bonjour service.
-        // iOS evaluates the Local Network permission at advertisement time,
-        // not at socket bind time — which is why server.start() always succeeds.
         let params = NWParameters.tcp
         params.includePeerToPeer = true
 
         guard let listener = try? NWListener(using: params) else {
-            print("⚠️ LocalNetworkPermission: could not create NWListener — resolving as .unknown")
+            print("⚠️ LocalNetworkPermission: could not create NWListener")
             timeout.cancel()
             finish(.unknown)
             return
         }
 
-        // Advertising this service type triggers the system dialog on first launch
-        // and also immediately returns PolicyDenied when permission is revoked.
         listener.service = NWListener.Service(type: Self.bonjourServiceType)
         self.listener = listener
 
-        listener.stateUpdateHandler = { state in
-            print("🔍 LocalNetworkPermission NWListener state: \(state)")
-            switch state {
-            case .ready:
-                // Bonjour advertisement succeeded — permission is granted.
+        // Required: NWListener fails with error 22 (Invalid argument) if no
+        // connection handler is set. This dummy handler satisfies the requirement.
+        listener.newConnectionHandler = { connection in
+            connection.cancel()
+        }
+
+        // This is where iOS reports PolicyDenied for a revoked Local Network permission.
+        // stateUpdateHandler only reports generic listener errors, not Bonjour policy errors.
+        listener.serviceRegistrationUpdateHandler = { change in
+            print("🔍 LocalNetworkPermission serviceRegistration: \(change)")
+            switch change {
+            case .add:
+                // Service registered successfully — permission is granted.
                 timeout.cancel()
                 finish(.granted)
 
+            case .remove:
+                // Service was removed. On permission denial this fires immediately
+                // after the _NWAdvertiser PolicyDenied error in the system logs.
+                // We treat an immediate remove (before .add) as denied.
+                timeout.cancel()
+                finish(.denied)
+
+            @unknown default:
+                break
+            }
+        }
+
+        // stateUpdateHandler still needed to catch non-permission listener failures.
+        listener.stateUpdateHandler = { state in
+            print("🔍 LocalNetworkPermission NWListener state: \(state)")
+            switch state {
             case .failed(let error):
                 let code = (error as NSError).code
-                print("🔍 LocalNetworkPermission NWListener error code: \(code) — \(error.localizedDescription)")
-
-                if Self.isPolicyDenied(error) {
-                    // PolicyDenied or NoAuth — user has denied Local Network permission.
-                    timeout.cancel()
-                    finish(.denied)
-                } else {
-                    // Port conflict or other non-permission error — treat as unknown
-                    // and allow the server to start rather than blocking the user.
-                    print("⚠️ LocalNetworkPermission: NWListener failed (non-policy): \(error)")
-                    timeout.cancel()
-                    finish(.unknown)
-                }
+                print("🔍 LocalNetworkPermission NWListener error: \(code) — \(error.localizedDescription)")
+                // Only treat explicit policy errors as denied; other failures are unknown.
+                timeout.cancel()
+                finish(Self.isPolicyDenied(error) ? .denied : .unknown)
 
             case .cancelled:
-                break // Expected — we cancelled it ourselves in finish()
+                break
 
             default:
-                break // .setup, .waiting — keep waiting
+                break
             }
         }
 
@@ -124,12 +128,10 @@ import UIKit
 
     /// Opens the app's page in iOS Settings so the user can manually grant Local Network access.
     ///
-    /// - Note: This is the only recovery path available after the user denies the permission.
-    /// - Warning: On iOS 17, the user may need to restart the device after granting
-    ///   the permission for it to take effect. This is a known iOS 17 bug.
+    /// - Note: This is the only recovery path after denial — iOS cannot re-prompt.
+    /// - Warning: On iOS 17, a device restart may be needed after granting the permission.
     public func openAppSettings() {
         guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
-
         DispatchQueue.main.async {
             UIApplication.shared.open(url)
         }

package/package.json

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