@cappitolian/http-local-server 0.0.1

package/CappitolianHttpLocalServer.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CappitolianHttpLocalServer'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.dependency   'GCDWebServer', '~> 3.5'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CappitolianHttpLocalServer",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "CappitolianHttpLocalServer",
+            targets: ["HttpLocalServerPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "HttpLocalServerPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/HttpLocalServerPlugin"),
+        .testTarget(
+            name: "HttpLocalServerPluginTests",
+            dependencies: ["HttpLocalServerPlugin"],
+            path: "ios/Tests/HttpLocalServerPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,103 @@
+# @cappitolian/http-local-server
+
+Runs a local HTTP server on your device, accessible over LAN. Supports connect, disconnect, GET, and POST methods with IP and port discovery.
+
+## Install
+
+```bash
+npm install @cappitolian/http-local-server
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`connect()`](#connect)
+* [`disconnect()`](#disconnect)
+* [`sendResponse(...)`](#sendresponse)
+* [`addListener('onRequest', ...)`](#addlisteneronrequest-)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### connect()
+
+```typescript
+connect() => Promise<HttpConnectResult>
+```
+
+**Returns:** <code>Promise&lt;<a href="#httpconnectresult">HttpConnectResult</a>&gt;</code>
+
+--------------------
+
+
+### disconnect()
+
+```typescript
+disconnect() => Promise<void>
+```
+
+--------------------
+
+
+### sendResponse(...)
+
+```typescript
+sendResponse(options: { requestId: string; body: string; }) => Promise<void>
+```
+
+| Param         | Type                                              |
+| ------------- | ------------------------------------------------- |
+| **`options`** | <code>{ requestId: string; body: string; }</code> |
+
+--------------------
+
+
+### addListener('onRequest', ...)
+
+```typescript
+addListener(eventName: 'onRequest', listenerFunc: (info: HttpRequestInfo) => void) => Promise<PluginListenerHandle> & PluginListenerHandle
+```
+
+| Param              | Type                                                                           |
+| ------------------ | ------------------------------------------------------------------------------ |
+| **`eventName`**    | <code>'onRequest'</code>                                                       |
+| **`listenerFunc`** | <code>(info: <a href="#httprequestinfo">HttpRequestInfo</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt; & <a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### HttpConnectResult
+
+| Prop       | Type                |
+| ---------- | ------------------- |
+| **`ip`**   | <code>string</code> |
+| **`port`** | <code>number</code> |
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
+#### HttpRequestInfo
+
+| Prop            | Type                |
+| --------------- | ------------------- |
+| **`requestId`** | <code>string</code> |
+| **`method`**    | <code>string</code> |
+| **`path`**      | <code>string</code> |
+| **`body`**      | <code>string</code> |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,59 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.cappitolian.plugins.httplocalserver"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'org.nanohttpd:nanohttpd:2.3.1'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/cappitolian/plugins/httplocalserver/HttpLocalServer.java

@@ -0,0 +1,160 @@
+// package com.cappitolian.plugins.httplocalservice;
+
+// import android.util.Log;
+
+// public class LocalIp {
+
+//     public String echo(String value) {
+//         Log.i("Echo", value);
+//         return value;
+//     }
+// }
+
+// package com.cappitolian.plugins.httplocalservice;
+
+// import android.util.Log;
+
+// public class LocalIp {
+
+//     public String echo(String value) {
+//         Log.i("Echo", value);
+//         return value;
+//     }
+// }
+
+package com.cappitolian.plugins.httplocalservice;
+
+import android.content.Context;
+import android.net.wifi.WifiManager;
+import android.text.format.Formatter;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import fi.iki.elonen.NanoHTTPD;
+import java.io.IOException;
+import java.util.UUID;
+import java.util.concurrent.*;
+import java.util.HashMap;
+
+public class HttpLocalServer {
+    private LocalNanoServer server;
+    private String localIp;
+    private int port = 8080;
+    private Plugin plugin;
+
+    // Map to wait for responses from JS (key: requestId)
+    private static final ConcurrentHashMap<String, CompletableFuture<String>> pendingResponses = new ConcurrentHashMap<>();
+
+    public HttpLocalServer(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void connect(PluginCall call) {
+        if (server == null) {
+            localIp = getLocalIpAddress(plugin.getContext());
+            server = new LocalNanoServer(localIp, port, plugin);
+            try {
+                server.start();
+                JSObject ret = new JSObject();
+                ret.put("ip", localIp);
+                ret.put("port", port);
+                call.resolve(ret);
+            } catch (Exception e) {
+                call.reject("Failed to start server: " + e.getMessage());
+            }
+        } else {
+            call.reject("Server is already running");
+        }
+    }
+
+    public void disconnect(PluginCall call) {
+        if (server != null) {
+            server.stop();
+            server = null;
+        }
+        call.resolve();
+    }
+
+    // Called by plugin when JS responds
+    public static void handleJsResponse(String requestId, String body) {
+        CompletableFuture<String> future = pendingResponses.remove(requestId);
+        if (future != null) {
+            future.complete(body);
+        }
+    }
+
+    // Helper to get local WiFi IP Address
+    private String getLocalIpAddress(Context context) {
+        WifiManager wm = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+        if (wm != null && wm.getConnectionInfo() != null) {
+            return Formatter.formatIpAddress(wm.getConnectionInfo().getIpAddress());
+        }
+        return "127.0.0.1"; // fallback
+    }
+
+    private static class LocalNanoServer extends NanoHTTPD {
+        private Plugin plugin;
+
+        public LocalNanoServer(String hostname, int port, Plugin plugin) {
+            super(hostname, port);
+            this.plugin = plugin;
+        }
+
+        @Override
+        public Response serve(IHTTPSession session) {
+            String path = session.getUri();
+            String method = session.getMethod().name();
+
+            // Read body if needed
+            String body = "";
+            if (session.getMethod() == Method.POST || session.getMethod() == Method.PUT) {
+                try {
+                    session.parseBody(new HashMap<>());
+                    body = session.getQueryParameterString();
+                } catch (Exception e) { }
+            }
+
+            // Generate a unique requestId
+            String requestId = UUID.randomUUID().toString();
+
+            // Prepare data for JS
+            JSObject req = new JSObject();
+            req.put("requestId", requestId);
+            req.put("method", method);
+            req.put("path", path);
+            req.put("body", body);
+
+            // Future to wait for JS response
+            CompletableFuture<String> future = new CompletableFuture<>();
+            pendingResponses.put(requestId, future);
+
+            // Send event to JS
+            if (plugin instanceof com.cappitolian.plugins.httplocalservice.HttpLocalServerPlugin) {
+                ((com.cappitolian.plugins.httplocalservice.HttpLocalServerPlugin) plugin).fireOnRequest(req);
+            }
+
+            String jsResponse = null;
+            try {
+                // Wait up to 3 seconds for JS response
+                jsResponse = future.get(3, TimeUnit.SECONDS);
+            } catch (TimeoutException e) {
+                jsResponse = "{\"error\": \"Timeout waiting for JS response\"}";
+            } catch (Exception e) {
+                jsResponse = "{\"error\": \"Error waiting for JS response\"}";
+            } finally {
+                pendingResponses.remove(requestId);
+            }
+
+            Response response = newFixedLengthResponse(Response.Status.OK, "application/json", jsResponse);
+            addCorsHeaders(response);
+            return response;
+        }
+
+        private void addCorsHeaders(Response response) {
+            response.addHeader("Access-Control-Allow-Origin", "*");
+            response.addHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+            response.addHeader("Access-Control-Allow-Headers", "origin, content-type, accept, authorization");
+            response.addHeader("Access-Control-Max-Age", "3600");
+        }
+    }
+}

package/android/src/main/java/com/cappitolian/plugins/httplocalserver/HttpLocalServerPlugin.java

@@ -0,0 +1,92 @@
+// package com.cappitolian.plugins.httplocalserver;
+
+// import com.getcapacitor.JSObject;
+// import com.getcapacitor.Plugin;
+// import com.getcapacitor.PluginCall;
+// import com.getcapacitor.PluginMethod;
+// import com.getcapacitor.annotation.CapacitorPlugin;
+
+// @CapacitorPlugin(name = "HttpLocalServer")
+// public class HttpLocalServerPlugin extends Plugin {
+
+//     private HttpLocalServer implementation = new HttpLocalServer();
+
+//     @PluginMethod
+//     public void echo(PluginCall call) {
+//         String value = call.getString("value");
+
+//         JSObject ret = new JSObject();
+//         ret.put("value", implementation.echo(value));
+//         call.resolve(ret);
+//     }
+// }
+
+// package com.cappitolian.plugins.httplocalserver;
+
+// import com.getcapacitor.JSObject;
+// import com.getcapacitor.Plugin;
+// import com.getcapacitor.PluginCall;
+// import com.getcapacitor.PluginMethod;
+// import com.getcapacitor.annotation.CapacitorPlugin;
+
+// @CapacitorPlugin(name = "HttpLocalServer")
+// public class HttpLocalServerPlugin extends Plugin {
+
+//     private HttpLocalServer implementation = new HttpLocalServer();
+
+//     @PluginMethod
+//     public void echo(PluginCall call) {
+//         String value = call.getString("value");
+
+//         JSObject ret = new JSObject();
+//         ret.put("value", implementation.echo(value));
+//         call.resolve(ret);
+//     }
+// }
+
+package com.cappitolian.plugins.httplocalservice;
+
+import com.getcapacitor.*;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@CapacitorPlugin(name = "HttpLocalServer")
+public class HttpLocalServerPlugin extends Plugin {
+
+    private HttpLocalServer localServer;
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        if (localServer == null) {
+            localServer = new HttpLocalServer(this);
+        }
+        localServer.connect(call);
+    }
+
+    // Add this method:
+    public void fireOnRequest(JSObject req) {
+        notifyListeners("onRequest", req, true);
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        if (localServer != null) {
+            localServer.disconnect(call);
+        } else {
+            call.resolve();
+        }
+    }
+
+    @PluginMethod
+    public void sendResponse(PluginCall call) {
+        String requestId = call.getString("requestId");
+        String body = call.getString("body");
+        if (requestId == null || body == null) {
+            call.reject("Missing requestId or body");
+            return;
+        }
+        HttpLocalServer.handleJsResponse(requestId, body);
+        call.resolve();
+    }
+}

package/dist/docs.json

@@ -0,0 +1,154 @@
+{
+  "api": {
+    "name": "HttpLocalServerPlugin",
+    "slug": "httplocalserverplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "connect",
+        "signature": "() => Promise<HttpConnectResult>",
+        "parameters": [],
+        "returns": "Promise<HttpConnectResult>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "HttpConnectResult"
+        ],
+        "slug": "connect"
+      },
+      {
+        "name": "disconnect",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "disconnect"
+      },
+      {
+        "name": "sendResponse",
+        "signature": "(options: { requestId: string; body: string; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ requestId: string; body: string; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "sendresponse"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'onRequest', listenerFunc: (info: HttpRequestInfo) => void) => Promise<PluginListenerHandle> & PluginListenerHandle",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'onRequest'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(info: HttpRequestInfo) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle> & PluginListenerHandle",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "HttpRequestInfo"
+        ],
+        "slug": "addlisteneronrequest-"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "HttpConnectResult",
+      "slug": "httpconnectresult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "ip",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "port",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "number"
+        }
+      ]
+    },
+    {
+      "name": "PluginListenerHandle",
+      "slug": "pluginlistenerhandle",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "remove",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "() => Promise<void>"
+        }
+      ]
+    },
+    {
+      "name": "HttpRequestInfo",
+      "slug": "httprequestinfo",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "requestId",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "method",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "path",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "body",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,22 @@
+export interface HttpConnectResult {
+    ip: string;
+    port: number;
+}
+export interface HttpRequestInfo {
+    requestId: string;
+    method: string;
+    path: string;
+    body?: string;
+}
+export interface HttpLocalServerPlugin {
+    connect(): Promise<HttpConnectResult>;
+    disconnect(): Promise<void>;
+    sendResponse(options: {
+        requestId: string;
+        body: string;
+    }): Promise<void>;
+    addListener(eventName: 'onRequest', listenerFunc: (info: HttpRequestInfo) => void): Promise<PluginListenerHandle> & PluginListenerHandle;
+}
+export interface PluginListenerHandle {
+    remove: () => Promise<void>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,5 @@
+// export interface HttpLocalServerPlugin {
+//   echo(options: { value: string }): Promise<{ value: string }>;
+// }
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,kEAAkE;AAClE,IAAI","sourcesContent":["// export interface HttpLocalServerPlugin {\n//   echo(options: { value: string }): Promise<{ value: string }>;\n// }\n\nexport interface HttpConnectResult {\n  ip: string;\n  port: number;\n}\n\nexport interface HttpRequestInfo {\n  requestId: string;\n  method: string;\n  path: string;\n  body?: string;\n}\n\nexport interface HttpLocalServerPlugin {\n  connect(): Promise<HttpConnectResult>;\n  disconnect(): Promise<void>;\n  sendResponse(options: { requestId: string; body: string }): Promise<void>;\n  addListener(\n    eventName: 'onRequest',\n    listenerFunc: (info: HttpRequestInfo) => void,\n  ): Promise<PluginListenerHandle> & PluginListenerHandle;\n}\n\nexport interface PluginListenerHandle {\n  remove: () => Promise<void>;\n}"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { HttpLocalServerPlugin } from './definitions';
+declare const HttpLocalServer: HttpLocalServerPlugin;
+export * from './definitions';
+export default HttpLocalServer;

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+// import { registerPlugin } from '@capacitor/core';
+// import type { HttpLocalServerPlugin } from './definitions';
+// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {
+//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),
+// });
+// export * from './definitions';
+// export { HttpLocalServer };
+import { registerPlugin } from '@capacitor/core';
+const HttpLocalServer = registerPlugin('HttpLocalServer');
+export * from './definitions';
+export default HttpLocalServer;
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,oDAAoD;AAEpD,8DAA8D;AAE9D,qFAAqF;AACrF,wEAAwE;AACxE,MAAM;AAEN,iCAAiC;AACjC,8BAA8B;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,MAAM,eAAe,GAAG,cAAc,CAAwB,iBAAiB,CAAC,CAAC;AAEjF,cAAc,eAAe,CAAC;AAC9B,eAAe,eAAe,CAAC","sourcesContent":["// import { registerPlugin } from '@capacitor/core';\n\n// import type { HttpLocalServerPlugin } from './definitions';\n\n// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {\n//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),\n// });\n\n// export * from './definitions';\n// export { HttpLocalServer };\n\nimport { registerPlugin } from '@capacitor/core';\nimport type { HttpLocalServerPlugin } from './definitions';\n\nconst HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer');\n\nexport * from './definitions';\nexport default HttpLocalServer;"]}

package/dist/plugin.cjs.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+// import { registerPlugin } from '@capacitor/core';
+// import type { HttpLocalServerPlugin } from './definitions';
+// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {
+//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),
+// });
+// export * from './definitions';
+// export { HttpLocalServer };
+const HttpLocalServer = core.registerPlugin('HttpLocalServer');
+
+module.exports = HttpLocalServer;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js"],"sourcesContent":["// import { registerPlugin } from '@capacitor/core';\n// import type { HttpLocalServerPlugin } from './definitions';\n// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {\n//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),\n// });\n// export * from './definitions';\n// export { HttpLocalServer };\nimport { registerPlugin } from '@capacitor/core';\nconst HttpLocalServer = registerPlugin('HttpLocalServer');\nexport * from './definitions';\nexport default HttpLocalServer;\n//# sourceMappingURL=index.js.map"],"names":["registerPlugin"],"mappings":";;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AAEK,MAAC,eAAe,GAAGA,mBAAc,CAAC,iBAAiB;;;;"}

package/dist/plugin.js

@@ -0,0 +1,16 @@
+var capacitorHttpLocalServer = (function (core) {
+	'use strict';
+
+	// import { registerPlugin } from '@capacitor/core';
+	// import type { HttpLocalServerPlugin } from './definitions';
+	// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {
+	//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),
+	// });
+	// export * from './definitions';
+	// export { HttpLocalServer };
+	const HttpLocalServer = core.registerPlugin('HttpLocalServer');
+
+	return HttpLocalServer;
+
+})(capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js"],"sourcesContent":["// import { registerPlugin } from '@capacitor/core';\n// import type { HttpLocalServerPlugin } from './definitions';\n// const HttpLocalServer = registerPlugin<HttpLocalServerPlugin>('HttpLocalServer', {\n//   web: () => import('./web').then((m) => new m.HttpLocalServerWeb()),\n// });\n// export * from './definitions';\n// export { HttpLocalServer };\nimport { registerPlugin } from '@capacitor/core';\nconst HttpLocalServer = registerPlugin('HttpLocalServer');\nexport * from './definitions';\nexport default HttpLocalServer;\n//# sourceMappingURL=index.js.map"],"names":["registerPlugin"],"mappings":";;;CAAA;CACA;CACA;CACA;CACA;CACA;CACA;AAEK,OAAC,eAAe,GAAGA,mBAAc,CAAC,iBAAiB;;;;;;;;"}

package/ios/Sources/HttpLocalServerPlugin/HttpLocalServer.swift

@@ -0,0 +1,157 @@
+// import Foundation
+
+// @objc public class HttpLocalServer: NSObject {
+//     @objc public func echo(_ value: String) -> String {
+//         print(value)
+//         return value
+//     }
+// }
+
+// import Foundation
+
+// @objc public class HttpLocalServer: NSObject {
+//     @objc public func echo(_ value: String) -> String {
+//         print(value)
+//         return value
+//     }
+// }
+
+import Foundation
+import GCDWebServer
+import Capacitor
+
+public protocol HttpLocalServerDelegate: AnyObject {
+    func httpLocalServerDidReceiveRequest(_ data: [String: Any])
+}
+
+@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")
+
+    public init(delegate: HttpLocalServerDelegate) {
+        self.delegate = delegate
+    }
+
+    @objc public func connect(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            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
+            do {
+                try self.webServer?.start(options: [
+                    GCDWebServerOption_Port: port,
+                    GCDWebServerOption_BonjourName: "",
+                    GCDWebServerOption_BindToLocalhost: false
+                ])
+                let ip = Self.getWiFiAddress() ?? "127.0.0.1"
+                call.resolve([
+                    "ip": ip,
+                    "port": port
+                ])
+            } catch {
+                call.reject("Failed to start server: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    @objc public func disconnect(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            self?.webServer?.stop()
+            self?.webServer = nil
+            call.resolve()
+        }
+    }
+
+    // Called by plugin when JS responds
+    static func handleJsResponse(requestId: String, body: String) {
+        queue.async {
+            if let callback = pendingResponses[requestId] {
+                callback(body)
+                pendingResponses.removeValue(forKey: requestId)
+            }
+        }
+    }
+
+    // Helper: get WiFi IP address (IPv4)
+    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
+            }
+            freeifaddrs(ifaddr)
+        }
+        return address
+    }
+}

package/ios/Sources/HttpLocalServerPlugin/HttpLocalServerPlugin.swift

@@ -0,0 +1,67 @@
+// import Foundation
+// import Capacitor
+
+// /**
+//  * Please read the Capacitor iOS Plugin Development Guide
+//  * here: https://capacitorjs.com/docs/plugins/ios
+//  */
+// @objc(HttpLocalServerPlugin)
+// public class HttpLocalServerPlugin: CAPPlugin, CAPBridgedPlugin {
+//     public let identifier = "HttpLocalServerPlugin"
+//     public let jsName = "HttpLocalServer"
+//     public let pluginMethods: [CAPPluginMethod] = [
+//         CAPPluginMethod(name: "echo", returnType: CAPPluginReturnPromise)
+//     ]
+//     private let implementation = HttpLocalServer()
+
+//     @objc func echo(_ call: CAPPluginCall) {
+//         let value = call.getString("value") ?? ""
+//         call.resolve([
+//             "value": implementation.echo(value)
+//         ])
+//     }
+// }
+
+import Foundation
+import Capacitor
+@objc(HttpLocalServerPlugin)
+public class HttpLocalServerPlugin: CAPPlugin, CAPBridgedPlugin, HttpLocalServerDelegate {
+    public let identifier = "HttpLocalServerPlugin"
+    public let jsName = "HttpLocalServer"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "connect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "disconnect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sendResponse", returnType: CAPPluginReturnPromise)
+    ]
+    var localServer: HttpLocalServer?
+
+    @objc func connect(_ call: CAPPluginCall) {
+        if localServer == nil {
+            localServer = HttpLocalServer(delegate: self)
+        }
+        localServer?.connect(call)
+    }
+
+    @objc func disconnect(_ call: CAPPluginCall) {
+        if localServer != nil {
+            localServer?.disconnect(call)
+        } else {
+            call.resolve()
+        }
+    }
+
+    @objc func sendResponse(_ call: CAPPluginCall) {
+        guard let requestId = call.getString("requestId"),
+              let body = call.getString("body") else {
+            call.reject("Missing requestId or body")
+            return
+        }
+        HttpLocalServer.handleJsResponse(requestId: requestId, body: body)
+        call.resolve()
+    }
+
+    // Delegate method
+    public func httpLocalServerDidReceiveRequest(_ data: [String: Any]) {
+        notifyListeners("onRequest", data: data)
+    }
+}

package/ios/Tests/HttpLocalServerPluginTests/HttpLocalServerPluginTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import HttpLocalServerPlugin
+
+class HttpLocalServerTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = HttpLocalServer()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@cappitolian/http-local-server",
+  "version": "0.0.1",
+  "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",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CappitolianHttpLocalServer.podspec"
+  ],
+  "author": "Cappitolian",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alessandrycruz1987/cappitolian/plugins/http-local-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alessandrycruz1987/cappitolian/plugins/http-local-server/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CappitolianHttpLocalServer -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api HttpLocalServerPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.0.0",
+    "@capacitor/core": "^7.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-java": "^2.6.6",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.30.1",
+    "swiftlint": "^2.0.0",
+    "typescript": "~4.1.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}