@cappitolian/http-local-server 0.0.7 → 0.0.9

package/dist/plugin.js

@@ -2,25 +2,78 @@ var capacitorHttpLocalServer = (function (exports, core) {
     'use strict';
 
     /**
-     * Registramos el plugin.
-     * El nombre 'HttpLocalServer' debe coincidir con el @CapacitorPlugin en Java
-     * y el @objc(HttpLocalServerPlugin) en Swift.
+     * Plugin de servidor HTTP local para Android e iOS.
+     *
+     * Permite crear un servidor HTTP en el dispositivo que puede recibir
+     * peticiones desde otros dispositivos en la misma red.
+     *
+     * @example
+     * ```typescript
+     * import { HttpLocalServer } from '@cappitolian/http-local-server';
+     *
+     * // Iniciar servidor
+     * const { ip, port } = await HttpLocalServer.connect();
+     * console.log(`Servidor en http://${ip}:${port}`);
+     *
+     * // Escuchar peticiones
+     * await HttpLocalServer.addListener('onRequest', async (data) => {
+     *   console.log('Petición recibida:', data);
+     *
+     *   // Procesar y responder
+     *   await HttpLocalServer.sendResponse({
+     *     requestId: data.requestId,
+     *     body: JSON.stringify({ success: true })
+     *   });
+     * });
+     * ```
      */
     const HttpLocalServer = core.registerPlugin('HttpLocalServer', {
         web: () => Promise.resolve().then(function () { return web; }).then(m => new m.HttpLocalServerWeb()),
     });
 
+    /**
+     * Implementación web del plugin HttpLocalServer.
+     * Proporciona funcionalidad mock para desarrollo en navegador.
+     */
     class HttpLocalServerWeb extends core.WebPlugin {
+        constructor() {
+            super(...arguments);
+            this.isRunning = false;
+        }
         async connect() {
-            console.warn('HttpLocalServer: El servidor nativo no se puede iniciar en el navegador.');
-            // Devolvemos un valor por defecto para no romper la ejecución en web
-            return { ip: '127.0.0.1', port: 8080 };
+            if (this.isRunning) {
+                console.warn('HttpLocalServer: El servidor ya está ejecutándose (Mock).');
+                return { ip: '127.0.0.1', port: 8080 };
+            }
+            console.warn('HttpLocalServer: El servidor nativo no está disponible en navegador. ' +
+                'Retornando valores mock para desarrollo.');
+            this.isRunning = true;
+            return {
+                ip: '127.0.0.1',
+                port: 8080
+            };
         }
         async disconnect() {
+            if (!this.isRunning) {
+                console.log('HttpLocalServer: El servidor ya está detenido (Mock).');
+                return;
+            }
             console.log('HttpLocalServer: Servidor detenido (Mock).');
+            this.isRunning = false;
         }
         async sendResponse(options) {
-            console.log('HttpLocalServer: Respuesta mock enviada al requestId:', options.requestId);
+            if (!this.isRunning) {
+                console.warn('HttpLocalServer: El servidor no está ejecutándose (Mock).');
+                return;
+            }
+            const { requestId, body } = options;
+            if (!requestId) {
+                throw new Error('Missing requestId');
+            }
+            if (!body) {
+                throw new Error('Missing body');
+            }
+            console.log(`HttpLocalServer: Respuesta mock enviada para requestId: ${requestId}`, '\nBody:', body.substring(0, 100) + (body.length > 100 ? '...' : ''));
         }
     }
 

package/dist/plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\n/**\n * Registramos el plugin.\n * El nombre 'HttpLocalServer' debe coincidir con el @CapacitorPlugin en Java\n * y el @objc(HttpLocalServerPlugin) en Swift.\n */\nconst HttpLocalServer = registerPlugin('HttpLocalServer', {\n    web: () => import('./web').then(m => new m.HttpLocalServerWeb()),\n});\n// Exportamos las interfaces para que el usuario pueda tipar sus variables\nexport * from './definitions';\n// Exportamos el objeto del plugin\nexport { HttpLocalServer };\n// Exportación por defecto opcional para mayor compatibilidad\nexport default HttpLocalServer;\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class HttpLocalServerWeb extends WebPlugin {\n    async connect() {\n        console.warn('HttpLocalServer: El servidor nativo no se puede iniciar en el navegador.');\n        // Devolvemos un valor por defecto para no romper la ejecución en web\n        return { ip: '127.0.0.1', port: 8080 };\n    }\n    async disconnect() {\n        console.log('HttpLocalServer: Servidor detenido (Mock).');\n    }\n    async sendResponse(options) {\n        console.log('HttpLocalServer: Respuesta mock enviada al requestId:', options.requestId);\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;IACA;IACA;IACA;IACA;IACA;AACK,UAAC,eAAe,GAAGA,mBAAc,CAAC,iBAAiB,EAAE;IAC1D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,kBAAkB,EAAE,CAAC;IACpE,CAAC;;ICPM,MAAM,kBAAkB,SAASC,cAAS,CAAC;IAClD,IAAI,MAAM,OAAO,GAAG;IACpB,QAAQ,OAAO,CAAC,IAAI,CAAC,0EAA0E,CAAC;IAChG;IACA,QAAQ,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE;IAC9C,IAAI;IACJ,IAAI,MAAM,UAAU,GAAG;IACvB,QAAQ,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC;IACjE,IAAI;IACJ,IAAI,MAAM,YAAY,CAAC,OAAO,EAAE;IAChC,QAAQ,OAAO,CAAC,GAAG,CAAC,uDAAuD,EAAE,OAAO,CAAC,SAAS,CAAC;IAC/F,IAAI;IACJ;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\n/**\n * Plugin de servidor HTTP local para Android e iOS.\n *\n * Permite crear un servidor HTTP en el dispositivo que puede recibir\n * peticiones desde otros dispositivos en la misma red.\n *\n * @example\n * ```typescript\n * import { HttpLocalServer } from '@cappitolian/http-local-server';\n *\n * // Iniciar servidor\n * const { ip, port } = await HttpLocalServer.connect();\n * console.log(`Servidor en http://${ip}:${port}`);\n *\n * // Escuchar peticiones\n * await HttpLocalServer.addListener('onRequest', async (data) => {\n *   console.log('Petición recibida:', data);\n *\n *   // Procesar y responder\n *   await HttpLocalServer.sendResponse({\n *     requestId: data.requestId,\n *     body: JSON.stringify({ success: true })\n *   });\n * });\n * ```\n */\nconst HttpLocalServer = registerPlugin('HttpLocalServer', {\n    web: () => import('./web').then(m => new m.HttpLocalServerWeb()),\n});\nexport * from './definitions';\nexport { HttpLocalServer };\nexport default HttpLocalServer;\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\n/**\n * Implementación web del plugin HttpLocalServer.\n * Proporciona funcionalidad mock para desarrollo en navegador.\n */\nexport class HttpLocalServerWeb extends WebPlugin {\n    constructor() {\n        super(...arguments);\n        this.isRunning = false;\n    }\n    async connect() {\n        if (this.isRunning) {\n            console.warn('HttpLocalServer: El servidor ya está ejecutándose (Mock).');\n            return { ip: '127.0.0.1', port: 8080 };\n        }\n        console.warn('HttpLocalServer: El servidor nativo no está disponible en navegador. ' +\n            'Retornando valores mock para desarrollo.');\n        this.isRunning = true;\n        return {\n            ip: '127.0.0.1',\n            port: 8080\n        };\n    }\n    async disconnect() {\n        if (!this.isRunning) {\n            console.log('HttpLocalServer: El servidor ya está detenido (Mock).');\n            return;\n        }\n        console.log('HttpLocalServer: Servidor detenido (Mock).');\n        this.isRunning = false;\n    }\n    async sendResponse(options) {\n        if (!this.isRunning) {\n            console.warn('HttpLocalServer: El servidor no está ejecutándose (Mock).');\n            return;\n        }\n        const { requestId, body } = options;\n        if (!requestId) {\n            throw new Error('Missing requestId');\n        }\n        if (!body) {\n            throw new Error('Missing body');\n        }\n        console.log(`HttpLocalServer: Respuesta mock enviada para requestId: ${requestId}`, '\\nBody:', body.substring(0, 100) + (body.length > 100 ? '...' : ''));\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;AACK,UAAC,eAAe,GAAGA,mBAAc,CAAC,iBAAiB,EAAE;IAC1D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,kBAAkB,EAAE,CAAC;IACpE,CAAC;;IC5BD;IACA;IACA;IACA;IACO,MAAM,kBAAkB,SAASC,cAAS,CAAC;IAClD,IAAI,WAAW,GAAG;IAClB,QAAQ,KAAK,CAAC,GAAG,SAAS,CAAC;IAC3B,QAAQ,IAAI,CAAC,SAAS,GAAG,KAAK;IAC9B,IAAI;IACJ,IAAI,MAAM,OAAO,GAAG;IACpB,QAAQ,IAAI,IAAI,CAAC,SAAS,EAAE;IAC5B,YAAY,OAAO,CAAC,IAAI,CAAC,2DAA2D,CAAC;IACrF,YAAY,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE;IAClD,QAAQ;IACR,QAAQ,OAAO,CAAC,IAAI,CAAC,uEAAuE;IAC5F,YAAY,0CAA0C,CAAC;IACvD,QAAQ,IAAI,CAAC,SAAS,GAAG,IAAI;IAC7B,QAAQ,OAAO;IACf,YAAY,EAAE,EAAE,WAAW;IAC3B,YAAY,IAAI,EAAE;IAClB,SAAS;IACT,IAAI;IACJ,IAAI,MAAM,UAAU,GAAG;IACvB,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;IAC7B,YAAY,OAAO,CAAC,GAAG,CAAC,uDAAuD,CAAC;IAChF,YAAY;IACZ,QAAQ;IACR,QAAQ,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC;IACjE,QAAQ,IAAI,CAAC,SAAS,GAAG,KAAK;IAC9B,IAAI;IACJ,IAAI,MAAM,YAAY,CAAC,OAAO,EAAE;IAChC,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;IAC7B,YAAY,OAAO,CAAC,IAAI,CAAC,2DAA2D,CAAC;IACrF,YAAY;IACZ,QAAQ;IACR,QAAQ,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,OAAO;IAC3C,QAAQ,IAAI,CAAC,SAAS,EAAE;IACxB,YAAY,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IAChD,QAAQ;IACR,QAAQ,IAAI,CAAC,IAAI,EAAE;IACnB,YAAY,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC;IAC3C,QAAQ;IACR,QAAQ,OAAO,CAAC,GAAG,CAAC,CAAC,wDAAwD,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,EAAE,CAAC,CAAC;IACjK,IAAI;IACJ;;;;;;;;;;;;;;;;;;"}

package/ios/Sources/HttpLocalServerPlugin/HttpLocalServer.swift

@@ -20,104 +20,76 @@ import Foundation
 import GCDWebServer
 import Capacitor
 
+// MARK: - Protocol
 public protocol HttpLocalServerDelegate: AnyObject {
     func httpLocalServerDidReceiveRequest(_ data: [String: Any])
 }
 
+// MARK: - HttpLocalServer
 @objc public class HttpLocalServer: NSObject {
-    var webServer: GCDWebServer?
-    weak var delegate: HttpLocalServerDelegate?
-    static var pendingResponses = [String: (String) -> Void]()
-    static let queue = DispatchQueue(label: "HttpLocalServer.pendingResponses")
-
+    
+    // MARK: - Properties
+    private var webServer: GCDWebServer?
+    private weak var delegate: HttpLocalServerDelegate?
+    
+    private static var pendingResponses = [String: (String) -> Void]()
+    private static let queue = DispatchQueue(label: "com.cappitolian.HttpLocalServer.pendingResponses", qos: .userInitiated)
+    
+    private let defaultTimeout: TimeInterval = 5.0
+    private let defaultPort: UInt = 8080
+    
+    // MARK: - Initialization
     public init(delegate: HttpLocalServerDelegate) {
         self.delegate = delegate
+        super.init()
     }
-
+    
+    deinit {
+        disconnect()
+    }
+    
+    // MARK: - Public Methods
     @objc public func connect(_ call: CAPPluginCall) {
         DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
+            guard let self = self else {
+                call.reject("Server instance deallocated")
+                return
+            }
+            
+            // Stop existing server if running
+            if self.webServer?.isRunning == true {
+                self.webServer?.stop()
+            }
+            
             self.webServer = GCDWebServer()
-
-            self.webServer?.addHandler(
-                match: { method, url, headers, path, query in
-                        GCDWebServerRequest(method: method, url: url, headers: headers, path: path, query: query)
-                },
-                processBlock: { request in
-                    let method = request.method
-                    let path = request.url.path
-                    var body: String? = nil
-
-                    if let dataRequest = request as? GCDWebServerDataRequest, let text = String(data: dataRequest.data, encoding: .utf8) {
-                        body = text
-                    }
-
-                    let requestId = UUID().uuidString
-                    var responseString: String? = nil
-
-                    // Set up a semaphore so we can block until JS responds or timeout (3s)
-                    let semaphore = DispatchSemaphore(value: 0)
-                    Self.queue.async {
-                        Self.pendingResponses[requestId] = { responseBody in
-                            responseString = responseBody
-                            semaphore.signal()
-                        }
-                    }
-
-                    // Notify delegate (plugin) with the request info
-                    let req: [String: Any?] = [
-                        "requestId": requestId,
-                        "method": method,
-                        "path": path,
-                        "body": body
-                    ]
-                    self.delegate?.httpLocalServerDidReceiveRequest(req.compactMapValues { $0 })
-
-                    // Wait for JS response or timeout
-                    _ = semaphore.wait(timeout: .now() + 3.0)
-                    Self.queue.async {
-                        Self.pendingResponses.removeValue(forKey: requestId)
-                    }
-                    let reply = responseString ?? "{\"error\":\"Timeout waiting for JS response\"}"
-
-                    let response = GCDWebServerDataResponse(text: reply)
-                    response?.setValue("*", forAdditionalHeader: "Access-Control-Allow-Origin")
-                    response?.setValue("GET,POST,OPTIONS", forAdditionalHeader: "Access-Control-Allow-Methods")
-                    response?.setValue("origin, content-type, accept, authorization", forAdditionalHeader: "Access-Control-Allow-Headers")
-                    response?.setValue("3600", forAdditionalHeader: "Access-Control-Max-Age")
-                    response?.contentType = "application/json"
-                    return response!
-                }
-            )
-
-            let port: UInt = 8080
+            self.setupHandlers()
+            
             do {
-                try self.webServer?.start(options: [
-                    GCDWebServerOption_Port: port,
-                    GCDWebServerOption_BonjourName: "",
-                    GCDWebServerOption_BindToLocalhost: false
-                ])
+                try self.startServer()
                 let ip = Self.getWiFiAddress() ?? "127.0.0.1"
                 call.resolve([
                     "ip": ip,
-                    "port": port
+                    "port": self.defaultPort
                 ])
             } catch {
                 call.reject("Failed to start server: \(error.localizedDescription)")
             }
         }
     }
-
-    @objc public func disconnect(_ call: CAPPluginCall) {
+    
+    @objc public func disconnect(_ call: CAPPluginCall? = nil) {
         DispatchQueue.main.async { [weak self] in
-            self?.webServer?.stop()
-            self?.webServer = nil
-            call.resolve()
+            guard let self = self else {
+                call?.reject("Server instance deallocated")
+                return
+            }
+            
+            self.disconnect()
+            call?.resolve()
         }
     }
-
-    // Called by plugin when JS responds
+    
+    // MARK: - Static Methods
     static func handleJsResponse(requestId: String, body: String) {
         queue.async {
             if let callback = pendingResponses[requestId] {
@@ -126,32 +98,238 @@ public protocol HttpLocalServerDelegate: AnyObject {
             }
         }
     }
-
-    // Helper: get WiFi IP address (IPv4)
+    
+    // MARK: - Private Methods
+    private func disconnect() {
+        webServer?.stop()
+        webServer = nil
+        
+        // Clear pending responses
+        Self.queue.async {
+            Self.pendingResponses.removeAll()
+        }
+    }
+    
+    private func setupHandlers() {
+        guard let webServer = webServer else { return }
+        
+        // GET requests
+        webServer.addDefaultHandler(
+            forMethod: "GET",
+            request: GCDWebServerRequest.self,
+            processBlock: { [weak self] request in
+                return self?.processRequest(request) ?? self?.errorResponse() ?? GCDWebServerResponse()
+            }
+        )
+        
+        // POST requests (with body)
+        webServer.addDefaultHandler(
+            forMethod: "POST",
+            request: GCDWebServerDataRequest.self,
+            processBlock: { [weak self] request in
+                return self?.processRequest(request) ?? self?.errorResponse() ?? GCDWebServerResponse()
+            }
+        )
+        
+        // PUT requests (with body)
+        webServer.addDefaultHandler(
+            forMethod: "PUT",
+            request: GCDWebServerDataRequest.self,
+            processBlock: { [weak self] request in
+                return self?.processRequest(request) ?? self?.errorResponse() ?? GCDWebServerResponse()
+            }
+        )
+        
+        // PATCH requests (with body)
+        webServer.addDefaultHandler(
+            forMethod: "PATCH",
+            request: GCDWebServerDataRequest.self,
+            processBlock: { [weak self] request in
+                return self?.processRequest(request) ?? self?.errorResponse() ?? GCDWebServerResponse()
+            }
+        )
+        
+        // DELETE requests
+        webServer.addDefaultHandler(
+            forMethod: "DELETE",
+            request: GCDWebServerRequest.self,
+            processBlock: { [weak self] request in
+                return self?.processRequest(request) ?? self?.errorResponse() ?? GCDWebServerResponse()
+            }
+        )
+        
+        // OPTIONS requests (CORS preflight)
+        webServer.addDefaultHandler(
+            forMethod: "OPTIONS",
+            request: GCDWebServerRequest.self,
+            processBlock: { [weak self] request in
+                return self?.corsResponse() ?? GCDWebServerResponse()
+            }
+        )
+    }
+    
+    private func processRequest(_ request: GCDWebServerRequest) -> GCDWebServerResponse {
+        let method = request.method
+        let path = request.url.path
+        let body = extractBody(from: request)
+        let headers = request.headers
+        let query = request.query
+        
+        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
+                semaphore.signal()
+            }
+        }
+        
+        // Notify delegate with request info
+        var requestData: [String: Any] = [
+            "requestId": requestId,
+            "method": method,
+            "path": path
+        ]
+        
+        // Solo agregar si existen (consistente con TypeScript y Android)
+        if let body = body, !body.isEmpty {
+            requestData["body"] = body
+        }
+        
+        if let headers = headers as? [String: String], !headers.isEmpty {
+            requestData["headers"] = headers
+        }
+        
+        if let query = query, !query.isEmpty {
+            requestData["query"] = query
+        }
+        
+        delegate?.httpLocalServerDidReceiveRequest(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 {
+            let timeoutResponse = "{\"error\":\"Request timeout\",\"requestId\":\"\(requestId)\"}"
+            return createJsonResponse(timeoutResponse, statusCode: 408)
+        }
+        
+        let reply = responseString ?? "{\"error\":\"No response from handler\"}"
+        return createJsonResponse(reply)
+    }
+    
+    private func extractBody(from request: GCDWebServerRequest) -> String? {
+        guard let dataRequest = request as? GCDWebServerDataRequest else {
+            return nil
+        }
+        
+        return String(data: dataRequest.data, encoding: .utf8)
+    }
+    
+    private func createJsonResponse(_ body: String, statusCode: Int = 200) -> GCDWebServerDataResponse {
+        let response = GCDWebServerDataResponse(text: body)
+        response?.statusCode = statusCode
+        response?.contentType = "application/json"
+        
+        // CORS headers
+        response?.setValue("*", forAdditionalHeader: "Access-Control-Allow-Origin")
+        response?.setValue("GET, POST, PUT, PATCH, DELETE, OPTIONS", forAdditionalHeader: "Access-Control-Allow-Methods")
+        response?.setValue("Origin, Content-Type, Accept, Authorization", forAdditionalHeader: "Access-Control-Allow-Headers")
+        response?.setValue("true", forAdditionalHeader: "Access-Control-Allow-Credentials")
+        response?.setValue("3600", forAdditionalHeader: "Access-Control-Max-Age")
+        
+        return response ?? GCDWebServerDataResponse()
+    }
+    
+    private func corsResponse() -> GCDWebServerDataResponse {
+        return createJsonResponse("{}", statusCode: 204)
+    }
+    
+    private func errorResponse() -> GCDWebServerDataResponse {
+        return createJsonResponse("{\"error\":\"Server error\"}", statusCode: 500)
+    }
+    
+    private func startServer() throws {
+        guard let webServer = webServer else {
+            throw NSError(
+                domain: "HttpLocalServer",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "WebServer not initialized"]
+            )
+        }
+        
+        let options: [String: Any] = [
+            GCDWebServerOption_Port: defaultPort,
+            GCDWebServerOption_BonjourName: "",
+            GCDWebServerOption_BindToLocalhost: false,
+            GCDWebServerOption_AutomaticallySuspendInBackground: false
+        ]
+        
+        try webServer.start(options: options)
+    }
+    
+    // MARK: - Network Utilities
     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
-                let addrFamily = interface.ifa_addr.pointee.sa_family
-                if addrFamily == UInt8(AF_INET) {
-                    let name = String(cString: interface.ifa_name)
-                    if name == "en0" { // WiFi interface
-                        var addr = interface.ifa_addr.pointee
-                        var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
-                        getnameinfo(&addr, socklen_t(interface.ifa_addr.pointee.sa_len),
-                                    &hostname, socklen_t(hostname.count),
-                                    nil, socklen_t(0), NI_NUMERICHOST)
-                        address = String(cString: hostname)
-                        break
-                    }
-                }
-                ptr = interface.ifa_next
-            }
+        
+        guard getifaddrs(&ifaddr) == 0 else {
+            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)
+            
+            // Prefer en0 (WiFi) over pdp_ip0 (cellular)
+            if name == "en0" {
+                break
+            }
+        }
+        
         return address
     }
-}
+}

package/package.json

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