@cappitolian/http-local-server-swifter 0.0.1

package/dist/plugin.cjs.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+/**
+ * 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 local.
+ *
+ * @example
+ * ```typescript
+ * import { HttpLocalServerSwifter } from '@cappitolian/http-local-server-swifter';
+ *
+ * // Iniciar servidor
+ * const { ip, port } = await HttpLocalServerSwifter.connect();
+ * console.log(`Servidor en http://${ip}:${port}`);
+ *
+ * // Escuchar peticiones
+ * await HttpLocalServerSwifter.addListener('onRequest', async (data) => {
+ *   console.log('Petición recibida:', data);
+ *
+ *   // Procesar y responder
+ *   await HttpLocalServerSwifter.sendResponse({
+ *     requestId: data.requestId,
+ *     body: JSON.stringify({ success: true })
+ *   });
+ * });
+ *
+ * // Detener servidor
+ * await HttpLocalServerSwifter.disconnect();
+ * ```
+ */
+const HttpLocalServerSwifter = core.registerPlugin('HttpLocalServerSwifter', {
+    web: () => Promise.resolve().then(function () { return web; }).then(m => new m.HttpLocalServerSwifterWeb()),
+});
+
+/**
+ * Implementación web (mock) del plugin HttpLocalServerSwifter.
+ *
+ * Proporciona funcionalidad simulada para desarrollo en navegador.
+ * El servidor real solo funciona en dispositivos iOS/Android nativos.
+ */
+class HttpLocalServerSwifterWeb extends core.WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.isRunning = false;
+    }
+    async connect() {
+        if (this.isRunning) {
+            console.warn('[HttpLocalServerSwifter Web] El servidor ya está ejecutándose (Mock).');
+            return { ip: '127.0.0.1', port: 8080 };
+        }
+        console.warn('[HttpLocalServerSwifter Web] El servidor HTTP nativo no está disponible en navegador.\n' +
+            'Retornando valores mock para desarrollo.\n' +
+            'Para funcionalidad real, ejecuta en un dispositivo iOS/Android.');
+        this.isRunning = true;
+        return {
+            ip: '127.0.0.1',
+            port: 8080
+        };
+    }
+    async disconnect() {
+        if (!this.isRunning) {
+            console.log('[HttpLocalServerSwifter Web] El servidor ya está detenido (Mock).');
+            return;
+        }
+        console.log('[HttpLocalServerSwifter Web] Servidor detenido (Mock).');
+        this.isRunning = false;
+    }
+    async sendResponse(options) {
+        if (!this.isRunning) {
+            throw new Error('Server is not running. Call connect() first.');
+        }
+        const { requestId, body } = options;
+        if (!requestId) {
+            throw new Error('Missing requestId');
+        }
+        if (!body) {
+            throw new Error('Missing body');
+        }
+        console.log(`[HttpLocalServerSwifter Web] Mock response sent for requestId: ${requestId}`, '\nBody preview:', body.substring(0, 100) + (body.length > 100 ? '...' : ''));
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HttpLocalServerSwifterWeb: HttpLocalServerSwifterWeb
+});
+
+exports.HttpLocalServerSwifter = HttpLocalServerSwifter;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.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 local.\n *\n * @example\n * ```typescript\n * import { HttpLocalServerSwifter } from '@cappitolian/http-local-server-swifter';\n *\n * // Iniciar servidor\n * const { ip, port } = await HttpLocalServerSwifter.connect();\n * console.log(`Servidor en http://${ip}:${port}`);\n *\n * // Escuchar peticiones\n * await HttpLocalServerSwifter.addListener('onRequest', async (data) => {\n *   console.log('Petición recibida:', data);\n *\n *   // Procesar y responder\n *   await HttpLocalServerSwifter.sendResponse({\n *     requestId: data.requestId,\n *     body: JSON.stringify({ success: true })\n *   });\n * });\n *\n * // Detener servidor\n * await HttpLocalServerSwifter.disconnect();\n * ```\n */\nconst HttpLocalServerSwifter = registerPlugin('HttpLocalServerSwifter', {\n    web: () => import('./web').then(m => new m.HttpLocalServerSwifterWeb()),\n});\nexport * from './definitions';\nexport { HttpLocalServerSwifter };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\n/**\n * Implementación web (mock) del plugin HttpLocalServerSwifter.\n *\n * Proporciona funcionalidad simulada para desarrollo en navegador.\n * El servidor real solo funciona en dispositivos iOS/Android nativos.\n */\nexport class HttpLocalServerSwifterWeb extends WebPlugin {\n    constructor() {\n        super(...arguments);\n        this.isRunning = false;\n    }\n    async connect() {\n        if (this.isRunning) {\n            console.warn('[HttpLocalServerSwifter Web] El servidor ya está ejecutándose (Mock).');\n            return { ip: '127.0.0.1', port: 8080 };\n        }\n        console.warn('[HttpLocalServerSwifter Web] El servidor HTTP nativo no está disponible en navegador.\\n' +\n            'Retornando valores mock para desarrollo.\\n' +\n            'Para funcionalidad real, ejecuta en un dispositivo iOS/Android.');\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('[HttpLocalServerSwifter Web] El servidor ya está detenido (Mock).');\n            return;\n        }\n        console.log('[HttpLocalServerSwifter Web] Servidor detenido (Mock).');\n        this.isRunning = false;\n    }\n    async sendResponse(options) {\n        if (!this.isRunning) {\n            throw new Error('Server is not running. Call connect() first.');\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(`[HttpLocalServerSwifter Web] Mock response sent for requestId: ${requestId}`, '\\nBody preview:', body.substring(0, 100) + (body.length > 100 ? '...' : ''));\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACK,MAAC,sBAAsB,GAAGA,mBAAc,CAAC,wBAAwB,EAAE;AACxE,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,yBAAyB,EAAE,CAAC;AAC3E,CAAC;;AC/BD;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,yBAAyB,SAASC,cAAS,CAAC;AACzD,IAAI,WAAW,GAAG;AAClB,QAAQ,KAAK,CAAC,GAAG,SAAS,CAAC;AAC3B,QAAQ,IAAI,CAAC,SAAS,GAAG,KAAK;AAC9B,IAAI;AACJ,IAAI,MAAM,OAAO,GAAG;AACpB,QAAQ,IAAI,IAAI,CAAC,SAAS,EAAE;AAC5B,YAAY,OAAO,CAAC,IAAI,CAAC,uEAAuE,CAAC;AACjG,YAAY,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE;AAClD,QAAQ;AACR,QAAQ,OAAO,CAAC,IAAI,CAAC,yFAAyF;AAC9G,YAAY,4CAA4C;AACxD,YAAY,iEAAiE,CAAC;AAC9E,QAAQ,IAAI,CAAC,SAAS,GAAG,IAAI;AAC7B,QAAQ,OAAO;AACf,YAAY,EAAE,EAAE,WAAW;AAC3B,YAAY,IAAI,EAAE;AAClB,SAAS;AACT,IAAI;AACJ,IAAI,MAAM,UAAU,GAAG;AACvB,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;AAC7B,YAAY,OAAO,CAAC,GAAG,CAAC,mEAAmE,CAAC;AAC5F,YAAY;AACZ,QAAQ;AACR,QAAQ,OAAO,CAAC,GAAG,CAAC,wDAAwD,CAAC;AAC7E,QAAQ,IAAI,CAAC,SAAS,GAAG,KAAK;AAC9B,IAAI;AACJ,IAAI,MAAM,YAAY,CAAC,OAAO,EAAE;AAChC,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;AAC7B,YAAY,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC;AAC3E,QAAQ;AACR,QAAQ,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,OAAO;AAC3C,QAAQ,IAAI,CAAC,SAAS,EAAE;AACxB,YAAY,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;AAChD,QAAQ;AACR,QAAQ,IAAI,CAAC,IAAI,EAAE;AACnB,YAAY,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC;AAC3C,QAAQ;AACR,QAAQ,OAAO,CAAC,GAAG,CAAC,CAAC,+DAA+D,EAAE,SAAS,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,EAAE,CAAC,CAAC;AAChL,IAAI;AACJ;;;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,95 @@
+var capacitorHttpLocalServerSwifter = (function (exports, core) {
+    'use strict';
+
+    /**
+     * 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 local.
+     *
+     * @example
+     * ```typescript
+     * import { HttpLocalServerSwifter } from '@cappitolian/http-local-server-swifter';
+     *
+     * // Iniciar servidor
+     * const { ip, port } = await HttpLocalServerSwifter.connect();
+     * console.log(`Servidor en http://${ip}:${port}`);
+     *
+     * // Escuchar peticiones
+     * await HttpLocalServerSwifter.addListener('onRequest', async (data) => {
+     *   console.log('Petición recibida:', data);
+     *
+     *   // Procesar y responder
+     *   await HttpLocalServerSwifter.sendResponse({
+     *     requestId: data.requestId,
+     *     body: JSON.stringify({ success: true })
+     *   });
+     * });
+     *
+     * // Detener servidor
+     * await HttpLocalServerSwifter.disconnect();
+     * ```
+     */
+    const HttpLocalServerSwifter = core.registerPlugin('HttpLocalServerSwifter', {
+        web: () => Promise.resolve().then(function () { return web; }).then(m => new m.HttpLocalServerSwifterWeb()),
+    });
+
+    /**
+     * Implementación web (mock) del plugin HttpLocalServerSwifter.
+     *
+     * Proporciona funcionalidad simulada para desarrollo en navegador.
+     * El servidor real solo funciona en dispositivos iOS/Android nativos.
+     */
+    class HttpLocalServerSwifterWeb extends core.WebPlugin {
+        constructor() {
+            super(...arguments);
+            this.isRunning = false;
+        }
+        async connect() {
+            if (this.isRunning) {
+                console.warn('[HttpLocalServerSwifter Web] El servidor ya está ejecutándose (Mock).');
+                return { ip: '127.0.0.1', port: 8080 };
+            }
+            console.warn('[HttpLocalServerSwifter Web] El servidor HTTP nativo no está disponible en navegador.\n' +
+                'Retornando valores mock para desarrollo.\n' +
+                'Para funcionalidad real, ejecuta en un dispositivo iOS/Android.');
+            this.isRunning = true;
+            return {
+                ip: '127.0.0.1',
+                port: 8080
+            };
+        }
+        async disconnect() {
+            if (!this.isRunning) {
+                console.log('[HttpLocalServerSwifter Web] El servidor ya está detenido (Mock).');
+                return;
+            }
+            console.log('[HttpLocalServerSwifter Web] Servidor detenido (Mock).');
+            this.isRunning = false;
+        }
+        async sendResponse(options) {
+            if (!this.isRunning) {
+                throw new Error('Server is not running. Call connect() first.');
+            }
+            const { requestId, body } = options;
+            if (!requestId) {
+                throw new Error('Missing requestId');
+            }
+            if (!body) {
+                throw new Error('Missing body');
+            }
+            console.log(`[HttpLocalServerSwifter Web] Mock response sent for requestId: ${requestId}`, '\nBody preview:', body.substring(0, 100) + (body.length > 100 ? '...' : ''));
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        HttpLocalServerSwifterWeb: HttpLocalServerSwifterWeb
+    });
+
+    exports.HttpLocalServerSwifter = HttpLocalServerSwifter;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"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 local.\n *\n * @example\n * ```typescript\n * import { HttpLocalServerSwifter } from '@cappitolian/http-local-server-swifter';\n *\n * // Iniciar servidor\n * const { ip, port } = await HttpLocalServerSwifter.connect();\n * console.log(`Servidor en http://${ip}:${port}`);\n *\n * // Escuchar peticiones\n * await HttpLocalServerSwifter.addListener('onRequest', async (data) => {\n *   console.log('Petición recibida:', data);\n *\n *   // Procesar y responder\n *   await HttpLocalServerSwifter.sendResponse({\n *     requestId: data.requestId,\n *     body: JSON.stringify({ success: true })\n *   });\n * });\n *\n * // Detener servidor\n * await HttpLocalServerSwifter.disconnect();\n * ```\n */\nconst HttpLocalServerSwifter = registerPlugin('HttpLocalServerSwifter', {\n    web: () => import('./web').then(m => new m.HttpLocalServerSwifterWeb()),\n});\nexport * from './definitions';\nexport { HttpLocalServerSwifter };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\n/**\n * Implementación web (mock) del plugin HttpLocalServerSwifter.\n *\n * Proporciona funcionalidad simulada para desarrollo en navegador.\n * El servidor real solo funciona en dispositivos iOS/Android nativos.\n */\nexport class HttpLocalServerSwifterWeb extends WebPlugin {\n    constructor() {\n        super(...arguments);\n        this.isRunning = false;\n    }\n    async connect() {\n        if (this.isRunning) {\n            console.warn('[HttpLocalServerSwifter Web] El servidor ya está ejecutándose (Mock).');\n            return { ip: '127.0.0.1', port: 8080 };\n        }\n        console.warn('[HttpLocalServerSwifter Web] El servidor HTTP nativo no está disponible en navegador.\\n' +\n            'Retornando valores mock para desarrollo.\\n' +\n            'Para funcionalidad real, ejecuta en un dispositivo iOS/Android.');\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('[HttpLocalServerSwifter Web] El servidor ya está detenido (Mock).');\n            return;\n        }\n        console.log('[HttpLocalServerSwifter Web] Servidor detenido (Mock).');\n        this.isRunning = false;\n    }\n    async sendResponse(options) {\n        if (!this.isRunning) {\n            throw new Error('Server is not running. Call connect() first.');\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(`[HttpLocalServerSwifter Web] Mock response sent for requestId: ${requestId}`, '\\nBody preview:', 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;IACA;IACA;IACA;AACK,UAAC,sBAAsB,GAAGA,mBAAc,CAAC,wBAAwB,EAAE;IACxE,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,yBAAyB,EAAE,CAAC;IAC3E,CAAC;;IC/BD;IACA;IACA;IACA;IACA;IACA;IACO,MAAM,yBAAyB,SAASC,cAAS,CAAC;IACzD,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,uEAAuE,CAAC;IACjG,YAAY,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE;IAClD,QAAQ;IACR,QAAQ,OAAO,CAAC,IAAI,CAAC,yFAAyF;IAC9G,YAAY,4CAA4C;IACxD,YAAY,iEAAiE,CAAC;IAC9E,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,mEAAmE,CAAC;IAC5F,YAAY;IACZ,QAAQ;IACR,QAAQ,OAAO,CAAC,GAAG,CAAC,wDAAwD,CAAC;IAC7E,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,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC;IAC3E,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,+DAA+D,EAAE,SAAS,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,EAAE,CAAC,CAAC;IAChL,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifter.swift

@@ -0,0 +1,406 @@
+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?
+    
+    private static var pendingResponses = [String: (String) -> Void]()
+    private static let queue = DispatchQueue(label: "com.cappitolian.HttpLocalServerSwifter.pendingResponses", qos: .userInitiated)
+    
+    private let defaultTimeout: TimeInterval = 5.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) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                call.reject("Server instance deallocated")
+                return
+            }
+            
+            // Stop existing server if running
+            self.disconnect()
+            
+            self.webServer = HttpServer()
+            self.setupHandlers()
+            
+            do {
+                try self.startServer()
+                let ip = Self.getWiFiAddress() ?? "127.0.0.1"
+                call.resolve([
+                    "ip": ip,
+                    "port": self.defaultPort
+                ])
+            } catch {
+                call.reject("Failed to start server: \(error.localizedDescription)")
+            }
+        }
+    }
+    
+    @objc public func disconnect(_ call: CAPPluginCall? = nil) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                call?.reject("Server instance deallocated")
+                return
+            }
+            
+            self.disconnect()
+            call?.resolve()
+        }
+    }
+    
+    // MARK: - Static Methods
+    static func handleJsResponse(requestId: String, body: String) {
+        queue.async {
+            if let callback = pendingResponses[requestId] {
+                callback(body)
+                pendingResponses.removeValue(forKey: requestId)
+            }
+        }
+    }
+    
+    // MARK: - Private Methods
+    private func disconnect() {
+        webServer?.stop()
+        webServer = nil
+        
+        // Clear pending responses
+        Self.queue.async {
+            Self.pendingResponses.removeAll()
+        }
+    }
+    
+    private func setupHandlers() {
+        guard let server = webServer else { return }
+        
+        // Catch-all handler for all HTTP methods
+        server["/(.*)"] = { [weak self] request in
+            guard let self = self else {
+                return self?.errorResponse() ?? .internalServerError
+            }
+            
+            // Handle OPTIONS (CORS preflight)
+            if request.method == "OPTIONS" {
+                return self.corsResponse()
+            }
+            
+            return self.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
+                semaphore.signal()
+            }
+        }
+        
+        // Notify delegate with request info
+        var requestData: [String: Any] = [
+            "requestId": requestId,
+            "method": method,
+            "path": path
+        ]
+        
+        // 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
+        }
+        
+        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 {
+            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: HttpRequest) -> String? {
+        guard let bodyBytes = request.body else {
+            return nil
+        }
+        
+        return String(bytes: bodyBytes, encoding: .utf8)
+    }
+    
+    private func extractHeaders(from request: HttpRequest) -> [String: String] {
+        return request.headers
+    }
+    
+    private func extractQuery(from request: HttpRequest) -> [String: String] {
+        return request.queryParams
+    }
+    
+    private func createJsonResponse(_ body: String, statusCode: Int = 200) -> HttpResponse {
+        var response: HttpResponse
+        
+        switch statusCode {
+        case 200:
+            response = .ok(.text(body))
+        case 204:
+            response = HttpResponse.raw(204, "No Content", [:], nil)
+        case 408:
+            response = HttpResponse.raw(408, "Request Timeout", [:], { writer in
+                try writer.write([UInt8](body.utf8))
+            })
+        case 500:
+            response = .internalServerError
+        default:
+            response = HttpResponse.raw(statusCode, "Custom Status", [:], { writer in
+                try writer.write([UInt8](body.utf8))
+            })
+        }
+        
+        // Add CORS headers
+        return response.withHeaders([
+            "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-Max-Age": "3600"
+        ])
+    }
+    
+    private func corsResponse() -> HttpResponse {
+        return createJsonResponse("{}", statusCode: 204)
+    }
+    
+    private func errorResponse() -> HttpResponse {
+        return createJsonResponse("{\"error\":\"Server error\"}", statusCode: 500)
+    }
+    
+    private func startServer() throws {
+        guard let server = webServer else {
+            throw NSError(
+                domain: "HttpLocalServerSwifter",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "WebServer not initialized"]
+            )
+        }
+        
+        // Swifter starts on all interfaces (0.0.0.0) by default
+        try server.start(defaultPort, forceIPv4: true)
+    }
+    
+    // MARK: - Network Utilities
+    static func getWiFiAddress() -> String? {
+        var address: String?
+        var ifaddr: UnsafeMutablePointer<ifaddrs>?
+        
+        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
+    }
+}
+
+// MARK: - HttpResponse Extension
+extension HttpResponse {
+    func withHeaders(_ headers: [String: String]) -> HttpResponse {
+        return HttpResponse.raw(self.statusCode(), self.reasonPhrase(), headers, { writer in
+            if let bodyData = try? self.content() {
+                try writer.write(bodyData)
+            }
+        })
+    }
+    
+    func statusCode() -> Int {
+        switch self {
+        case .ok: return 200
+        case .created: return 201
+        case .accepted: return 202
+        case .movedPermanently: return 301
+        case .notModified: return 304
+        case .badRequest: return 400
+        case .unauthorized: return 401
+        case .forbidden: return 403
+        case .notFound: return 404
+        case .internalServerError: return 500
+        case .raw(let code, _, _, _): return code
+        default: return 200
+        }
+    }
+    
+    func reasonPhrase() -> String {
+        switch self {
+        case .ok: return "OK"
+        case .created: return "Created"
+        case .accepted: return "Accepted"
+        case .movedPermanently: return "Moved Permanently"
+        case .notModified: return "Not Modified"
+        case .badRequest: return "Bad Request"
+        case .unauthorized: return "Unauthorized"
+        case .forbidden: return "Forbidden"
+        case .notFound: return "Not Found"
+        case .internalServerError: return "Internal Server Error"
+        case .raw(_, let phrase, _, _): return phrase
+        default: return "OK"
+        }
+    }
+    
+    func content() throws -> [UInt8] {
+        switch self {
+        case .ok(let body), .created(let body), .accepted(let body):
+            return try bodyToBytes(body)
+        case .badRequest(let body), .notFound(let body), .internalServerError:
+            if let body = body {
+                return try bodyToBytes(body)
+            }
+            return []
+        case .raw(_, _, _, let writer):
+            var data = [UInt8]()
+            let mockWriter = MockResponseWriter { bytes in
+                data.append(contentsOf: bytes)
+            }
+            try writer?(mockWriter)
+            return data
+        default:
+            return []
+        }
+    }
+    
+    private func bodyToBytes(_ body: HttpResponseBody) throws -> [UInt8] {
+        switch body {
+        case .text(let string):
+            return [UInt8](string.utf8)
+        case .html(let string):
+            return [UInt8](string.utf8)
+        case .json(let object):
+            let data = try JSONSerialization.data(withJSONObject: object)
+            return [UInt8](data)
+        case .data(let data, _):
+            return [UInt8](data)
+        case .custom(let writer):
+            var bytes = [UInt8]()
+            let mockWriter = MockResponseWriter { data in
+                bytes.append(contentsOf: data)
+            }
+            try writer(mockWriter)
+            return bytes
+        }
+    }
+}
+
+// MARK: - Mock Response Writer
+private class MockResponseWriter: HttpResponseBodyWriter {
+    let writeHandler: ([UInt8]) -> Void
+    
+    init(writeHandler: @escaping ([UInt8]) -> Void) {
+        self.writeHandler = writeHandler
+    }
+    
+    func write(_ data: [UInt8]) throws {
+        writeHandler(data)
+    }
+    
+    func write(_ data: ArraySlice<UInt8>) throws {
+        writeHandler(Array(data))
+    }
+    
+    func write(_ data: NSData) throws {
+        var bytes = [UInt8](repeating: 0, count: data.length)
+        data.getBytes(&bytes, length: data.length)
+        writeHandler(bytes)
+    }
+    
+    func write(_ data: Data) throws {
+        writeHandler([UInt8](data))
+    }
+}

package/ios/Sources/HttpLocalServerSwifterPlugin/HttpLocalServerSwifterPlugin.swift

@@ -0,0 +1,68 @@
+import Foundation
+import Capacitor
+
+/**
+* Capacitor plugin for running a local HTTP server on the device.
+* Allows receiving HTTP requests and sending responses from JavaScript.
+*/
+@objc(HttpLocalServerSwifterPlugin)
+public class HttpLocalServerSwifterPlugin: CAPPlugin, CAPBridgedPlugin, HttpLocalServerSwifterDelegate {
+    
+    public let identifier = "HttpLocalServerSwifterPlugin"
+    public let jsName = "HttpLocalServerSwifter"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "connect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "disconnect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sendResponse", returnType: CAPPluginReturnPromise)
+    ]
+    
+    private var localServer: HttpLocalServerSwifter?
+    
+    /**
+    * Starts the local HTTP server.
+    * @return ip: The server's IP address
+    * @return port: The port the server is listening on
+    */
+    @objc func connect(_ call: CAPPluginCall) {
+        if localServer == nil {
+            localServer = HttpLocalServerSwifter(delegate: self)
+        }
+        localServer?.connect(call)
+    }
+    
+    /**
+    * Stops the local HTTP server.
+    * Cleans up all resources and pending requests.
+    */
+    @objc func disconnect(_ call: CAPPluginCall) {
+        if localServer != nil {
+            localServer?.disconnect(call)
+        } else {
+            call.resolve()
+        }
+    }
+    
+    /**
+    * Sends a response back to the client that made the request.
+    * @param requestId Unique request ID (received in 'onRequest')
+    * @param body Response body (typically stringified JSON)
+    */
+    @objc func sendResponse(_ call: CAPPluginCall) {
+        guard let requestId = call.getString("requestId") else {
+            call.reject("Missing requestId")
+            return
+        }
+        
+        guard let body = call.getString("body") else {
+            call.reject("Missing body")
+            return
+        }
+        
+        HttpLocalServerSwifter.handleJsResponse(requestId: requestId, body: body)
+        call.resolve()
+    }
+    
+    public func httpLocalServerSwifterDidReceiveRequest(_ data: [String: Any]) {
+        notifyListeners("onRequest", data: data)
+    }
+}