local2public 0.1.0__tar.gz

local2public-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+uv.lock

local2public-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

local2public-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: local2public
+Version: 0.1.0
+Summary: Local to public tunnel
+Requires-Python: >=3.10
+Requires-Dist: httpx

local2public-0.1.0/README.md

@@ -0,0 +1,5 @@
+# l2p - Local to Public
+
+```
+python cli.py --port [port_number] --name [your_website_name]
+```

local2public-0.1.0/app.py

@@ -0,0 +1,54 @@
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import HTMLResponse, JSONResponse
+import asyncio
+import uuid
+from fastapi import WebSocket, WebSocketDisconnect
+
+
+app = FastAPI(
+    title="Local To Public",
+    docs_url='/',
+    redoc_url='/docs',
+)
+
+import asyncio
+import uuid
+
+pending_requests = {}  # request_id -> {"request": ..., "future": ...}
+    
+@app.get("/poll/{name}")
+async def poll(name: str):
+    requests = {
+        rid: {"method": r["method"], "path": r["path"], "body": r["body"]}
+        for rid, r in pending_requests.items()
+    }
+    return JSONResponse(requests)
+
+@app.post("/respond/{request_id}")
+async def respond(request_id: str, request: Request):
+    data = await request.json()
+    if request_id in pending_requests:
+        pending_requests[request_id]["future"].set_result(data)
+    return JSONResponse({"ok": True})
+
+@app.api_route("/join/{name}/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
+async def proxy(name: str, path: str, request: Request):
+    request_id = str(uuid.uuid4())
+    loop = asyncio.get_event_loop()
+    future = loop.create_future()
+
+    pending_requests[request_id] = {
+        "method": request.method,
+        "path": f"/{path}",
+        "body": (await request.body()).decode(),
+        "future": future,
+    }
+
+    # wait for CLI to respond
+    try:
+        response = await asyncio.wait_for(future, timeout=30)
+        return Response(content=response["body"], status_code=response["status"])
+    except asyncio.TimeoutError:
+        return JSONResponse({"error": "timeout"}, status_code=504)
+    finally:
+        pending_requests.pop(request_id, None)

local2public-0.1.0/local2public/cli.py

@@ -0,0 +1,61 @@
+from argparse import ArgumentParser
+import asyncio
+import httpx
+
+SERVER_URL = "https://l2p-beige.vercel.app"  # change to your deployed server
+
+def parse_args():
+    parser = ArgumentParser(description="ltp - local to public")
+    parser.add_argument("-p", "--port", type=int, required=True)
+    parser.add_argument("-n", "--name", type=str, required=True)
+    parser.add_argument("-v", "--verbose", action="store_true")
+    return parser.parse_args()
+
+async def tunnel(local_port: int, name: str, verbose: bool):
+    print(f"Tunnel open: {SERVER_URL}/join/{name}/")
+    print("Ctrl+C to stop")
+
+    async with httpx.AsyncClient() as client:
+        while True:
+            try:
+                # poll for pending requests
+                resp = await client.get(f"{SERVER_URL}/poll/{name}", timeout=5)
+                requests = resp.json()
+
+                for request_id, req in requests.items():
+                    if verbose:
+                        print(f"→ {req['method']} {req['path']}")
+
+                    try:
+                        # forward to local server
+                        local_resp = await client.request(
+                            method=req["method"],
+                            url=f"http://localhost:{local_port}{req['path']}",
+                            content=req["body"],
+                            timeout=10,
+                        )
+                        # send response back to server
+                        await client.post(f"{SERVER_URL}/respond/{request_id}", json={
+                            "status": local_resp.status_code,
+                            "body": local_resp.text,
+                        })
+                    except Exception as e:
+                        await client.post(f"{SERVER_URL}/respond/{request_id}", json={
+                            "status": 502,
+                            "body": str(e),
+                        })
+
+            except Exception as e:
+                print(f"Poll error: {e}")
+
+            await asyncio.sleep(0.5)
+
+def main():
+    args = parse_args()
+    try:
+        asyncio.run(tunnel(args.port, args.name, args.verbose))
+    except KeyboardInterrupt:
+        print("\nTunnel closed")
+
+if __name__ == "__main__":
+    main()

local2public-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "local2public"
+version = "0.1.0"
+description = "Local to public tunnel"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx",
+]
+
+[project.scripts]
+ltp = "ltp.cli:main"

local2public-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+fastapi
+websockets
+uvicorn

local2public-0.1.0/vercel.json

@@ -0,0 +1,10 @@
+{
+    "builds": [{
+        "src": "app.py",
+        "use": "@vercel/python"
+    }],
+    "routes": [{
+        "src": "/(.*)",
+        "dest": "app.py"
+    }]
+}