funnel-cli 0.1.0__tar.gz

funnel_cli-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+uv.lock
+__pycache__
+.env
+dist/

funnel_cli-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

funnel_cli-0.1.0/Justfile

@@ -0,0 +1,24 @@
+DROPLET_IP := "165.22.130.48"
+USER := "root@" + DROPLET_IP
+
+build-client:
+    rm -rf dist/
+    uv build
+
+publish-client: build-client
+    uv publish
+
+login:
+   ssh -i ~/.ssh/funnel {{USER}}
+
+sync:
+    rsync -e "ssh -i ~/.ssh/funnel" -r . root@165.22.130.48:~/funnel
+
+configure-ssl:
+    ssh {{USER}} " \
+    sudo apt update && \
+    sudo apt install -y certbot python3-certbot-dns-digitalocean && \
+    echo 'dns_digitalocean_token=$DO_API_TOKEN' > /root/certbot-creds.ini && \
+    chmod go-rwx ~/certbot-creds.ini && \
+    sudo certbot certonly -v --dns-digitalocean --dns-digitalocean-credentials ~/certbot-creds.ini -d funnel.delivery -d '*.funnel.delivery' --non-interactive --agree-tos -m aydinschwa@gmail.com
+    "

funnel_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aydin
+
+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.

funnel_cli-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: funnel-cli
+Version: 0.1.0
+Summary: Expose your local services to the internet
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: textual

funnel_cli-0.1.0/client/client.py

@@ -0,0 +1,289 @@
+import argparse
+import asyncio
+from datetime import datetime
+
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.reactive import reactive
+from textual.widgets import DataTable, Static
+
+from shared.lib import (
+    FunnelMessage,
+    FunnelMessageType,
+    forward,
+    read_message,
+    write_message,
+)
+
+HOST = "funnel.delivery"
+PORT = 8080
+DEFAULT_LOCAL_PORT = 8000
+
+METHOD_COLORS: dict[str, str] = {
+    "GET": "green",
+    "POST": "#3b82f6",
+    "PUT": "yellow",
+    "DELETE": "red",
+    "PATCH": "cyan",
+    "HEAD": "magenta",
+    "OPTIONS": "dim white",
+}
+
+
+class TunnelInfo(Static):
+    """Header panel showing tunnel URL, forwarding target, and connection status."""
+
+    subdomain = reactive("")
+    local_port = reactive(DEFAULT_LOCAL_PORT)
+    connected = reactive(False)
+
+    waiting_for_local = reactive(False)
+
+    def render(self) -> str:
+        if self.waiting_for_local:
+            status = "[yellow]● Waiting for local service…[/yellow]"
+            url = f"[dim]nothing on localhost:{self.local_port}[/dim]"
+        elif not self.subdomain:
+            status = "[yellow]● Connecting…[/yellow]"
+            url = "[dim]waiting for server…[/dim]"
+        elif self.connected:
+            status = "[green]● Connected[/green]"
+            url = f"[bold]https://{self.subdomain}.{HOST}[/bold]"
+        else:
+            status = "[red]● Disconnected[/red]"
+            url = f"[dim]{self.subdomain}.{HOST}[/dim]"
+
+        return (
+            f"  Tunnel   {url}\n"
+            f"  Forward  [bold]http://localhost:{self.local_port}[/bold]\n"
+            f"  Status   {status}"
+        )
+
+
+class RequestCount(Static):
+    """Section header that tracks total number of forwarded requests."""
+
+    count = reactive(0)
+
+    def render(self) -> str:
+        return f" Requests ({self.count} total)"
+
+
+class FunnelApp(App):
+    """Funnel tunnel client TUI."""
+
+    TITLE = "Funnel"
+    ENABLE_COMMAND_PALETTE = False
+
+    CSS = """
+    #tunnel-info {
+        height: auto;
+        padding: 1 0;
+        background: $surface;
+        border-bottom: solid $primary;
+    }
+
+    #request-count {
+        height: 1;
+        background: $boost;
+        text-style: bold;
+        color: $text-muted;
+    }
+
+    #request-table {
+        height: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        subdomain: str | None = None,
+        local_port: int = DEFAULT_LOCAL_PORT,
+    ):
+        super().__init__()
+        self._subdomain_request = subdomain
+        self._local_port = local_port
+        self._control_writer: asyncio.StreamWriter | None = None
+
+    def compose(self) -> ComposeResult:
+        info = TunnelInfo(id="tunnel-info")
+        info.local_port = self._local_port
+        yield info
+        yield RequestCount(id="request-count")
+        yield DataTable(id="request-table")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#request-table", DataTable)
+        table.add_columns("Time", "Method", "Path", "ID")
+        table.cursor_type = "none"
+        self._run_tunnel()
+        self._monitor_local_service()
+
+    @work(exclusive=True)
+    async def _run_tunnel(self) -> None:
+        """Background worker managing the tunnel control connection."""
+        info = self.query_one("#tunnel-info", TunnelInfo)
+        try:
+            await self._wait_for_local_service(info)
+            reader, writer = await asyncio.open_connection(HOST, PORT)
+            self._control_writer = writer
+
+            await write_message(
+                writer,
+                FunnelMessage(
+                    type=FunnelMessageType.CONNECT,
+                    proxy_subdomain=self._subdomain_request,
+                ),
+            )
+
+            accept = await read_message(reader)
+            if accept.type == FunnelMessageType.ACCEPT:
+                info.subdomain = accept.proxy_subdomain or ""
+                info.connected = True
+
+            while True:
+                msg = await read_message(reader)
+                if msg.type == FunnelMessageType.HEARTBEAT:
+                    continue
+                elif msg.type == FunnelMessageType.INCOMING:
+                    self._record_request(msg)
+
+        except Exception:
+            info.connected = False
+
+    def _record_request(self, message: FunnelMessage) -> None:
+        """Parse an INCOMING message and append it to the request table."""
+        method, path = "???", "/"
+        if message.request_line:
+            parts = message.request_line.split()
+            if len(parts) >= 2:
+                method, path = parts[0], parts[1]
+
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        color = METHOD_COLORS.get(method.upper(), "white")
+        styled_method = Text(f" {method:<7}", style=f"bold {color}")
+        conn_short = (message.connection_id or "")[:8]
+
+        table = self.query_one("#request-table", DataTable)
+        table.add_row(timestamp, styled_method, path, conn_short)
+        table.scroll_end(animate=False)
+
+        counter = self.query_one("#request-count", RequestCount)
+        counter.count += 1
+
+        if message.connection_id:
+            asyncio.create_task(self._handle_data_connection(message.connection_id))
+
+    async def _check_local_port(self) -> bool:
+        """Return True if something is listening on the local forwarding port."""
+        try:
+            _, w = await asyncio.open_connection("localhost", self._local_port)
+            w.close()
+            await w.wait_closed()
+            return True
+        except OSError:
+            return False
+
+    async def _wait_for_local_service(self, info: TunnelInfo) -> None:
+        """Block until something is listening on the local forwarding port."""
+        while not await self._check_local_port():
+            info.waiting_for_local = True
+            await asyncio.sleep(2)
+        info.waiting_for_local = False
+
+    @work(exclusive=True, group="local_monitor")
+    async def _monitor_local_service(self) -> None:
+        """Periodically check that the local service is still reachable."""
+        info = self.query_one("#tunnel-info", TunnelInfo)
+        while True:
+            await asyncio.sleep(5)
+            alive = await self._check_local_port()
+            info.waiting_for_local = not alive
+
+    async def _handle_data_connection(self, connection_id: str) -> None:
+        """Open a data connection to forward traffic for a single request."""
+        try:
+            local_r, local_w = await asyncio.open_connection(
+                "localhost", self._local_port
+            )
+            remote_r, remote_w = await asyncio.open_connection(HOST, PORT)
+
+            await write_message(
+                remote_w,
+                FunnelMessage(
+                    type=FunnelMessageType.RECEIVE,
+                    connection_id=connection_id,
+                ),
+            )
+
+            await asyncio.gather(
+                forward(remote_r, local_w),
+                forward(local_r, remote_w),
+            )
+        except Exception:
+            pass
+
+    def action_help_quit(self) -> None:
+        self.exit()
+
+
+HELP_TEXT = """\
+\033[1mfunnel\033[0m - expose your local services to the internet
+
+\033[1mUSAGE\033[0m
+    funnel [OPTIONS] <port>
+
+\033[1mEXAMPLES\033[0m
+    funnel 3000
+    funnel 8080 --subdomain my-app
+
+\033[1mOPTIONS\033[0m
+    -s, --subdomain <name>   Request a specific subdomain (default: random)
+    -h, --help               Show this help message
+
+\033[1mHOW IT WORKS\033[0m
+    Funnel opens a tunnel to funnel.delivery and assigns you a public
+    URL like https://<subdomain>.funnel.delivery. Any HTTP traffic to
+    that URL is forwarded to your local service on the given port.
+
+    Press Ctrl+C to disconnect.
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        usage="funnel [OPTIONS] <port>",
+        add_help=False,
+    )
+    parser.add_argument(
+        "port",
+        nargs="?",
+        type=int,
+        default=DEFAULT_LOCAL_PORT,
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "-s", "--subdomain",
+        type=str,
+        default=None,
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "-h", "--help",
+        action="store_true",
+        default=False,
+        help=argparse.SUPPRESS,
+    )
+    args = parser.parse_args()
+
+    if args.help:
+        print(HELP_TEXT)
+        return
+
+    app = FunnelApp(subdomain=args.subdomain, local_port=args.port)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

funnel_cli-0.1.0/docker-compose.yml

@@ -0,0 +1,16 @@
+services:
+
+  reverse_proxy:
+    build: infra/
+    ports:
+      - "443:443"
+      - "80:80"
+    volumes:
+      - /etc/letsencrypt:/etc/letsencrypt:ro
+
+  funnel_server:
+    build:
+      context: .
+      dockerfile: server/Dockerfile
+    ports: 
+      - "8080:8080"

funnel_cli-0.1.0/infra/Caddyfile

@@ -0,0 +1,4 @@
+funnel.delivery, *.funnel.delivery {
+    tls /etc/letsencrypt/live/funnel.delivery/fullchain.pem /etc/letsencrypt/live/funnel.delivery/privkey.pem
+    reverse_proxy funnel_server:80
+}

funnel_cli-0.1.0/infra/Dockerfile

@@ -0,0 +1,2 @@
+FROM caddy:latest
+COPY Caddyfile /etc/caddy/Caddyfile

funnel_cli-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "funnel-cli"
+version = "0.1.0"
+description = "Expose your local services to the internet"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.14"
+dependencies = ["textual"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["client", "shared"]
+
+[project.scripts]
+funnel = "client.client:main"

funnel_cli-0.1.0/server/Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY server/ ./server/
+COPY shared/ ./shared/
+CMD ["python3", "-m", "server.server"]

funnel_cli-0.1.0/server/server.py

@@ -0,0 +1,233 @@
+import asyncio
+import logging
+import uuid
+
+from dataclasses import dataclass
+from shared.lib import (
+    forward,
+    FunnelMessage,
+    FunnelMessageType,
+    read_message,
+    write_message,
+)
+from server.util import generate_random_subdomain, send_html_response
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("funnel_server")
+
+HOST = "0.0.0.0"
+HTTP_PORT = 80
+CLIENT_PORT = 8080
+BASE_DOMAIN = "funnel.delivery"
+
+
+@dataclass
+class Tunnel:
+    reader: asyncio.StreamReader
+    writer: asyncio.StreamWriter
+    lock: asyncio.Lock
+
+
+@dataclass
+class PendingConnection:
+    reader: asyncio.StreamReader
+    writer: asyncio.StreamWriter
+    proxy_subdomain: str
+    identifier_bytes: bytes
+
+
+TUNNELS: dict[str, Tunnel] = {}
+PENDING_CONNECTIONS: dict[str, PendingConnection] = {}
+
+
+async def handle_heartbeat(
+    proxy_subdomain: str, writer: asyncio.StreamWriter, lock: asyncio.Lock
+) -> None:
+    """
+    Periodically sends heartbeat messages to the funnel client to ensure the connection
+    is still alive. Cleans up the connection if the client becomes unreachable.
+    """
+    try:
+        while True:
+            async with lock:
+                logger.info("Sending heartbeat")
+                await write_message(
+                    writer,
+                    FunnelMessage(type=FunnelMessageType.HEARTBEAT),
+                )
+            await asyncio.sleep(10)
+
+    # if heartbeat fails, clean up connection
+    except Exception as e:
+        logger.error(e)
+        writer.close()
+        del TUNNELS[proxy_subdomain]
+        to_remove = [
+            cid
+            for cid, conn in PENDING_CONNECTIONS.items()
+            if conn.proxy_subdomain == proxy_subdomain
+        ]
+        for cid in to_remove:
+            PENDING_CONNECTIONS[cid].writer.close()
+            del PENDING_CONNECTIONS[cid]
+        logger.info(f"Cleaned up connection associated with {proxy_subdomain}")
+
+
+async def check_pending_connection(connection_id: str) -> None:
+    """
+    Checks if a connection ID is still in the pool of pending connections.
+    Deletes the connection and shuts the writer down if it hasn't been
+    claimed within 10 seconds.
+    """
+    await asyncio.sleep(10)
+    if connection_id in PENDING_CONNECTIONS:
+        logger.info(f"connection {connection_id} is unclaimed, cleaning it up")
+        pending_connection = PENDING_CONNECTIONS[connection_id]
+        pending_connection.writer.close()
+        del PENDING_CONNECTIONS[connection_id]
+
+
+async def handle_public(
+    public_reader: asyncio.StreamReader, public_writer: asyncio.StreamWriter
+) -> None:
+    """
+    Sets up a short-lived connection between a public request and the funnel server
+    and notifies the client of the connection
+    """
+    try:
+        header_bytes = await public_reader.readuntil(b"\r\n\r\n")
+        header_lines = header_bytes.decode().split("\r\n")
+        request_line = header_lines[0]
+        headers = dict(line.split(": ", 1) for line in header_lines if ": " in line)
+        host = headers["Host"].split(":")[0].lower()
+        proxy_subdomain = host.split(".")[0]
+
+        if host == BASE_DOMAIN:
+            await send_html_response(public_writer, "home.html")
+            return
+
+        client_writer = TUNNELS[proxy_subdomain].writer
+        lock = TUNNELS[proxy_subdomain].lock
+
+    except Exception as e:
+        logger.error(f"failed to parse proxy subdomain with error {e}")
+        await send_html_response(
+            public_writer, "404.html", status=404, subdomain=proxy_subdomain
+        )
+        return
+
+    connection_id = str(uuid.uuid4())
+    PENDING_CONNECTIONS[connection_id] = PendingConnection(
+        reader=public_reader,
+        writer=public_writer,
+        proxy_subdomain=proxy_subdomain,
+        identifier_bytes=header_bytes,
+    )
+
+    asyncio.create_task(check_pending_connection(connection_id))
+
+    logger.info(f"Created temporary request identifier {connection_id}")
+    # lock the client writer since the control connection has multiple things
+    # being written to it at once
+    async with lock:
+        await write_message(
+            client_writer,
+            FunnelMessage(
+                type=FunnelMessageType.INCOMING,
+                connection_id=connection_id,
+                request_line=request_line,
+            ),
+        )
+
+
+# request will be to open up a long-running TCP connection
+# this is the control connection, raw bytes do not flow over this connection
+async def handle_client(
+    client_reader: asyncio.StreamReader, client_writer: asyncio.StreamWriter
+) -> None:
+    """
+    Handles the control connection between the funnel client and funnel server.
+    The initial connection is established here, as well as setting up new connections
+    when a client requests data to be forwarded to it.
+    """
+    try:
+        message = await read_message(client_reader)
+        match message.type:
+            case FunnelMessageType.CONNECT:
+                logger.info("Received connection request from client")
+                proxy_subdomain = message.proxy_subdomain
+                if not proxy_subdomain:
+                    proxy_subdomain = generate_random_subdomain()
+                proxy_subdomain = proxy_subdomain.lower()
+                if proxy_subdomain in TUNNELS:
+                    raise Exception(
+                        f"subdomain {proxy_subdomain} has already been claimed"
+                    )
+                lock = asyncio.Lock()
+                logger.info(f"assigning subdomain {proxy_subdomain} to client")
+                TUNNELS[proxy_subdomain] = Tunnel(
+                    reader=client_reader, writer=client_writer, lock=lock
+                )
+
+                async with lock:
+                    await write_message(
+                        client_writer,
+                        FunnelMessage(
+                            type=FunnelMessageType.ACCEPT,
+                            proxy_subdomain=proxy_subdomain,
+                        ),
+                    )
+
+                asyncio.create_task(
+                    handle_heartbeat(proxy_subdomain, client_writer, lock)
+                )
+
+            case FunnelMessageType.RECEIVE:
+                connection_id = message.connection_id
+                if not connection_id:
+                    raise Exception("no connection ID present in receive message")
+                connection = PENDING_CONNECTIONS[connection_id]
+                public_reader, public_writer = (
+                    connection.reader,
+                    connection.writer,
+                )
+
+                # write the initial bytes that were read for subdomain routing to the client
+                client_writer.write(connection.identifier_bytes)
+                await client_writer.drain()
+
+                await asyncio.gather(
+                    asyncio.create_task(forward(public_reader, client_writer)),
+                    asyncio.create_task(forward(client_reader, public_writer)),
+                )
+
+                logger.info(
+                    f"Request closed, terminating connection ID {connection_id}"
+                )
+                del PENDING_CONNECTIONS[connection_id]
+
+            case _:
+                logger.info(message.type)
+                raise Exception("Invalid connection request")
+
+    except Exception as e:
+        logger.error(f"Error connecting to client: {e}")
+        client_writer.close()
+
+
+async def start_client_handler():
+    server = await asyncio.start_server(handle_client, HOST, CLIENT_PORT)
+    await server.serve_forever()
+
+
+async def start_public_handler():
+    server = await asyncio.start_server(handle_public, HOST, HTTP_PORT)
+    await server.serve_forever()
+
+
+async def main():
+    await asyncio.gather(start_client_handler(), start_public_handler())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

funnel_cli-0.1.0/server/templates/404.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tunnel Not Found — Funnel</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            background-color: #0a0a0a;
+            color: #e0e0e0;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .container {
+            text-align: center;
+            padding: 2rem;
+            max-width: 480px;
+        }
+
+        .status-code {
+            font-size: 6rem;
+            font-weight: 700;
+            letter-spacing: -0.04em;
+            color: #fff;
+            line-height: 1;
+            margin-bottom: 1rem;
+        }
+
+        .divider {
+            width: 48px;
+            height: 2px;
+            background: #333;
+            margin: 0 auto 1.5rem;
+        }
+
+        h1 {
+            font-size: 1.25rem;
+            font-weight: 500;
+            color: #ccc;
+            margin-bottom: 0.75rem;
+        }
+
+        p {
+            font-size: 0.9rem;
+            color: #666;
+            line-height: 1.6;
+        }
+
+        .subdomain {
+            color: #888;
+            font-family: "SF Mono", "Fira Code", "Fira Mono", Menlo, Consolas, monospace;
+            font-size: 0.85rem;
+            background: #161616;
+            border: 1px solid #222;
+            padding: 0.15rem 0.5rem;
+            border-radius: 4px;
+        }
+
+        .home-link {
+            display: inline-block;
+            margin-top: 2rem;
+            color: #555;
+            text-decoration: none;
+            font-size: 0.8rem;
+            letter-spacing: 0.05em;
+            text-transform: uppercase;
+            transition: color 0.2s;
+        }
+
+        .home-link:hover {
+            color: #aaa;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="status-code">404</div>
+        <div class="divider"></div>
+        <h1>Tunnel not found</h1>
+        <p>
+            No active tunnel for <span class="subdomain">{subdomain}</span><br>
+            The tunnel may have disconnected or the subdomain was never claimed.
+        </p>
+        <a class="home-link" href="https://funnel.delivery">← funnel.delivery</a>
+    </div>
+</body>
+</html>

funnel_cli-0.1.0/server/templates/home.html

@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Funnel — Expose your local server to the internet</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            background-color: #0a0a0a;
+            color: #e0e0e0;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .container {
+            text-align: center;
+            padding: 2rem;
+            max-width: 540px;
+        }
+
+        .logo {
+            font-size: 3rem;
+            font-weight: 700;
+            letter-spacing: -0.03em;
+            color: #fff;
+            margin-bottom: 0.5rem;
+        }
+
+        .tagline {
+            font-size: 1rem;
+            color: #666;
+            margin-bottom: 2.5rem;
+        }
+
+        .terminal {
+            background: #111;
+            border: 1px solid #222;
+            border-radius: 8px;
+            padding: 1.25rem 1.5rem;
+            text-align: left;
+            margin-bottom: 2.5rem;
+        }
+
+        .terminal-bar {
+            display: flex;
+            gap: 6px;
+            margin-bottom: 1rem;
+        }
+
+        .terminal-dot {
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            background: #333;
+        }
+
+        .terminal-line {
+            font-family: "SF Mono", "Fira Code", "Fira Mono", Menlo, Consolas, monospace;
+            font-size: 0.85rem;
+            line-height: 1.8;
+            color: #888;
+        }
+
+        .terminal-line .prompt {
+            color: #555;
+        }
+
+        .terminal-line .cmd {
+            color: #ccc;
+        }
+
+        .terminal-line .url {
+            color: #6ec7e0;
+        }
+
+        .features {
+            display: flex;
+            gap: 2rem;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+
+        .feature {
+            flex: 1;
+            min-width: 140px;
+        }
+
+        .feature-title {
+            font-size: 0.8rem;
+            font-weight: 600;
+            color: #999;
+            text-transform: uppercase;
+            letter-spacing: 0.06em;
+            margin-bottom: 0.35rem;
+        }
+
+        .feature-desc {
+            font-size: 0.8rem;
+            color: #555;
+            line-height: 1.5;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="logo">funnel</div>
+        <p class="tagline">Expose your local server to the internet.</p>
+
+        <div class="terminal">
+            <div class="terminal-bar">
+                <div class="terminal-dot"></div>
+                <div class="terminal-dot"></div>
+                <div class="terminal-dot"></div>
+            </div>
+            <div class="terminal-line">
+                <span class="prompt">$</span> <span class="cmd">funnel 8000</span>
+            </div>
+            <div class="terminal-line">
+                Forwarding <span class="url">https://my-subdomain.funnel.delivery</span> → localhost:8000
+            </div>
+        </div>
+    </div>
+</body>
+</html>

funnel_cli-0.1.0/server/util.py

@@ -0,0 +1,88 @@
+import asyncio
+import random
+from pathlib import Path
+
+TEMPLATE_DIR = Path(__file__).resolve().parent / "templates"
+
+STATUS_PHRASES = {
+    200: "OK",
+    404: "Not Found",
+}
+
+
+def load_template(name: str, **kwargs: str) -> str:
+    text = (TEMPLATE_DIR / name).read_text()
+    for key, value in kwargs.items():
+        text = text.replace(f"{{{key}}}", value)
+    return text
+
+
+async def send_html_response(
+    writer: asyncio.StreamWriter,
+    template: str,
+    status: int = 200,
+    **kwargs: str,
+) -> None:
+    body = load_template(template, **kwargs)
+    phrase = STATUS_PHRASES.get(status, "OK")
+    response = (
+        f"HTTP/1.1 {status} {phrase}\r\n"
+        "Content-Type: text/html\r\n"
+        "Connection: close\r\n"
+        f"Content-Length: {len(body)}\r\n"
+        "\r\n" + body
+    )
+    writer.write(response.encode())
+    await writer.drain()
+    writer.close()
+
+
+def generate_random_subdomain() -> str:
+    adjectives = [
+        "auspicious",
+        "diabolical",
+        "ominous",
+        "glib",
+        "crusty",
+        "swift",
+        "moldy",
+        "spicy",
+        "fuzzy",
+        "wonky",
+        "crispy",
+        "soggy",
+        "sneaky",
+        "famous",
+        "infamous",
+        "controversial",
+        "rusty",
+        "dusty",
+        "toasty",
+        "frosty",
+        "gloomy",
+        "zesty",
+    ]
+    nouns = [
+        "yak",
+        "clam",
+        "waffle",
+        "toad",
+        "walrus",
+        "pickle",
+        "badger",
+        "turnip",
+        "eel",
+        "moose",
+        "squid",
+        "mango",
+        "puffin",
+        "ferret",
+        "shrimp",
+        "egret",
+        "parrot",
+        "trashcan",
+        "spatula",
+        "mitochondria",
+        "rat",
+    ]
+    return f"{random.choice(adjectives)}-{random.choice(nouns)}"

funnel_cli-0.1.0/shared/lib.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import asyncio
+import json
+import struct
+
+from dataclasses import asdict, dataclass
+from enum import StrEnum
+from typing import Optional
+
+
+class FunnelMessageType(StrEnum):
+    CONNECT = "connect"
+    ACCEPT = "accept"
+    HEARTBEAT = "heartbeat"
+    INCOMING = "incoming_connection"
+    RECEIVE = "receive_connection"
+
+
+@dataclass
+class FunnelMessage:
+    type: FunnelMessageType
+    connection_id: Optional[str] = None
+    proxy_subdomain: Optional[str] = None
+    method: Optional[str] = None
+    request_line: Optional[str] = None
+
+    def encode(self) -> bytes:
+        # filter out missing keys before sending the message
+        data = {k: v for k, v in asdict(self).items() if v is not None}
+        return json.dumps(data).encode()
+
+    @classmethod
+    def decode(cls, data: bytes) -> FunnelMessage:
+        return cls(**json.loads(data))
+
+
+async def read_message(reader: asyncio.StreamReader) -> FunnelMessage:
+    message_length = struct.unpack(">I", await reader.readexactly(4))[0]
+    data = await reader.readexactly(message_length)
+    return FunnelMessage.decode(data)
+
+
+async def write_message(
+    writer: asyncio.StreamWriter, funnel_message: FunnelMessage
+) -> None:
+    data = funnel_message.encode()
+    writer.write(struct.pack(">I", len(data)))
+    writer.write(data)
+    await writer.drain()
+
+
+async def forward(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+    data = await reader.read(4096)
+    while data:
+        writer.write(data)
+        await writer.drain()
+        data = await reader.read(4096)
+    writer.close()