tunnelvt 0.1.0__tar.gz

tunnelvt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vintech IDs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tunnelvt-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tunnelvt
+Version: 0.1.0
+Summary: Simple tunneling — expose local apps behind Cloudflare. No login.
+License: MIT
+Project-URL: Homepage, https://github.com/vintechids/tunnelvt-py
+Project-URL: Repository, https://github.com/vintechids/tunnelvt-py
+Keywords: tunnel,ngrok,localhost,expose,webhook,proxy,cloudflare
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websocket-client>=1.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# tunnelvt — Python
+
+Simple tunneling client in Python. No login. Expose local apps at `domain/<device>/<app>`.
+
+## Install
+
+```bash
+pip install tunnelvt
+```
+
+Requires Python ≥ 3.9.
+
+## Usage
+
+```bash
+tunnelvt -s https://tunnel.example.com -a myapp -p 3000
+```
+
+Output:
+```
+[tunnelvt] connected — a1b2c3d4e5f6g7h8/myapp -> localhost:3000
+```
+
+Your app is now at:
+
+```
+https://tunnel.example.com/a1b2c3d4e5f6g7h8/myapp/
+```
+
+### Custom device ID
+
+```bash
+tunnelvt -s https://tunnel.example.com -d my-laptop -a api -p 8080
+# → https://tunnel.example.com/my-laptop/api/
+```
+
+### Library usage
+
+```python
+from tunnelvt import TunnelVT
+
+client = TunnelVT(
+    server_url="https://tunnel.example.com",
+    app="myapp",
+    port=3000,
+)
+client.connect()  # blocks
+```
+
+## License
+
+MIT

tunnelvt-0.1.0/README.md

@@ -0,0 +1,52 @@
+# tunnelvt — Python
+
+Simple tunneling client in Python. No login. Expose local apps at `domain/<device>/<app>`.
+
+## Install
+
+```bash
+pip install tunnelvt
+```
+
+Requires Python ≥ 3.9.
+
+## Usage
+
+```bash
+tunnelvt -s https://tunnel.example.com -a myapp -p 3000
+```
+
+Output:
+```
+[tunnelvt] connected — a1b2c3d4e5f6g7h8/myapp -> localhost:3000
+```
+
+Your app is now at:
+
+```
+https://tunnel.example.com/a1b2c3d4e5f6g7h8/myapp/
+```
+
+### Custom device ID
+
+```bash
+tunnelvt -s https://tunnel.example.com -d my-laptop -a api -p 8080
+# → https://tunnel.example.com/my-laptop/api/
+```
+
+### Library usage
+
+```python
+from tunnelvt import TunnelVT
+
+client = TunnelVT(
+    server_url="https://tunnel.example.com",
+    app="myapp",
+    port=3000,
+)
+client.connect()  # blocks
+```
+
+## License
+
+MIT

tunnelvt-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tunnelvt"
+version = "0.1.0"
+description = "Simple tunneling — expose local apps behind Cloudflare. No login."
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.9"
+keywords = ["tunnel", "ngrok", "localhost", "expose", "webhook", "proxy", "cloudflare"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: Proxy Servers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "websocket-client>=1.7",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-cov"]
+
+[project.urls]
+Homepage = "https://github.com/vintechids/tunnelvt-py"
+Repository = "https://github.com/vintechids/tunnelvt-py"
+
+[project.scripts]
+tunnelvt = "tunnelvt.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

tunnelvt-0.1.0/setup.cfg

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

tunnelvt-0.1.0/src/tunnelvt/__init__.py

@@ -0,0 +1,9 @@
+"""tunnelvt — Simple tunneling. No login.
+
+Expose local apps at ``domain/<device>/<app>`` through a tunnelvt server.
+"""
+
+from .client import TunnelVT
+
+__version__ = "0.1.0"
+__all__ = ["TunnelVT"]

tunnelvt-0.1.0/src/tunnelvt/cli.py

@@ -0,0 +1,39 @@
+"""CLI entry point for ``tunnelvt``."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+from .client import TunnelVT
+
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(
+        prog="tunnelvt",
+        description="Expose a local port through gotunnel. No login needed.",
+    )
+    p.add_argument("-a", "--app", required=True, help="app name for this tunnel")
+    p.add_argument("-p", "--port", type=int, required=True, help="local port to expose")
+    p.add_argument("-v", "--verbose", action="store_true", help="enable debug logging")
+    args = p.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="[tunnelvt] %(levelname)s %(message)s",
+    )
+
+    client = TunnelVT(app=args.app, port=args.port)
+    try:
+        client.connect()
+    except KeyboardInterrupt:
+        print("", file=sys.stderr)
+        sys.exit(0)
+    except Exception as exc:
+        logging.error("%s", exc)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tunnelvt-0.1.0/src/tunnelvt/client.py

@@ -0,0 +1,190 @@
+"""WebSocket tunnel client — username+password → JWT, auto-refresh.
+
+First run prompts for username+password. Gets JWT from /_tunnel/auth.
+Saves to ~/.tunnelvt.json. JWT expires 7 days — auto-refreshes with saved creds.
+"""
+
+from __future__ import annotations
+
+import base64
+import getpass
+import json
+import logging
+import sys
+import threading
+from http.client import HTTPConnection, HTTPResponse
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse, urlunparse
+from urllib.request import Request, urlopen
+
+import websocket
+
+logger = logging.getLogger("tunnelvt")
+
+DEFAULT_SERVER = "https://gotunnel.vinstechid.com"
+VERSION = "1.0.0"
+BUILD_HASH = "dev"
+
+HOP_BY_HOP = {
+    "connection", "keep-alive", "proxy-authenticate",
+    "proxy-authorization", "te", "trailers",
+    "transfer-encoding", "upgrade",
+}
+MAX_BODY = 10 * 1024 * 1024
+
+
+def _identity_file() -> Path:
+    return Path.home() / ".tunnelvt.json"
+
+
+def _build_ws_url(server_url: str) -> str:
+    p = urlparse(server_url)
+    scheme = "wss" if p.scheme in ("https", "wss") else "ws"
+    return urlunparse((scheme, p.netloc, "/_tunnel/connect", "", "", ""))
+
+
+def _fetch_jwt(server_url: str, username: str, password: str) -> str:
+    data = json.dumps({"username": username, "password": password}).encode()
+    req = Request(server_url + "/_tunnel/auth", data=data,
+                  headers={"Content-Type": "application/json"})
+    with urlopen(req, timeout=10) as resp:
+        if resp.status != 200:
+            raise RuntimeError(resp.read().decode())
+        return json.loads(resp.read())["jwt"]
+
+
+class TunnelVT:
+    """Connect to gotunnel and expose a local port."""
+
+    def __init__(self, app: str = "", port: int = 0) -> None:
+        self.app = app
+        self.port = port
+        self._username = ""
+        self._password = ""
+        self._jwt = ""
+        self._ws: websocket.WebSocket | None = None
+
+    def connect(self) -> None:
+        while True:
+            self._ensure_jwt()
+            try:
+                self._connect_ws()
+                return
+            except Exception as e:
+                if "invalid or expired" in str(e):
+                    self._jwt = ""
+                    continue
+                raise
+
+    def _connect_ws(self) -> None:
+        ws_url = _build_ws_url(DEFAULT_SERVER)
+        self._ws = websocket.create_connection(ws_url, timeout=30)
+        try:
+            self._register()
+            self._read_loop()
+        finally:
+            self._ws.close()
+
+    def _ensure_jwt(self) -> None:
+        idf = _identity_file()
+        if idf.exists():
+            try:
+                data = json.loads(idf.read_text())
+                if data.get("username"):
+                    self._username = data["username"]
+                    self._password = data.get("password", "")
+                    self._jwt = data.get("jwt", "")
+            except Exception:
+                pass
+
+        if not self._username:
+            self._username = input("Username: ").strip()
+            if not self._username:
+                raise RuntimeError("username required")
+            self._password = getpass.getpass("Password: ").strip()
+            if not self._password:
+                raise RuntimeError("password required")
+
+        if not self._jwt:
+            try:
+                self._jwt = _fetch_jwt(DEFAULT_SERVER, self._username, self._password)
+            except Exception:
+                idf.unlink(missing_ok=True)
+                self._username = ""
+                self._password = ""
+                raise
+
+        idf.write_text(json.dumps({
+            "username": self._username,
+            "password": self._password,
+            "jwt": self._jwt,
+        }))
+
+    def _register(self) -> None:
+        msg = {
+            "type": "register",
+            "jwt": self._jwt,
+            "app": self.app,
+            "port": self.port,
+            "version": VERSION,
+            "vhash": BUILD_HASH,
+        }
+        self._send(msg)
+        ack = self._recv()
+        if ack is None:
+            raise RuntimeError("connection closed")
+        if ack.get("type") == "error":
+            raise RuntimeError(ack.get("error", "server rejected"))
+        print(f"https://gotunnel.vinstechid.com/{self._username}/{self.app}/")
+        logger.info("connected — %s/%s -> localhost:%d", self._username, self.app, self.port)
+
+    def _read_loop(self) -> None:
+        while True:
+            msg = self._recv()
+            if msg is None:
+                break
+            if msg.get("type") == "request":
+                t = threading.Thread(target=self._handle_request, args=(msg,), daemon=True)
+                t.start()
+
+    def _handle_request(self, msg: dict[str, Any]) -> None:
+        self._send(self._do_local(msg))
+
+    def _do_local(self, msg: dict[str, Any]) -> dict[str, Any]:
+        req_id = msg.get("id", "")
+        def err(e: str) -> dict[str, Any]:
+            return {"type": "error", "id": req_id, "error": e}
+        try:
+            body = base64.b64decode(msg.get("body", ""))
+        except Exception:
+            return err("invalid body encoding")
+        conn = HTTPConnection("localhost", self.port, timeout=25)
+        try:
+            headers = {k: v for k, v in msg.get("headers", {}).items()
+                       if k.lower() not in HOP_BY_HOP}
+            conn.request(method=msg.get("method", "GET"), url=msg.get("path", "/"),
+                         body=body if body else None, headers=headers)
+            resp: HTTPResponse = conn.getresponse()
+            resp_body = resp.read(MAX_BODY)
+            return {
+                "type": "response", "id": req_id, "status": resp.status,
+                "headers": dict(resp.getheaders()),
+                "body": base64.b64encode(resp_body).decode(),
+            }
+        except Exception as exc:
+            return err(f"local request failed: {exc}")
+        finally:
+            conn.close()
+
+    def _send(self, msg: dict[str, Any]) -> None:
+        if self._ws:
+            self._ws.send(json.dumps(msg))
+
+    def _recv(self) -> dict[str, Any] | None:
+        if self._ws is None:
+            return None
+        try:
+            return json.loads(self._ws.recv())
+        except websocket.WebSocketConnectionClosedException:
+            return None

tunnelvt-0.1.0/src/tunnelvt.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tunnelvt
+Version: 0.1.0
+Summary: Simple tunneling — expose local apps behind Cloudflare. No login.
+License: MIT
+Project-URL: Homepage, https://github.com/vintechids/tunnelvt-py
+Project-URL: Repository, https://github.com/vintechids/tunnelvt-py
+Keywords: tunnel,ngrok,localhost,expose,webhook,proxy,cloudflare
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websocket-client>=1.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# tunnelvt — Python
+
+Simple tunneling client in Python. No login. Expose local apps at `domain/<device>/<app>`.
+
+## Install
+
+```bash
+pip install tunnelvt
+```
+
+Requires Python ≥ 3.9.
+
+## Usage
+
+```bash
+tunnelvt -s https://tunnel.example.com -a myapp -p 3000
+```
+
+Output:
+```
+[tunnelvt] connected — a1b2c3d4e5f6g7h8/myapp -> localhost:3000
+```
+
+Your app is now at:
+
+```
+https://tunnel.example.com/a1b2c3d4e5f6g7h8/myapp/
+```
+
+### Custom device ID
+
+```bash
+tunnelvt -s https://tunnel.example.com -d my-laptop -a api -p 8080
+# → https://tunnel.example.com/my-laptop/api/
+```
+
+### Library usage
+
+```python
+from tunnelvt import TunnelVT
+
+client = TunnelVT(
+    server_url="https://tunnel.example.com",
+    app="myapp",
+    port=3000,
+)
+client.connect()  # blocks
+```
+
+## License
+
+MIT

tunnelvt-0.1.0/src/tunnelvt.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/tunnelvt/__init__.py
+src/tunnelvt/cli.py
+src/tunnelvt/client.py
+src/tunnelvt.egg-info/PKG-INFO
+src/tunnelvt.egg-info/SOURCES.txt
+src/tunnelvt.egg-info/dependency_links.txt
+src/tunnelvt.egg-info/entry_points.txt
+src/tunnelvt.egg-info/requires.txt
+src/tunnelvt.egg-info/top_level.txt

tunnelvt-0.1.0/src/tunnelvt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tunnelvt-0.1.0/src/tunnelvt.egg-info/entry_points.txt

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

tunnelvt-0.1.0/src/tunnelvt.egg-info/requires.txt

@@ -0,0 +1,5 @@
+websocket-client>=1.7
+
+[dev]
+pytest>=8
+pytest-cov

tunnelvt-0.1.0/src/tunnelvt.egg-info/top_level.txt

@@ -0,0 +1 @@
+tunnelvt