devlinker 1.2.4__tar.gz → 1.2.8__tar.gz

{devlinker-1.2.4/devlinker.egg-info → devlinker-1.2.8}/PKG-INFO

@@ -1,14 +1,18 @@
 Metadata-Version: 2.4
 Name: devlinker
-Version: 1.2.4
+Version: 1.2.8
 Summary: AI-powered linking and automation tool
 Author-email: Mani <mani1028@users.noreply.github.com>
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: click
-Requires-Dist: flask
+Requires-Dist: docker
+Requires-Dist: fastapi
+Requires-Dist: httpx
 Requires-Dist: pyngrok
 Requires-Dist: requests
+Requires-Dist: uvicorn
+Requires-Dist: websockets
 
 # Dev Linker
 
@@ -23,7 +27,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
-- No config needed for standard Flask/Docker flows
+- No config needed for standard FastAPI or Flask plus Docker flows
 - Serves both through one proxy at http://localhost:8000
 - Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
 - Terminal-first workflow
@@ -70,7 +74,7 @@ Typical startup output:
 ```text
 Dev Linker v1.2.2
 
-[INFO] Mode: Auto (Flask + Docker detection)
+[INFO] Mode: Auto (FastAPI async proxy + Docker detection)
 [INFO] Booting local services...
 [INFO] Detecting frontend/backend ports...
 [OK] Frontend -> 5173
@@ -88,8 +92,10 @@ Tip: Press Ctrl+Click to open link
 DevLinker Ready (in 2.4s)
 Frontend: http://localhost:5173
 Backend:  http://localhost:5000
-Proxy:    http://localhost:8000
-PUBLIC URL: https://xxxx.trycloudflare.com
+Access Links:
+Local:  http://localhost:8000
+WLAN:   http://192.168.1.5:8000
+Public: https://xxxx.trycloudflare.com
 Tip: Press Ctrl+Click to open link
 ```
 
@@ -123,6 +129,12 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Disable WLAN URL output:
+
+```bash
+devlinker --no-lan
+```
+
 Interactive backend selection (when local and Docker are both detected):
 
 ```bash
@@ -157,6 +169,7 @@ Frontend detection behavior:
 - Scans Vite defaults and fallback ports (`5173` through `5190`)
 - Also checks common alternatives (`3000`, `4173`, `8080`)
 - Retries during startup to catch slow boot cases
+- Performs readiness gating before proxy startup (waits until frontend looks like Vite and backend responds)
 
 ## Important Frontend Rule
 
@@ -173,10 +186,13 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, parse all Docker host-to-container port mappings
-3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
-4. Use the best mapped host port automatically, even when internal port is not 5000
-5. If nothing is found, print next-step guidance and exit
+2. If not found, query Docker via Docker SDK (`docker.from_env()`) for published host-to-container port mappings
+3. Prioritize containers using labels when present (`devlinker.role=backend`, optional `devlinker.port=<container-port>`)
+4. Otherwise rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+5. Use the best mapped host port automatically, even when internal port is not 5000
+6. If nothing is found, print next-step guidance and exit
+
+If Docker SDK is unavailable, Dev Linker falls back to Docker CLI parsing as a compatibility path.
 
 When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
 
@@ -218,25 +234,33 @@ For containerized Flask backends, ensure:
 
 ## Notes
 
-- runner.py expects frontend project in frontend and Flask app in backend/app.py.
+- runner.py expects frontend project in frontend and Python app in backend/app.py.
 - If those paths do not exist, Dev Linker skips launch and only tries to detect already-running services.
 - Tunnel selection order is: cloudflared (TryCloudflare), then ngrok.
 - If cloudflared is unavailable and ngrok is not configured, Dev Linker prints one-time setup guidance.
 - You may need to set ngrok auth once on your machine using ngrok config add-authtoken <token>.
 - Dev Linker prints a public URL with `ngrok-skip-browser-warning=true` only when ngrok is used.
 - Startup output includes selected tunnel provider (`cloudflare` or `ngrok`).
-- When Dev Linker launches a Vite frontend, it sets `ONELINK=1` to disable Vite HMR WebSockets for stable tunnel behavior.
+- Proxy layer now supports WebSocket upgrades, including Vite HMR over shared links.
+- Proxy listens on `0.0.0.0` and can print a WLAN URL for same-network sharing.
+- If WLAN access fails on Windows, allow the proxy port in firewall and confirm devices are on the same network.
 
-## Real-Time Development Modes
+## Runtime Smoke Test
 
-### Option 1: Dev Linker sharing mode (recommended)
+Run this test to validate proxy behavior end-to-end (frontend HTTP route, backend API forwarding, and WebSocket pass-through):
 
-- Run `devlinker` to share one combined frontend/backend URL.
-- Open local Vite URL yourself for instant HMR updates.
-- Share Dev Linker/ngrok URL with others; they can use normal page refresh to see changes.
+```bash
+python -m unittest tests.test_proxy_runtime
+```
+
+The test spins up lightweight local frontend and backend apps, starts Dev Linker proxy, and verifies:
 
-### Option 2: Full remote HMR mode (bypass Dev Linker)
+- `GET /` is routed to frontend
+- `POST /api/login` is routed to backend
+- `ws://.../hmr` round-trip works through proxy
 
-- Start frontend and backend manually.
-- Configure Vite `server.proxy` for `/api` to backend.
-- Run `ngrok http <vite-port>` directly so Vite handles WebSocket HMR traffic.
+## Real-Time Development
+
+- Run `devlinker` to share one combined frontend/backend URL.
+- Vite HMR and other WebSocket flows are proxied end-to-end through Dev Linker.
+- Keep using relative frontend API paths (for example, `/api/endpoint`) so routing stays consistent locally and over tunnel.

devlinker-1.2.4/PKG-INFO → devlinker-1.2.8/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: devlinker
-Version: 1.2.4
-Summary: AI-powered linking and automation tool
-Author-email: Mani <mani1028@users.noreply.github.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: click
-Requires-Dist: flask
-Requires-Dist: pyngrok
-Requires-Dist: requests
-
 # Dev Linker
 
 Dev Linker runs frontend and backend dev servers, proxies both through a single local port (8000), and creates a single public URL via Cloudflare or ngrok.
@@ -23,7 +11,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
-- No config needed for standard Flask/Docker flows
+- No config needed for standard FastAPI or Flask plus Docker flows
 - Serves both through one proxy at http://localhost:8000
 - Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
 - Terminal-first workflow
@@ -70,7 +58,7 @@ Typical startup output:
 ```text
 Dev Linker v1.2.2
 
-[INFO] Mode: Auto (Flask + Docker detection)
+[INFO] Mode: Auto (FastAPI async proxy + Docker detection)
 [INFO] Booting local services...
 [INFO] Detecting frontend/backend ports...
 [OK] Frontend -> 5173
@@ -88,8 +76,10 @@ Tip: Press Ctrl+Click to open link
 DevLinker Ready (in 2.4s)
 Frontend: http://localhost:5173
 Backend:  http://localhost:5000
-Proxy:    http://localhost:8000
-PUBLIC URL: https://xxxx.trycloudflare.com
+Access Links:
+Local:  http://localhost:8000
+WLAN:   http://192.168.1.5:8000
+Public: https://xxxx.trycloudflare.com
 Tip: Press Ctrl+Click to open link
 ```
 
@@ -123,6 +113,12 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Disable WLAN URL output:
+
+```bash
+devlinker --no-lan
+```
+
 Interactive backend selection (when local and Docker are both detected):
 
 ```bash
@@ -157,6 +153,7 @@ Frontend detection behavior:
 - Scans Vite defaults and fallback ports (`5173` through `5190`)
 - Also checks common alternatives (`3000`, `4173`, `8080`)
 - Retries during startup to catch slow boot cases
+- Performs readiness gating before proxy startup (waits until frontend looks like Vite and backend responds)
 
 ## Important Frontend Rule
 
@@ -173,10 +170,13 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, parse all Docker host-to-container port mappings
-3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
-4. Use the best mapped host port automatically, even when internal port is not 5000
-5. If nothing is found, print next-step guidance and exit
+2. If not found, query Docker via Docker SDK (`docker.from_env()`) for published host-to-container port mappings
+3. Prioritize containers using labels when present (`devlinker.role=backend`, optional `devlinker.port=<container-port>`)
+4. Otherwise rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+5. Use the best mapped host port automatically, even when internal port is not 5000
+6. If nothing is found, print next-step guidance and exit
+
+If Docker SDK is unavailable, Dev Linker falls back to Docker CLI parsing as a compatibility path.
 
 When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
 
@@ -218,25 +218,33 @@ For containerized Flask backends, ensure:
 
 ## Notes
 
-- runner.py expects frontend project in frontend and Flask app in backend/app.py.
+- runner.py expects frontend project in frontend and Python app in backend/app.py.
 - If those paths do not exist, Dev Linker skips launch and only tries to detect already-running services.
 - Tunnel selection order is: cloudflared (TryCloudflare), then ngrok.
 - If cloudflared is unavailable and ngrok is not configured, Dev Linker prints one-time setup guidance.
 - You may need to set ngrok auth once on your machine using ngrok config add-authtoken <token>.
 - Dev Linker prints a public URL with `ngrok-skip-browser-warning=true` only when ngrok is used.
 - Startup output includes selected tunnel provider (`cloudflare` or `ngrok`).
-- When Dev Linker launches a Vite frontend, it sets `ONELINK=1` to disable Vite HMR WebSockets for stable tunnel behavior.
+- Proxy layer now supports WebSocket upgrades, including Vite HMR over shared links.
+- Proxy listens on `0.0.0.0` and can print a WLAN URL for same-network sharing.
+- If WLAN access fails on Windows, allow the proxy port in firewall and confirm devices are on the same network.
 
-## Real-Time Development Modes
+## Runtime Smoke Test
 
-### Option 1: Dev Linker sharing mode (recommended)
+Run this test to validate proxy behavior end-to-end (frontend HTTP route, backend API forwarding, and WebSocket pass-through):
 
-- Run `devlinker` to share one combined frontend/backend URL.
-- Open local Vite URL yourself for instant HMR updates.
-- Share Dev Linker/ngrok URL with others; they can use normal page refresh to see changes.
+```bash
+python -m unittest tests.test_proxy_runtime
+```
 
-### Option 2: Full remote HMR mode (bypass Dev Linker)
+The test spins up lightweight local frontend and backend apps, starts Dev Linker proxy, and verifies:
 
-- Start frontend and backend manually.
-- Configure Vite `server.proxy` for `/api` to backend.
-- Run `ngrok http <vite-port>` directly so Vite handles WebSocket HMR traffic.
+- `GET /` is routed to frontend
+- `POST /api/login` is routed to backend
+- `ws://.../hmr` round-trip works through proxy
+
+## Real-Time Development
+
+- Run `devlinker` to share one combined frontend/backend URL.
+- Vite HMR and other WebSocket flows are proxied end-to-end through Dev Linker.
+- Keep using relative frontend API paths (for example, `/api/endpoint`) so routing stays consistent locally and over tunnel.

{devlinker-1.2.4 → devlinker-1.2.8}/devlinker/detector.py

@@ -6,15 +6,50 @@ from typing import Iterable, Optional, Tuple
 import requests
 
 
-def check_port(port: int, timeout: float = 1.0) -> bool:
-    """Return True when an HTTP service responds on localhost:port."""
+DEFAULT_BACKEND_PROBE_PATHS = (
+    "/health",
+    "/api/health",
+    "/",
+)
+
+
+def check_port(
+    port: int,
+    timeout: float = 1.0,
+    probe_paths: Iterable[str] = DEFAULT_BACKEND_PROBE_PATHS,
+) -> bool:
+    """Return True when an HTTP service is reachable on localhost:port.
+
+    Probe order is health-first (for API-style backends), then root fallback.
+    """
+    normalized_paths: list[str] = []
+    for path in probe_paths:
+        cleaned = path.strip()
+        if not cleaned:
+            continue
+        if not cleaned.startswith("/"):
+            cleaned = f"/{cleaned}"
+        normalized_paths.append(cleaned)
+
+    if not normalized_paths:
+        normalized_paths = ["/"]
+
     for host in ("localhost", "127.0.0.1"):
-        try:
-            response = requests.get(f"http://{host}:{port}", timeout=timeout)
-            if response.status_code < 500:
+        for path in normalized_paths:
+            try:
+                response = requests.get(f"http://{host}:{port}{path}", timeout=timeout)
+            except requests.RequestException:
+                continue
+
+            # Health endpoints must return 2xx/3xx to be considered ready.
+            if path in {"/health", "/api/health"}:
+                if 200 <= response.status_code < 400:
+                    return True
+                continue
+
+            # Root fallback accepts non-error responses.
+            if 200 <= response.status_code < 400:
                 return True
-        except requests.RequestException:
-            pass
     return False
 
 

{devlinker-1.2.4 → devlinker-1.2.8}/devlinker/main.py

@@ -55,17 +55,55 @@ def _print_summary(
     backend_port: int,
     proxy_port: int,
     public_url: str | None,
+    wlan_url: str | None,
     startup_seconds: float,
 ) -> None:
     print(f"\nDevLinker Ready (in {startup_seconds:.1f}s)")
     print(f"Frontend: http://localhost:{frontend_port}")
     print(f"Backend:  http://localhost:{backend_port}")
-    print(f"Proxy:    http://localhost:{proxy_port}")
+    print("Access Links:")
+    print(f"Local:  http://localhost:{proxy_port}")
+    if wlan_url:
+        print(f"WLAN:   {wlan_url}")
+    else:
+        print("WLAN:   unavailable")
     if public_url:
-        print(f"PUBLIC URL: {public_url}")
+        print(f"Public: {public_url}")
         print("Tip: Press Ctrl+Click to open link")
     else:
-        print("Public:   unavailable (local proxy still active)")
+        print("Public: unavailable (local proxy still active)")
+
+
+def _get_local_ip() -> str | None:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.connect(("8.8.8.8", 80))
+        ip_address = sock.getsockname()[0]
+        if ip_address and not ip_address.startswith("127."):
+            return ip_address
+        return None
+    except OSError:
+        return None
+    finally:
+        sock.close()
+
+
+def _wait_for_readiness(
+    label: str,
+    port: int,
+    checker,
+    retries: int = 15,
+    delay_seconds: float = 1.0,
+) -> bool:
+    print(f"[INFO] Waiting for {label} on :{port}...")
+    for attempt in range(1, retries + 1):
+        if checker(port):
+            print(f"[OK] {label} ready on :{port}")
+            return True
+        if attempt < retries:
+            time.sleep(delay_seconds)
+    print(f"[WARN] {label} not ready on :{port} after {retries} checks")
+    return False
 
 
 @click.command()
@@ -93,6 +131,13 @@ def _print_summary(
     show_default=True,
     help="Prompt to choose backend when local and Docker candidates are both available.",
 )
+@click.option(
+    "--lan/--no-lan",
+    "lan_enabled",
+    default=True,
+    show_default=True,
+    help="Show WLAN sharing URL for devices on the same network.",
+)
 @click.option("--debug", is_flag=True, hidden=True, help="Enable debug logging.")
 def cli(
     frontend: int | None,
@@ -101,11 +146,12 @@ def cli(
     auto_start_docker: bool,
     no_tunnel: bool,
     interactive_backend: bool,
+    lan_enabled: bool,
     debug: bool,
 ) -> None:
     started = time.perf_counter()
     print(f"\nDev Linker v{__version__}")
-    print("[INFO] Mode: Auto (Flask + Docker detection)")
+    print("[INFO] Mode: Auto (FastAPI async proxy + Docker detection)")
     print("[INFO] Booting local services...")
 
     start_servers(auto_start_docker=auto_start_docker)
@@ -131,13 +177,13 @@ def cli(
             "Backend not detected on common ports. Start backend first or set --backend (example: 5000)."
         )
 
-    if not is_vite_port(frontend_port):
+    if not _wait_for_readiness("Frontend", frontend_port, is_vite_port):
         raise click.ClickException(
             f"Frontend port {frontend_port} is reachable but does not look like a Vite dev server. "
             "Run frontend with Dev Linker or pass the correct --frontend port."
         )
 
-    if not check_port(backend_port):
+    if not _wait_for_readiness("Backend", backend_port, check_port):
         raise click.ClickException(
             f"Backend port {backend_port} is not reachable. Verify backend is running and listening on localhost."
         )
@@ -150,9 +196,20 @@ def cli(
     print(f"[INFO] Starting proxy on :{proxy_port}...")
     start_proxy(frontend_port, backend_port, proxy_port=proxy_port)
 
-    # Allow Flask thread to bind before opening tunnel.
+    # Allow proxy thread to bind before opening tunnel.
     time.sleep(1)
 
+    wlan_url: str | None = None
+    if lan_enabled:
+        local_ip = _get_local_ip()
+        if local_ip:
+            wlan_url = f"http://{local_ip}:{proxy_port}"
+            print(f"[OK] WLAN URL: {wlan_url}")
+            print("[INFO] Share WLAN link with teammates on same WiFi/LAN.")
+        else:
+            print("[WARN] WLAN URL unavailable (no active LAN interface detected).")
+            print("[INFO] If LAN sharing fails, allow proxy port in firewall and use same network.")
+
     print(f"\n[OK] Proxy ready at http://localhost:{proxy_port}\n")
     warning_free_url: str | None = None
     if no_tunnel:
@@ -179,6 +236,7 @@ def cli(
         backend_port,
         proxy_port,
         warning_free_url,
+        wlan_url,
         startup_seconds=time.perf_counter() - started,
     )
 

devlinker-1.2.8/devlinker/proxy.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Dict, Optional
+from urllib.parse import urlencode
+
+import httpx
+import uvicorn
+import websockets
+from fastapi import FastAPI, Request, Response, WebSocket
+from fastapi.responses import PlainTextResponse
+from starlette.websockets import WebSocketDisconnect
+from websockets.exceptions import ConnectionClosed
+
+app = FastAPI()
+
+FRONTEND: Optional[int] = None
+BACKEND: Optional[int] = None
+HTTP_CLIENT: Optional[httpx.AsyncClient] = None
+
+HOP_BY_HOP_HEADERS = {
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+}
+
+
+@app.on_event("startup")
+async def _on_startup() -> None:
+    global HTTP_CLIENT
+    HTTP_CLIENT = httpx.AsyncClient(timeout=15.0, follow_redirects=False)
+
+
+@app.on_event("shutdown")
+async def _on_shutdown() -> None:
+    global HTTP_CLIENT
+    if HTTP_CLIENT is not None:
+        await HTTP_CLIENT.aclose()
+        HTTP_CLIENT = None
+
+
+def _connection_header_tokens(headers: Dict[str, str]) -> set[str]:
+    connection = ""
+    for key, value in headers.items():
+        if key.lower() == "connection":
+            connection = value
+            break
+    return {token.strip().lower() for token in connection.split(",") if token.strip()}
+
+
+def _filter_request_headers(incoming: Dict[str, str]) -> Dict[str, str]:
+    connection_tokens = _connection_header_tokens(incoming)
+    excluded = HOP_BY_HOP_HEADERS | connection_tokens | {"host", "content-length"}
+    return {k: v for k, v in incoming.items() if k.lower() not in excluded}
+
+
+def _filter_response_headers(incoming: Dict[str, str]) -> Dict[str, str]:
+    connection_tokens = _connection_header_tokens(incoming)
+    excluded = HOP_BY_HOP_HEADERS | connection_tokens | {"content-length"}
+    return {k: v for k, v in incoming.items() if k.lower() not in excluded}
+
+
+def _filter_websocket_headers(incoming: Dict[str, str]) -> Dict[str, str]:
+    connection_tokens = _connection_header_tokens(incoming)
+    excluded = HOP_BY_HOP_HEADERS | connection_tokens | {
+        "host",
+        "sec-websocket-key",
+        "sec-websocket-version",
+        "sec-websocket-extensions",
+        "sec-websocket-protocol",
+    }
+    return {k: v for k, v in incoming.items() if k.lower() not in excluded}
+
+
+def _target_port(path: str) -> Optional[int]:
+    if path == "/api" or path.startswith("/api/"):
+        return BACKEND
+    return FRONTEND
+
+
+def _build_target_http_url(port: int, path: str, query_params: list[tuple[str, str]]) -> str:
+    query_string = urlencode(query_params, doseq=True)
+    base_url = f"http://127.0.0.1:{port}{path}"
+    if not query_string:
+        return base_url
+    return f"{base_url}?{query_string}"
+
+
+def _build_target_ws_url(port: int, path: str, query: str) -> str:
+    base_url = f"ws://127.0.0.1:{port}{path}"
+    if not query:
+        return base_url
+    return f"{base_url}?{query}"
+
+
+async def _forward_http(request: Request) -> Response:
+    target_port = _target_port(request.url.path)
+    if target_port is None:
+        if request.url.path.startswith("/api"):
+            return PlainTextResponse("Backend is not configured.", status_code=503)
+        return PlainTextResponse("Frontend is not configured.", status_code=503)
+
+    if HTTP_CLIENT is None:
+        return PlainTextResponse("Proxy HTTP client is not ready.", status_code=503)
+
+    payload = await request.body()
+    query_params = list(request.query_params.multi_items())
+    target_url = _build_target_http_url(target_port, request.url.path, query_params)
+
+    try:
+        upstream = await HTTP_CLIENT.request(
+            method=request.method,
+            url=target_url,
+            content=payload,
+            headers=_filter_request_headers(dict(request.headers)),
+        )
+    except httpx.RequestError as exc:
+        return PlainTextResponse(f"Upstream unavailable: {exc}", status_code=502)
+
+    return Response(
+        content=upstream.content,
+        status_code=upstream.status_code,
+        headers=_filter_response_headers(dict(upstream.headers)),
+    )
+
+
+async def _proxy_websocket(websocket: WebSocket) -> None:
+    target_port = _target_port(websocket.url.path)
+    if target_port is None:
+        await websocket.close(code=1013)
+        return
+
+    requested_subprotocols = [
+        value.strip()
+        for value in websocket.headers.get("sec-websocket-protocol", "").split(",")
+        if value.strip()
+    ]
+    forward_headers = _filter_websocket_headers(dict(websocket.headers))
+    target_url = _build_target_ws_url(target_port, websocket.url.path, websocket.url.query)
+
+    try:
+        connect_kwargs = {
+            "subprotocols": requested_subprotocols or None,
+            "open_timeout": 10,
+            "ping_interval": 20,
+            "ping_timeout": 20,
+        }
+        try:
+            upstream_connect = websockets.connect(
+                target_url,
+                additional_headers=forward_headers,
+                **connect_kwargs,
+            )
+        except TypeError:
+            upstream_connect = websockets.connect(
+                target_url,
+                extra_headers=forward_headers,
+                **connect_kwargs,
+            )
+
+        async with upstream_connect as upstream:
+            await websocket.accept(subprotocol=upstream.subprotocol)
+
+            async def client_to_upstream() -> None:
+                while True:
+                    message = await websocket.receive()
+                    if message["type"] == "websocket.disconnect":
+                        break
+                    text = message.get("text")
+                    if text is not None:
+                        await upstream.send(text)
+                        continue
+                    binary = message.get("bytes")
+                    if binary is not None:
+                        await upstream.send(binary)
+
+            async def upstream_to_client() -> None:
+                while True:
+                    data = await upstream.recv()
+                    if isinstance(data, str):
+                        await websocket.send_text(data)
+                    else:
+                        await websocket.send_bytes(data)
+
+            done, pending = await asyncio.wait(
+                {
+                    asyncio.create_task(client_to_upstream()),
+                    asyncio.create_task(upstream_to_client()),
+                },
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            for task in pending:
+                task.cancel()
+            await asyncio.gather(*pending, return_exceptions=True)
+            for task in done:
+                exception = task.exception()
+                if exception and not isinstance(exception, (WebSocketDisconnect, ConnectionClosed)):
+                    raise exception
+    except Exception:
+        if websocket.client_state.name != "DISCONNECTED":
+            await websocket.close(code=1011)
+
+
+@app.api_route(
+    "/",
+    methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+)
+@app.api_route(
+    "/{path:path}",
+    methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+)
+async def http_proxy(path: str, request: Request) -> Response:  # noqa: ARG001
+    return await _forward_http(request)
+
+
+@app.websocket("/")
+@app.websocket("/{path:path}")
+async def websocket_proxy(websocket: WebSocket, path: str) -> None:  # noqa: ARG001
+    await _proxy_websocket(websocket)
+
+
+def start_proxy(frontend_port: int, backend_port: int, proxy_port: int = 8000) -> None:
+    global FRONTEND, BACKEND
+    FRONTEND = frontend_port
+    BACKEND = backend_port
+
+    thread = threading.Thread(
+        target=lambda: uvicorn.run(app, host="0.0.0.0", port=proxy_port, log_level="warning"),
+        daemon=True,
+    )
+    thread.start()

{devlinker-1.2.4 → devlinker-1.2.8}/devlinker/runner.py

@@ -9,7 +9,12 @@ import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import List
+from typing import Any, List
+
+try:
+    import docker  # type: ignore
+except ImportError:  # pragma: no cover - optional fallback path
+    docker = None
 
 from .detector import check_port, is_vite_port
 
@@ -82,7 +87,129 @@ def _container_priority(name: str, container_port: int, default_container_port:
     return score
 
 
-def get_docker_backend_candidates(
+def _normalize_label_port(value: str | None) -> int | None:
+    if not value:
+        return None
+    try:
+        parsed = int(value)
+    except ValueError:
+        return None
+    if 1 <= parsed <= 65535:
+        return parsed
+    return None
+
+
+def _extract_port_mappings_from_docker_sdk(container: Any) -> list[tuple[int, int]]:
+    mappings: list[tuple[int, int]] = []
+    ports = (container.attrs or {}).get("NetworkSettings", {}).get("Ports", {})
+    if not isinstance(ports, dict):
+        return mappings
+
+    for container_port_proto, bindings in ports.items():
+        if not isinstance(container_port_proto, str):
+            continue
+        try:
+            container_port = int(container_port_proto.split("/", 1)[0])
+        except (ValueError, IndexError):
+            continue
+        if not bindings:
+            continue
+        if not isinstance(bindings, list):
+            continue
+
+        for binding in bindings:
+            if not isinstance(binding, dict):
+                continue
+            host_port_str = binding.get("HostPort")
+            if not host_port_str:
+                continue
+            try:
+                host_port = int(host_port_str)
+            except (TypeError, ValueError):
+                continue
+            mappings.append((host_port, container_port))
+    return mappings
+
+
+def _docker_sdk_backend_candidates(
+    default_container_port: int = 5000,
+    debug: bool = False,
+) -> list[tuple[str, int, int]]:
+    if docker is None:
+        _debug_log(debug, "Docker SDK not installed; falling back to docker CLI parsing")
+        return []
+
+    try:
+        client = docker.from_env()
+        containers = client.containers.list()
+    except Exception as exc:
+        _debug_log(debug, f"Docker SDK unavailable ({exc}); falling back to docker CLI parsing")
+        return []
+
+    candidates: list[tuple[int, int, str, int, int, int]] = []
+    for index, container in enumerate(containers):
+        container_name = str(getattr(container, "name", "unknown"))
+        labels = getattr(container, "labels", {}) or {}
+        role_label = str(labels.get("devlinker.role", "")).strip().lower()
+        preferred_container_port = _normalize_label_port(labels.get("devlinker.port"))
+        if preferred_container_port is None:
+            preferred_container_port = _normalize_label_port(labels.get("devlinker.backend.port"))
+
+        mappings = _extract_port_mappings_from_docker_sdk(container)
+        if not mappings:
+            continue
+
+        for host_port, container_port in mappings:
+            priority = _container_priority(container_name, container_port, default_container_port)
+            if role_label == "backend":
+                priority += 20
+            elif role_label:
+                priority -= 2
+
+            if preferred_container_port is not None:
+                if container_port == preferred_container_port:
+                    priority += 12
+                else:
+                    priority -= 6
+
+            candidates.append((priority, index, container_name, host_port, container_port, preferred_container_port or 0))
+            _debug_log(
+                debug,
+                (
+                    f"SDK candidate: container='{container_name}', host={host_port}, "
+                    f"container={container_port}, role={role_label or '-'}, "
+                    f"label_port={preferred_container_port if preferred_container_port is not None else '-'}, "
+                    f"score={priority}"
+                ),
+            )
+
+    if not candidates:
+        return []
+
+    ranked = sorted(candidates, key=lambda item: (-item[0], item[1]))
+    ordered: list[tuple[str, int, int]] = []
+    seen: set[tuple[str, int, int]] = set()
+    for _score, _index, name, host_port, container_port, _label_port in ranked:
+        key = (name, host_port, container_port)
+        if key in seen:
+            continue
+        seen.add(key)
+        ordered.append(key)
+
+    if ordered:
+        first_name, first_host_port, first_container_port = ordered[0]
+        _debug_log(
+            debug,
+            (
+                f"Selected Docker SDK container '{first_name}' with host port {first_host_port} "
+                f"(container port {first_container_port})"
+            ),
+        )
+
+    return ordered
+
+
+def _docker_cli_backend_candidates(
     default_container_port: int = 5000,
     debug: bool = False,
 ) -> list[tuple[str, int, int]]:
@@ -122,7 +249,7 @@ def get_docker_backend_candidates(
             _debug_log(
                 debug,
                 (
-                    f"Candidate Docker port mapping: container='{name}', "
+                    f"CLI candidate Docker mapping: container='{name}', "
                     f"host={host_port}, container={container_port}"
                 ),
             )
@@ -130,7 +257,6 @@ def get_docker_backend_candidates(
     if not candidates:
         return []
 
-    # Score candidates by likely backend identity and prefer newest on ties.
     ranked = sorted(
         candidates,
         key=lambda item: (-_container_priority(item[0], item[2], default_container_port), item[3]),
@@ -144,19 +270,26 @@ def get_docker_backend_candidates(
         seen.add(key)
         ordered.append(key)
 
-    if ordered:
-        name, host_port, container_port = ordered[0]
-        _debug_log(
-            debug,
-            (
-                f"Selected Docker container '{name}' with host port {host_port} "
-                f"(container port {container_port})"
-            ),
-        )
-
     return ordered
 
 
+def get_docker_backend_candidates(
+    default_container_port: int = 5000,
+    debug: bool = False,
+) -> list[tuple[str, int, int]]:
+    sdk_candidates = _docker_sdk_backend_candidates(
+        default_container_port=default_container_port,
+        debug=debug,
+    )
+    if sdk_candidates:
+        return sdk_candidates
+
+    return _docker_cli_backend_candidates(
+        default_container_port=default_container_port,
+        debug=debug,
+    )
+
+
 def _choose_backend_candidate(
     local_port: int,
     docker_candidates: list[tuple[str, int, int]],

devlinker-1.2.4/README.md → devlinker-1.2.8/devlinker.egg-info/PKG-INFO

@@ -1,3 +1,19 @@
+Metadata-Version: 2.4
+Name: devlinker
+Version: 1.2.8
+Summary: AI-powered linking and automation tool
+Author-email: Mani <mani1028@users.noreply.github.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Requires-Dist: docker
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: pyngrok
+Requires-Dist: requests
+Requires-Dist: uvicorn
+Requires-Dist: websockets
+
 # Dev Linker
 
 Dev Linker runs frontend and backend dev servers, proxies both through a single local port (8000), and creates a single public URL via Cloudflare or ngrok.
@@ -11,7 +27,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
-- No config needed for standard Flask/Docker flows
+- No config needed for standard FastAPI or Flask plus Docker flows
 - Serves both through one proxy at http://localhost:8000
 - Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
 - Terminal-first workflow
@@ -58,7 +74,7 @@ Typical startup output:
 ```text
 Dev Linker v1.2.2
 
-[INFO] Mode: Auto (Flask + Docker detection)
+[INFO] Mode: Auto (FastAPI async proxy + Docker detection)
 [INFO] Booting local services...
 [INFO] Detecting frontend/backend ports...
 [OK] Frontend -> 5173
@@ -76,8 +92,10 @@ Tip: Press Ctrl+Click to open link
 DevLinker Ready (in 2.4s)
 Frontend: http://localhost:5173
 Backend:  http://localhost:5000
-Proxy:    http://localhost:8000
-PUBLIC URL: https://xxxx.trycloudflare.com
+Access Links:
+Local:  http://localhost:8000
+WLAN:   http://192.168.1.5:8000
+Public: https://xxxx.trycloudflare.com
 Tip: Press Ctrl+Click to open link
 ```
 
@@ -111,6 +129,12 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Disable WLAN URL output:
+
+```bash
+devlinker --no-lan
+```
+
 Interactive backend selection (when local and Docker are both detected):
 
 ```bash
@@ -145,6 +169,7 @@ Frontend detection behavior:
 - Scans Vite defaults and fallback ports (`5173` through `5190`)
 - Also checks common alternatives (`3000`, `4173`, `8080`)
 - Retries during startup to catch slow boot cases
+- Performs readiness gating before proxy startup (waits until frontend looks like Vite and backend responds)
 
 ## Important Frontend Rule
 
@@ -161,10 +186,13 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, parse all Docker host-to-container port mappings
-3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
-4. Use the best mapped host port automatically, even when internal port is not 5000
-5. If nothing is found, print next-step guidance and exit
+2. If not found, query Docker via Docker SDK (`docker.from_env()`) for published host-to-container port mappings
+3. Prioritize containers using labels when present (`devlinker.role=backend`, optional `devlinker.port=<container-port>`)
+4. Otherwise rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+5. Use the best mapped host port automatically, even when internal port is not 5000
+6. If nothing is found, print next-step guidance and exit
+
+If Docker SDK is unavailable, Dev Linker falls back to Docker CLI parsing as a compatibility path.
 
 When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
 
@@ -206,25 +234,33 @@ For containerized Flask backends, ensure:
 
 ## Notes
 
-- runner.py expects frontend project in frontend and Flask app in backend/app.py.
+- runner.py expects frontend project in frontend and Python app in backend/app.py.
 - If those paths do not exist, Dev Linker skips launch and only tries to detect already-running services.
 - Tunnel selection order is: cloudflared (TryCloudflare), then ngrok.
 - If cloudflared is unavailable and ngrok is not configured, Dev Linker prints one-time setup guidance.
 - You may need to set ngrok auth once on your machine using ngrok config add-authtoken <token>.
 - Dev Linker prints a public URL with `ngrok-skip-browser-warning=true` only when ngrok is used.
 - Startup output includes selected tunnel provider (`cloudflare` or `ngrok`).
-- When Dev Linker launches a Vite frontend, it sets `ONELINK=1` to disable Vite HMR WebSockets for stable tunnel behavior.
+- Proxy layer now supports WebSocket upgrades, including Vite HMR over shared links.
+- Proxy listens on `0.0.0.0` and can print a WLAN URL for same-network sharing.
+- If WLAN access fails on Windows, allow the proxy port in firewall and confirm devices are on the same network.
 
-## Real-Time Development Modes
+## Runtime Smoke Test
 
-### Option 1: Dev Linker sharing mode (recommended)
+Run this test to validate proxy behavior end-to-end (frontend HTTP route, backend API forwarding, and WebSocket pass-through):
 
-- Run `devlinker` to share one combined frontend/backend URL.
-- Open local Vite URL yourself for instant HMR updates.
-- Share Dev Linker/ngrok URL with others; they can use normal page refresh to see changes.
+```bash
+python -m unittest tests.test_proxy_runtime
+```
 
-### Option 2: Full remote HMR mode (bypass Dev Linker)
+The test spins up lightweight local frontend and backend apps, starts Dev Linker proxy, and verifies:
 
-- Start frontend and backend manually.
-- Configure Vite `server.proxy` for `/api` to backend.
-- Run `ngrok http <vite-port>` directly so Vite handles WebSocket HMR traffic.
+- `GET /` is routed to frontend
+- `POST /api/login` is routed to backend
+- `ws://.../hmr` round-trip works through proxy
+
+## Real-Time Development
+
+- Run `devlinker` to share one combined frontend/backend URL.
+- Vite HMR and other WebSocket flows are proxied end-to-end through Dev Linker.
+- Keep using relative frontend API paths (for example, `/api/endpoint`) so routing stays consistent locally and over tunnel.

devlinker-1.2.8/devlinker.egg-info/requires.txt

@@ -0,0 +1,8 @@
+click
+docker
+fastapi
+httpx
+pyngrok
+requests
+uvicorn
+websockets

{devlinker-1.2.4 → devlinker-1.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devlinker"
-version = "1.2.4"
+version = "1.2.8"
 description = "AI-powered linking and automation tool"
 authors = [
     { name = "Mani", email = "mani1028@users.noreply.github.com" }
@@ -13,9 +13,13 @@ readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [
     "click",
-    "flask",
+    "docker",
+    "fastapi",
+    "httpx",
     "pyngrok",
     "requests",
+    "uvicorn",
+    "websockets",
 ]
 
 [project.scripts]

devlinker-1.2.4/devlinker/proxy.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import threading
-from typing import Dict, Optional
-
-import requests
-from flask import Flask, Response, request
-
-app = Flask(__name__)
-
-FRONTEND: Optional[int] = None
-BACKEND: Optional[int] = None
-
-
-def _filter_headers(incoming: Dict[str, str]) -> Dict[str, str]:
-    excluded = {
-        "host",
-        "content-length",
-        "connection",
-        "accept-encoding",
-        "upgrade",
-        "sec-websocket-key",
-        "sec-websocket-version",
-        "sec-websocket-extensions",
-    }
-    return {k: v for k, v in incoming.items() if k.lower() not in excluded}
-
-
-def _forward(target_url: str) -> Response:
-    if request.headers.get("Upgrade", "").lower() == "websocket":
-        return Response(
-            "WebSocket upgrade is not supported by the Dev Linker HTTP proxy. "
-            "For shared links, run Vite with HMR disabled.",
-            status=426,
-        )
-
-    payload = request.get_data() if request.method in {"POST", "PUT", "PATCH"} else None
-    query_params = list(request.args.items(multi=True))
-
-    try:
-        upstream = requests.request(
-            method=request.method,
-            url=target_url,
-            params=query_params,
-            data=payload,
-            headers=_filter_headers(dict(request.headers)),
-            cookies=request.cookies,
-            allow_redirects=False,
-            timeout=15,
-        )
-    except requests.RequestException as exc:
-        return Response(f"Upstream unavailable: {exc}", status=502)
-
-    response = Response(upstream.content, status=upstream.status_code)
-    for key, value in upstream.headers.items():
-        if key.lower() in {"content-length", "transfer-encoding", "connection"}:
-            continue
-        response.headers[key] = value
-    return response
-
-
-@app.route("/api/<path:path>", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"])
-def api_proxy(path: str) -> Response:
-    if BACKEND is None:
-        return Response("Backend is not configured.", status=503)
-    return _forward(f"http://localhost:{BACKEND}/api/{path}")
-
-
-@app.route("/", defaults={"path": ""}, methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"])
-@app.route("/<path:path>", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"])
-def frontend_proxy(path: str) -> Response:
-    if FRONTEND is None:
-        return Response("Frontend is not configured.", status=503)
-
-    target = f"http://localhost:{FRONTEND}/{path}" if path else f"http://localhost:{FRONTEND}/"
-    return _forward(target)
-
-
-def start_proxy(frontend_port: int, backend_port: int, proxy_port: int = 8000) -> None:
-    global FRONTEND, BACKEND
-    FRONTEND = frontend_port
-    BACKEND = backend_port
-
-    thread = threading.Thread(
-        target=lambda: app.run(host="0.0.0.0", port=proxy_port, debug=False, use_reloader=False),
-        daemon=True,
-    )
-    thread.start()

devlinker-1.2.4/devlinker.egg-info/requires.txt

@@ -1,4 +0,0 @@
-click
-flask
-pyngrok
-requests