devlinker 0.1.0__tar.gz

devlinker-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: devlinker
+Version: 0.1.0
+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.
+
+## Features
+
+- Launches frontend and backend (when frontend and backend/app.py exist)
+- Detects common frontend/backend ports
+- Serves both through one proxy at http://localhost:8000
+- Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
+- Terminal-first workflow
+- Supports CLI version output with --version
+
+## Project Structure
+
+```text
+onelink/
+├── onelink/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── runner.py
+│   ├── detector.py
+│   ├── proxy.py
+│   └── tunnel.py
+├── setup.py
+├── README.md
+└── requirements.txt
+```
+
+## Install
+
+For local development:
+
+```bash
+pip install .
+```
+
+After publishing to PyPI:
+
+```bash
+pip install dev-linker
+```
+
+## Run
+
+```bash
+devlinker
+```
+
+Typical startup output:
+
+```text
+✨ Dev Linker v0.1.0
+
+🚀 Starting services...
+🔍 Detecting services...
+	• Frontend -> 5173
+	• Backend  -> 5000
+
+🌐 Proxy ready at http://localhost:8000
+
+⚡ Tunnel provider: Cloudflare
+🌍 Public URL:
+	https://xxxx.trycloudflare.com
+
+👉 Share this link with anyone
+```
+
+Version check:
+
+```bash
+devlinker --version
+```
+
+Optional overrides:
+
+```bash
+devlinker --frontend 5173 --backend 5000
+```
+
+If port 8000 is already in use:
+
+```bash
+devlinker --frontend 5173 --backend 5000 --proxy-port 18000
+```
+
+Default behavior also tries fallback ports automatically when 8000 is busy:
+
+- 8001
+- 8002
+- 18000
+
+## Important Frontend Rule
+
+Frontend requests must use relative API paths:
+
+```js
+fetch("/api/endpoint")
+```
+
+Do not hardcode backend host URLs in frontend code.
+
+## Notes
+
+- runner.py expects frontend project in frontend and Flask 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.
+
+## Real-Time Development Modes
+
+### Option 1: Dev Linker sharing mode (recommended)
+
+- 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.
+
+### Option 2: Full remote HMR mode (bypass Dev Linker)
+
+- 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.

devlinker-0.1.0/README.md

@@ -0,0 +1,126 @@
+# 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.
+
+## Features
+
+- Launches frontend and backend (when frontend and backend/app.py exist)
+- Detects common frontend/backend ports
+- Serves both through one proxy at http://localhost:8000
+- Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
+- Terminal-first workflow
+- Supports CLI version output with --version
+
+## Project Structure
+
+```text
+onelink/
+├── onelink/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── runner.py
+│   ├── detector.py
+│   ├── proxy.py
+│   └── tunnel.py
+├── setup.py
+├── README.md
+└── requirements.txt
+```
+
+## Install
+
+For local development:
+
+```bash
+pip install .
+```
+
+After publishing to PyPI:
+
+```bash
+pip install dev-linker
+```
+
+## Run
+
+```bash
+devlinker
+```
+
+Typical startup output:
+
+```text
+✨ Dev Linker v0.1.0
+
+🚀 Starting services...
+🔍 Detecting services...
+	• Frontend -> 5173
+	• Backend  -> 5000
+
+🌐 Proxy ready at http://localhost:8000
+
+⚡ Tunnel provider: Cloudflare
+🌍 Public URL:
+	https://xxxx.trycloudflare.com
+
+👉 Share this link with anyone
+```
+
+Version check:
+
+```bash
+devlinker --version
+```
+
+Optional overrides:
+
+```bash
+devlinker --frontend 5173 --backend 5000
+```
+
+If port 8000 is already in use:
+
+```bash
+devlinker --frontend 5173 --backend 5000 --proxy-port 18000
+```
+
+Default behavior also tries fallback ports automatically when 8000 is busy:
+
+- 8001
+- 8002
+- 18000
+
+## Important Frontend Rule
+
+Frontend requests must use relative API paths:
+
+```js
+fetch("/api/endpoint")
+```
+
+Do not hardcode backend host URLs in frontend code.
+
+## Notes
+
+- runner.py expects frontend project in frontend and Flask 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.
+
+## Real-Time Development Modes
+
+### Option 1: Dev Linker sharing mode (recommended)
+
+- 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.
+
+### Option 2: Full remote HMR mode (bypass Dev Linker)
+
+- 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.

devlinker-0.1.0/devlinker/__init__.py

@@ -0,0 +1,11 @@
+"""Dev Linker package."""
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "main",
+    "runner",
+    "detector",
+    "proxy",
+    "tunnel",
+]

devlinker-0.1.0/devlinker/detector.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import time
+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."""
+    try:
+        response = requests.get(f"http://127.0.0.1:{port}", timeout=timeout)
+        return response.status_code < 500
+    except requests.RequestException:
+        return False
+
+
+def is_vite_port(port: int, timeout: float = 1.0) -> bool:
+    """Return True when port looks like a Vite dev server."""
+    try:
+        response = requests.get(f"http://127.0.0.1:{port}/@vite/client", timeout=timeout)
+        if response.status_code != 200:
+            return False
+
+        content_type = response.headers.get("content-type", "").lower()
+        return "javascript" in content_type or "vite" in response.text[:400].lower()
+    except requests.RequestException:
+        return False
+
+
+def _pick_open_port(
+    candidates: Iterable[int],
+    excluded: Optional[int] = None,
+    checker=check_port,
+) -> Optional[int]:
+    for port in candidates:
+        if excluded is not None and port == excluded:
+            continue
+        if checker(port):
+            return port
+    return None
+
+
+def detect_ports(
+    frontend: Optional[int] = None,
+    backend: Optional[int] = None,
+    retries: int = 12,
+    delay_seconds: float = 1.0,
+) -> Tuple[Optional[int], Optional[int]]:
+    """Detect frontend and backend ports with retry support for slow startups."""
+    frontend_ports = [5173, 5174, 5175, 5176, 5177, 3000, 8080]
+    backend_ports = [5000, 8081]
+
+    selected_frontend = frontend
+    selected_backend = backend
+
+    for _ in range(max(retries, 1)):
+        if selected_frontend is None:
+            selected_frontend = _pick_open_port(frontend_ports, checker=is_vite_port)
+        if selected_backend is None:
+            selected_backend = _pick_open_port(backend_ports, excluded=selected_frontend)
+
+        if selected_frontend is not None and selected_backend is not None:
+            break
+
+        time.sleep(delay_seconds)
+
+    return selected_frontend, selected_backend

devlinker-0.1.0/devlinker/main.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import socket
+import time
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import click
+
+from . import __version__
+from .detector import check_port, detect_ports, is_vite_port
+from .proxy import start_proxy
+from .runner import start_servers
+from .tunnel import start_tunnel
+
+
+def _is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(1)
+        return sock.connect_ex(("127.0.0.1", port)) == 0
+
+
+def _select_proxy_port(requested_port: int) -> int:
+    if not _is_port_in_use(requested_port):
+        return requested_port
+
+    if requested_port != 8000:
+        raise click.ClickException(
+            f"Proxy port {requested_port} is already in use. Choose another with --proxy-port."
+        )
+
+    for candidate in (8001, 8002, 18000):
+        if not _is_port_in_use(candidate):
+            print(f"Port 8000 is busy. Falling back to proxy port {candidate}.")
+            return candidate
+
+    raise click.ClickException(
+        "No free proxy port found in fallback list (8000, 8001, 8002, 18000)."
+    )
+
+
+def _with_ngrok_skip_warning(url: str) -> str:
+    parts = urlsplit(url)
+    if "ngrok" not in parts.netloc:
+        return url
+
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query["ngrok-skip-browser-warning"] = "true"
+    new_query = urlencode(query)
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, new_query, parts.fragment))
+
+
+@click.command()
+@click.version_option(version=__version__, prog_name="devlinker")
+@click.option("--frontend", type=int, default=None, help="Override detected frontend port.")
+@click.option("--backend", type=int, default=None, help="Override detected backend port.")
+@click.option("--proxy-port", type=int, default=8000, show_default=True, help="Proxy listen port.")
+def cli(frontend: int | None, backend: int | None, proxy_port: int) -> None:
+    print(f"\n✨ Dev Linker v{__version__}\n")
+    print("🚀 Starting services...")
+
+    start_servers()
+
+    print("🔍 Detecting services...")
+    frontend_port, backend_port = detect_ports(frontend=frontend, backend=backend)
+
+    if frontend_port is None:
+        raise click.ClickException(
+            "Frontend not detected on common ports. Try: devlinker --frontend 5173"
+        )
+    if backend_port is None:
+        raise click.ClickException(
+            "Backend not detected on common ports. Try: devlinker --backend 5000"
+        )
+
+    if not is_vite_port(frontend_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):
+        raise click.ClickException(
+            f"Backend port {backend_port} is not reachable. Try: devlinker --backend 5000"
+        )
+
+    proxy_port = _select_proxy_port(proxy_port)
+
+    print(f"   • Frontend -> {frontend_port}")
+    print(f"   • Backend  -> {backend_port}\n")
+
+    print(f"🌐 Starting proxy on :{proxy_port}...")
+    start_proxy(frontend_port, backend_port, proxy_port=proxy_port)
+
+    # Allow Flask thread to bind before opening tunnel.
+    time.sleep(1)
+
+    print(f"\n🌐 Proxy ready at http://localhost:{proxy_port}\n")
+    try:
+        print("⚡ Opening public tunnel...")
+        provider, public_url = start_tunnel(proxy_port)
+        warning_free_url = _with_ngrok_skip_warning(public_url)
+        provider_label = "Cloudflare" if provider == "cloudflare" else "ngrok"
+        print(f"⚡ Tunnel provider: {provider_label}")
+        print("🌍 Public URL:")
+        print(f"   {warning_free_url}\n")
+        print("👉 Share this link with anyone")
+    except RuntimeError as exc:
+        print(f"⚠ Tunnel unavailable: {exc}")
+        print(f"🌐 Local proxy remains available at http://localhost:{proxy_port}")
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nDev Linker stopped.")
+
+
+if __name__ == "__main__":
+    cli()

devlinker-0.1.0/devlinker/proxy.py

@@ -0,0 +1,88 @@
+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://127.0.0.1:{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://127.0.0.1:{FRONTEND}/{path}" if path else f"http://127.0.0.1:{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-0.1.0/devlinker/runner.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+from .detector import check_port, is_vite_port
+
+
+def _read_package_json(package_path: Path) -> dict:
+    try:
+        return json.loads(package_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _frontend_command(frontend_dir: Path) -> List[str]:
+    package_json = frontend_dir / "package.json"
+    data = _read_package_json(package_json)
+    scripts = data.get("scripts", {}) if isinstance(data, dict) else {}
+
+    if "dev" in scripts:
+        return ["npm", "run", "dev"]
+    if "start" in scripts:
+        return ["npm", "start"]
+    return ["npm", "run", "dev"]
+
+
+def _resolve_command(binary: str) -> str:
+    if sys.platform.startswith("win") and not binary.lower().endswith(".cmd"):
+        win_binary = f"{binary}.cmd"
+        resolved = shutil.which(win_binary)
+        if resolved:
+            return resolved
+
+    resolved = shutil.which(binary)
+    return resolved or binary
+
+
+def start_servers(frontend_dir: str = "frontend", backend_dir: str = "backend") -> None:
+    """Launch frontend/backend when their expected directories exist."""
+    frontend_path = Path(frontend_dir)
+    backend_path = Path(backend_dir)
+
+    if frontend_path.exists() and frontend_path.is_dir():
+        if any(is_vite_port(port, timeout=0.5) for port in (5173, 5174, 5175, 5176, 5177, 3000, 8080)):
+            print("[dev-linker] Frontend appears to already be running. Skipping launch.")
+        else:
+            cmd = _frontend_command(frontend_path)
+            cmd[0] = _resolve_command(cmd[0])
+            env = os.environ.copy()
+            env["ONELINK"] = "1"
+            subprocess.Popen(cmd, cwd=frontend_path, env=env)  # noqa: S603
+    else:
+        print("[dev-linker] Skipping frontend launch (frontend/ not found).")
+
+    app_py = backend_path / "app.py"
+    if app_py.exists() and backend_path.is_dir():
+        if check_port(5000, timeout=0.5):
+            print("[dev-linker] Backend appears to already be running. Skipping launch.")
+        else:
+            subprocess.Popen([sys.executable, "app.py"], cwd=backend_path)  # noqa: S603
+    else:
+        print("[dev-linker] Skipping backend launch (backend/app.py not found).")

devlinker-0.1.0/devlinker/tunnel.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from subprocess import TimeoutExpired
+
+from pyngrok import ngrok
+from pyngrok.exception import PyngrokError
+
+_TRYCLOUDFLARE_URL = re.compile(r"https://[a-z0-9.-]+\.trycloudflare\.com", re.IGNORECASE)
+_CLOUDFLARED_PROCESSES: list[subprocess.Popen[str]] = []
+
+
+def _extract_trycloudflare_url(output: str) -> str | None:
+    match = _TRYCLOUDFLARE_URL.search(output)
+    return match.group(0) if match else None
+
+
+def _try_cloudflare(proxy_port: int, startup_timeout: float = 12.0) -> str | None:
+    cloudflared = shutil.which("cloudflared")
+    if cloudflared is None:
+        return None
+
+    command = [
+        cloudflared,
+        "tunnel",
+        "--url",
+        f"http://127.0.0.1:{proxy_port}",
+        "--no-autoupdate",
+    ]
+
+    process = subprocess.Popen(  # noqa: S603
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+
+    output = ""
+    try:
+        stdout, _ = process.communicate(timeout=startup_timeout)
+        output = stdout or ""
+    except TimeoutExpired as exc:
+        output = (exc.stdout or "") + (exc.stderr or "")
+
+    url = _extract_trycloudflare_url(output)
+    if url:
+        _CLOUDFLARED_PROCESSES.append(process)
+        return url
+
+    process.terminate()
+    return None
+
+
+def _disconnect_existing_tunnels() -> None:
+    for tunnel in ngrok.get_tunnels():
+        ngrok.disconnect(tunnel.public_url)
+
+
+def _start_ngrok_tunnel(proxy_port: int) -> str:
+    try:
+        tunnel = ngrok.connect(proxy_port)
+        return tunnel.public_url
+    except PyngrokError as exc:
+        message = str(exc).lower()
+
+        # If a prior endpoint is still active, disconnect and retry once.
+        if "already online" in message or "endpoint" in message and "online" in message:
+            try:
+                _disconnect_existing_tunnels()
+                tunnel = ngrok.connect(proxy_port)
+                return tunnel.public_url
+            except PyngrokError as retry_exc:
+                raise RuntimeError(
+                    f"Failed to start ngrok tunnel after disconnect retry: {retry_exc}"
+                ) from retry_exc
+
+        if "err_ngrok_108" in message or "simultaneous ngrok agent sessions" in message:
+            raise RuntimeError(
+                "Failed to start ngrok tunnel: account session limit reached (ERR_NGROK_108). Close other ngrok agents in https://dashboard.ngrok.com/agents or run a single agent with multiple endpoints."
+            ) from exc
+
+        if "authtoken" in message or "err_ngrok_4018" in message or "authentication failed" in message:
+            raise RuntimeError(
+                "Failed to start ngrok tunnel: missing or invalid auth token. Run 'ngrok config add-authtoken <token>' and try again."
+            ) from exc
+
+        raise RuntimeError(f"Failed to start ngrok tunnel: {exc}") from exc
+
+
+def start_tunnel(proxy_port: int = 8000) -> tuple[str, str]:
+    """Open a public tunnel and return (provider, url)."""
+    cloudflare_url = _try_cloudflare(proxy_port)
+    if cloudflare_url is not None:
+        return "cloudflare", cloudflare_url
+
+    try:
+        ngrok_url = _start_ngrok_tunnel(proxy_port)
+        return "ngrok", ngrok_url
+    except RuntimeError as ngrok_error:
+        raise RuntimeError(
+            "No tunnel available.\n"
+            "Option 1 (recommended): install cloudflared and ensure it is on PATH.\n"
+            "Option 2: configure ngrok auth token with 'ngrok config add-authtoken <token>'.\n"
+            f"Ngrok details: {ngrok_error}"
+        ) from ngrok_error

devlinker-0.1.0/devlinker.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: devlinker
+Version: 0.1.0
+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.
+
+## Features
+
+- Launches frontend and backend (when frontend and backend/app.py exist)
+- Detects common frontend/backend ports
+- Serves both through one proxy at http://localhost:8000
+- Creates a public tunnel for sharing (Cloudflare first, ngrok fallback)
+- Terminal-first workflow
+- Supports CLI version output with --version
+
+## Project Structure
+
+```text
+onelink/
+├── onelink/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── runner.py
+│   ├── detector.py
+│   ├── proxy.py
+│   └── tunnel.py
+├── setup.py
+├── README.md
+└── requirements.txt
+```
+
+## Install
+
+For local development:
+
+```bash
+pip install .
+```
+
+After publishing to PyPI:
+
+```bash
+pip install dev-linker
+```
+
+## Run
+
+```bash
+devlinker
+```
+
+Typical startup output:
+
+```text
+✨ Dev Linker v0.1.0
+
+🚀 Starting services...
+🔍 Detecting services...
+	• Frontend -> 5173
+	• Backend  -> 5000
+
+🌐 Proxy ready at http://localhost:8000
+
+⚡ Tunnel provider: Cloudflare
+🌍 Public URL:
+	https://xxxx.trycloudflare.com
+
+👉 Share this link with anyone
+```
+
+Version check:
+
+```bash
+devlinker --version
+```
+
+Optional overrides:
+
+```bash
+devlinker --frontend 5173 --backend 5000
+```
+
+If port 8000 is already in use:
+
+```bash
+devlinker --frontend 5173 --backend 5000 --proxy-port 18000
+```
+
+Default behavior also tries fallback ports automatically when 8000 is busy:
+
+- 8001
+- 8002
+- 18000
+
+## Important Frontend Rule
+
+Frontend requests must use relative API paths:
+
+```js
+fetch("/api/endpoint")
+```
+
+Do not hardcode backend host URLs in frontend code.
+
+## Notes
+
+- runner.py expects frontend project in frontend and Flask 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.
+
+## Real-Time Development Modes
+
+### Option 1: Dev Linker sharing mode (recommended)
+
+- 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.
+
+### Option 2: Full remote HMR mode (bypass Dev Linker)
+
+- 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.

devlinker-0.1.0/devlinker.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+devlinker/__init__.py
+devlinker/detector.py
+devlinker/main.py
+devlinker/proxy.py
+devlinker/runner.py
+devlinker/tunnel.py
+devlinker.egg-info/PKG-INFO
+devlinker.egg-info/SOURCES.txt
+devlinker.egg-info/dependency_links.txt
+devlinker.egg-info/entry_points.txt
+devlinker.egg-info/requires.txt
+devlinker.egg-info/top_level.txt

devlinker-0.1.0/devlinker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devlinker-0.1.0/devlinker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devlinker = devlinker.main:cli

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

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

devlinker-0.1.0/devlinker.egg-info/top_level.txt

@@ -0,0 +1 @@
+devlinker

devlinker-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devlinker"
+version = "0.1.0"
+description = "AI-powered linking and automation tool"
+authors = [
+    { name = "Mani", email = "mani1028@users.noreply.github.com" }
+]
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "click",
+    "flask",
+    "pyngrok",
+    "requests",
+]
+
+[project.scripts]
+devlinker = "devlinker.main:cli"
+
+[tool.setuptools.packages.find]
+include = ["devlinker*"]

devlinker-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

devlinker-0.1.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()