prosoon-pf 0.1.0__tar.gz

prosoon_pf-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: prosoon-pf
+Version: 0.1.0
+Summary: Quick-start a local HTTP server and optionally expose it via a Cloudflare tunnel.
+Author: Prasun Banerjee
+License: MIT
+Keywords: http,server,cloudflare,tunnel,share,cli
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# prosoon-pf
+
+Quick-start a local HTTP server, and optionally expose it to the internet with a
+Cloudflare quick tunnel — in one command. Linux only for now.
+
+## Install
+
+```bash
+pip install prosoon-pf
+```
+
+## Usage
+
+Serve the current directory locally on port 8000:
+
+```bash
+prosoon-pf
+```
+
+Pick a port and a directory:
+
+```bash
+prosoon-pf 9000 --dir ~/share
+```
+
+Expose it publicly (prints a `https://….trycloudflare.com` link):
+
+```bash
+prosoon-pf 8000 --public
+```
+
+If `cloudflared` isn't installed, `--public` mode will ask before installing it.
+
+## Public mode is public
+
+When you use `--public`, **every file in the served directory becomes
+downloadable by anyone with the link** for as long as the command runs. The tool
+shows you the directory contents and asks for confirmation first. Don't serve a
+folder that contains passwords, keys, `.ovpn` files, or anything private.
+
+## License
+
+MIT

prosoon_pf-0.1.0/README.md

@@ -0,0 +1,43 @@
+# prosoon-pf
+
+Quick-start a local HTTP server, and optionally expose it to the internet with a
+Cloudflare quick tunnel — in one command. Linux only for now.
+
+## Install
+
+```bash
+pip install prosoon-pf
+```
+
+## Usage
+
+Serve the current directory locally on port 8000:
+
+```bash
+prosoon-pf
+```
+
+Pick a port and a directory:
+
+```bash
+prosoon-pf 9000 --dir ~/share
+```
+
+Expose it publicly (prints a `https://….trycloudflare.com` link):
+
+```bash
+prosoon-pf 8000 --public
+```
+
+If `cloudflared` isn't installed, `--public` mode will ask before installing it.
+
+## Public mode is public
+
+When you use `--public`, **every file in the served directory becomes
+downloadable by anyone with the link** for as long as the command runs. The tool
+shows you the directory contents and asks for confirmation first. Don't serve a
+folder that contains passwords, keys, `.ovpn` files, or anything private.
+
+## License
+
+MIT

prosoon_pf-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prosoon-pf"
+version = "0.1.0"
+description = "Quick-start a local HTTP server and optionally expose it via a Cloudflare tunnel."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Prasun Banerjee" }]
+keywords = ["http", "server", "cloudflare", "tunnel", "share", "cli"]
+classifiers = [
+    "Environment :: Console",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+# Homepage = "N/A"
+
+# This is what makes `prosoon-pf` a runnable command after install.
+# Format: command-name = "import.path:function"
+[project.scripts]
+prosoon-pf = "prosoon_pf.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

prosoon_pf-0.1.0/setup.cfg

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

prosoon_pf-0.1.0/src/prosoon_pf/__init__.py

@@ -0,0 +1,3 @@
+"""prosoon-pf: quick-start a local HTTP server and optionally expose it via a Cloudflare tunnel."""
+
+__version__ = "0.1.0"

prosoon_pf-0.1.0/src/prosoon_pf/cli.py

@@ -0,0 +1,240 @@
+"""
+prosoon-pf — quick-start an HTTP server and optionally expose it publicly.
+
+What it automates (the commands you'd otherwise type by hand):
+    1. python3 -m http.server <port>
+    2. ensure cloudflared is installed (check -> ask consent -> install)
+    3. cloudflared tunnel --url http://localhost:<port>
+
+Design notes for future-you:
+    - We use subprocess to run the real programs rather than reimplementing
+      them. http.server and cloudflared already exist and are battle-tested;
+      our job is just orchestration.
+    - We never run a privileged install without asking. Auto-sudo from a pip
+      package is exactly what makes a package look malicious.
+"""
+
+import argparse
+import http.server
+import os
+import re
+import shutil
+import signal
+import socketserver
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+from . import __version__
+
+
+# ----------------------------------------------------------------------------
+# Step 0: environment checks
+# ----------------------------------------------------------------------------
+
+def check_python_version(minimum=(3, 8)):
+    """Refuse to run on ancient Python. We rely on f-strings and pathlib,
+    so anything below 3.8 is not worth supporting."""
+    if sys.version_info < minimum:
+        need = ".".join(str(n) for n in minimum)
+        have = ".".join(str(n) for n in sys.version_info[:3])
+        sys.exit(f"[!] Python {need}+ required, but you're on {have}.")
+
+
+def cloudflared_path():
+    """Return the path to cloudflared if it's on PATH, else None.
+    shutil.which is the Python equivalent of the shell `which` command."""
+    return shutil.which("cloudflared")
+
+
+# ----------------------------------------------------------------------------
+# Step 1: the local server
+# ----------------------------------------------------------------------------
+
+def serve_directory(port, directory):
+    """Start http.server bound to the given port, serving `directory`.
+
+    We run this in-process (not via subprocess) so we control the lifecycle
+    cleanly and can shut it down on Ctrl+C. ThreadingHTTPServer handles
+    multiple requests without blocking, which matters when a browser opens
+    several connections at once.
+    """
+    directory = str(Path(directory).resolve())
+
+    # A handler factory that serves from `directory` instead of cwd.
+    def handler(*args, **kwargs):
+        return http.server.SimpleHTTPRequestHandler(
+            *args, directory=directory, **kwargs
+        )
+
+    # allow_reuse_address avoids "Address already in use" on quick restarts.
+    socketserver.ThreadingTCPServer.allow_reuse_address = True
+    httpd = socketserver.ThreadingTCPServer(("0.0.0.0", port), handler)
+
+    # Run the blocking serve loop on a background thread so main() can
+    # continue (e.g. to start the tunnel) and still catch Ctrl+C.
+    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    thread.start()
+    return httpd
+
+
+# ----------------------------------------------------------------------------
+# Step 2: ensure cloudflared exists
+# ----------------------------------------------------------------------------
+
+INSTALL_HINT = (
+    "Install cloudflared manually, then re-run:\n"
+    "    wget https://github.com/cloudflare/cloudflared/releases/latest/"
+    "download/cloudflared-linux-amd64.deb\n"
+    "    sudo dpkg -i cloudflared-linux-amd64.deb"
+)
+
+
+def ensure_cloudflared(assume_yes=False):
+    """Return a path to cloudflared, installing it (with consent) if missing.
+
+    Linux-only for now. We ask before doing anything that needs sudo.
+    """
+    existing = cloudflared_path()
+    if existing:
+        return existing
+
+    print("[!] cloudflared is not installed.")
+    if not assume_yes:
+        answer = input("    Install it now? (needs sudo) [y/N]: ").strip().lower()
+        if answer not in ("y", "yes"):
+            sys.exit("[!] Cannot create a public tunnel without cloudflared.\n" + INSTALL_HINT)
+
+    arch = os.uname().machine
+    # Map uname arch -> the .deb Cloudflare publishes.
+    deb_arch = {"x86_64": "amd64", "aarch64": "arm64", "armv7l": "arm"}.get(arch)
+    if deb_arch is None:
+        sys.exit(f"[!] Unsupported architecture: {arch}.\n" + INSTALL_HINT)
+
+    url = (
+        f"https://github.com/cloudflare/cloudflared/releases/latest/"
+        f"download/cloudflared-linux-{deb_arch}.deb"
+    )
+    deb = f"/tmp/cloudflared-{deb_arch}.deb"
+
+    try:
+        print(f"[*] Downloading {url}")
+        subprocess.run(["wget", "-qO", deb, url], check=True)
+        print("[*] Installing (you may be prompted for your sudo password)...")
+        subprocess.run(["sudo", "dpkg", "-i", deb], check=True)
+    except subprocess.CalledProcessError as exc:
+        sys.exit(f"[!] Install failed ({exc}).\n" + INSTALL_HINT)
+    finally:
+        # Clean up the downloaded .deb regardless of outcome.
+        try:
+            os.remove(deb)
+        except OSError:
+            pass
+
+    path = cloudflared_path()
+    if not path:
+        sys.exit("[!] cloudflared still not found after install.\n" + INSTALL_HINT)
+    return path
+
+
+# ----------------------------------------------------------------------------
+# Step 3: the tunnel
+# ----------------------------------------------------------------------------
+
+TUNNEL_URL_RE = re.compile(r"https://[-\w]+\.trycloudflare\.com")
+
+
+def start_tunnel(cloudflared, port):
+    """Launch a cloudflared quick tunnel and stream its output, printing the
+    public URL prominently when it appears.
+
+    cloudflared writes its status (including the URL) to stderr, so we merge
+    stderr into stdout and read line by line.
+    """
+    proc = subprocess.Popen(
+        [cloudflared, "tunnel", "--url", f"http://localhost:{port}"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+    )
+
+    printed = False
+    for line in proc.stdout:
+        match = TUNNEL_URL_RE.search(line)
+        if match and not printed:
+            url = match.group(0)
+            print("\n" + "=" * 56)
+            print(f"  Public URL:  {url}")
+            print("=" * 56 + "\n")
+            printed = True
+        # Uncomment to see raw cloudflared logs:
+        # print(line, end="")
+    return proc
+
+
+# ----------------------------------------------------------------------------
+# Wiring it together
+# ----------------------------------------------------------------------------
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="prosoon-pf",
+        description="Quick-start a local HTTP server, optionally exposed via Cloudflare.",
+    )
+    parser.add_argument("port", nargs="?", type=int, default=8000,
+                        help="Port to serve on (default: 8000).")
+    parser.add_argument("-d", "--dir", default=".",
+                        help="Directory to serve (default: current dir).")
+    parser.add_argument("--public", action="store_true",
+                        help="Expose the server publicly via a Cloudflare tunnel.")
+    parser.add_argument("-y", "--yes", action="store_true",
+                        help="Skip the cloudflared install confirmation.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    args = parser.parse_args(argv)
+
+    check_python_version()
+
+    serve_dir = Path(args.dir).resolve()
+
+    # The safety confirmation for public mode. This is the whole reason the
+    # tool is trustworthy: the user sees exactly what they're about to expose.
+    if args.public:
+        print(f"[!] PUBLIC mode: everything in  {serve_dir}  will be reachable")
+        print("    by anyone with the link, for as long as this runs.")
+        try:
+            entries = sorted(p.name for p in serve_dir.iterdir())
+        except OSError:
+            entries = []
+        if entries:
+            preview = ", ".join(entries[:8]) + ("  ..." if len(entries) > 8 else "")
+            print(f"    Contents: {preview}")
+        if not args.yes:
+            confirm = input("    Expose this directory publicly? [y/N]: ").strip().lower()
+            if confirm not in ("y", "yes"):
+                sys.exit("[*] Aborted. Nothing was exposed.")
+
+    httpd = serve_directory(args.port, serve_dir)
+    print(f"[*] Serving {serve_dir} at http://localhost:{args.port}")
+
+    tunnel_proc = None
+    try:
+        if args.public:
+            cf = ensure_cloudflared(assume_yes=args.yes)
+            print("[*] Starting Cloudflare tunnel...")
+            tunnel_proc = start_tunnel(cf, args.port)  # blocks, streaming logs
+        else:
+            print("[*] Local mode. Press Ctrl+C to stop.")
+            signal.pause()  # sleep until a signal (Ctrl+C) arrives
+    except KeyboardInterrupt:
+        print("\n[*] Shutting down...")
+    finally:
+        if tunnel_proc and tunnel_proc.poll() is None:
+            tunnel_proc.terminate()
+        httpd.shutdown()
+        print("[*] Stopped.")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: prosoon-pf
+Version: 0.1.0
+Summary: Quick-start a local HTTP server and optionally expose it via a Cloudflare tunnel.
+Author: Prasun Banerjee
+License: MIT
+Keywords: http,server,cloudflare,tunnel,share,cli
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# prosoon-pf
+
+Quick-start a local HTTP server, and optionally expose it to the internet with a
+Cloudflare quick tunnel — in one command. Linux only for now.
+
+## Install
+
+```bash
+pip install prosoon-pf
+```
+
+## Usage
+
+Serve the current directory locally on port 8000:
+
+```bash
+prosoon-pf
+```
+
+Pick a port and a directory:
+
+```bash
+prosoon-pf 9000 --dir ~/share
+```
+
+Expose it publicly (prints a `https://….trycloudflare.com` link):
+
+```bash
+prosoon-pf 8000 --public
+```
+
+If `cloudflared` isn't installed, `--public` mode will ask before installing it.
+
+## Public mode is public
+
+When you use `--public`, **every file in the served directory becomes
+downloadable by anyone with the link** for as long as the command runs. The tool
+shows you the directory contents and asks for confirmation first. Don't serve a
+folder that contains passwords, keys, `.ovpn` files, or anything private.
+
+## License
+
+MIT

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

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/prosoon_pf/__init__.py
+src/prosoon_pf/cli.py
+src/prosoon_pf.egg-info/PKG-INFO
+src/prosoon_pf.egg-info/SOURCES.txt
+src/prosoon_pf.egg-info/dependency_links.txt
+src/prosoon_pf.egg-info/entry_points.txt
+src/prosoon_pf.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+prosoon-pf = prosoon_pf.cli:main

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

@@ -0,0 +1 @@
+prosoon_pf