weed-cli 1.9.5__tar.gz → 2.0.2__tar.gz

{weed_cli-1.9.5 → weed_cli-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.9.5
+Version: 2.0.2
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal

{weed_cli-1.9.5 → weed_cli-2.0.2}/node.py

@@ -249,10 +249,19 @@ def load_manifest_entries(archive_dir, file_name=None):
         sys.exit(f"no .ott/manifest.jsonl in {archive_dir} — archive a file with ott first")
     with open(manifest_path) as f:
         raw = [json.loads(line) for line in f if line.strip()]
+    # Deduplicate by sha256 first (last-write-wins), matching ott's own
+    # load_manifest convention.  A rename appends a new entry with an
+    # updated name/last_path under the same sha256; without this step the
+    # old entry (wrong name, missing path) survives as a "different file"
+    # and causes a spurious "not found on disk" error at startup.
+    by_hash: dict = {}
+    for e in raw:
+        by_hash[e['sha256']] = e
+    deduped = list(by_hash.values())
     if file_name:
-        raw = [e for e in raw if e['name'] == file_name]
+        deduped = [e for e in deduped if e['name'] == file_name]
     by_name = {}
-    for e in raw:
+    for e in deduped:
         by_name[e['name']] = e
     all_entries = list(by_name.values())
     entries = [e for e in all_entries if e.get('type') in ('video', 'audio')]

{weed_cli-1.9.5 → weed_cli-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "1.9.5"
+version = "2.0.2"
 description = "Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel"
 readme = "README.md"
 license = { text = "MIT" }

weed_cli-2.0.2/tests/test_orbit_ws.py

@@ -0,0 +1,300 @@
+"""
+The orbit MJPEG relay (web_ui.py): the WebSocket frame parser and unmask
+(pure functions over a byte stream, driven with io.BytesIO), the
+drop-oldest fanout policy (against a real queue.Queue), and the whole
+path end to end -- a hand-rolled WebSocket client pushes a frame into a
+real WebUIServer and a raw-socket viewer reads it back out of
+/api/orbit-view as a multipart part. Stdlib only, like the server.
+"""
+import base64
+import hashlib
+import io
+import os
+import queue
+import socket
+import struct
+import time
+
+import pytest
+
+import web_ui
+from testutil import http_get_json
+
+WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+
+@pytest.fixture(autouse=True)
+def _reset_orbit_state():
+    """The relay's state is module globals that no other fixture resets;
+    a viewer queue left behind by one test would otherwise still be fed
+    (and counted) by the next."""
+    web_ui._orbit_subscribers.clear()
+    web_ui._orbit_ws_connected = False
+    web_ui._orbit_res = None
+    web_ui._orbit_rx.update(fps=0.0, kbps=0, dropped=0)
+    yield
+    web_ui._orbit_subscribers.clear()
+
+
+# ── frame building (the client side of RFC 6455) ──────────────────────
+def client_frame(payload, opcode=2, fin=True, mask_key=None):
+    """A masked client->server frame, exactly as a browser sends it."""
+    mask_key = mask_key or os.urandom(4)
+    b0 = (0x80 if fin else 0) | opcode
+    n = len(payload)
+    if n < 126:
+        hdr = bytes([b0, 0x80 | n])
+    elif n < 65536:
+        hdr = bytes([b0, 0x80 | 126]) + struct.pack('>H', n)
+    else:
+        hdr = bytes([b0, 0x80 | 127]) + struct.pack('>Q', n)
+    return hdr + mask_key + naive_unmask(payload, mask_key)
+
+
+def naive_unmask(data, key):
+    # the per-byte definition from the RFC, i.e. what the fast path
+    # must agree with
+    return bytes(data[i] ^ key[i % 4] for i in range(len(data)))
+
+
+# ── unmask ─────────────────────────────────────────────────────────────
+@pytest.mark.parametrize('n', [0, 1, 3, 4, 5, 63, 64, 65, 1000, 120_000])
+def test_unmask_matches_the_per_byte_definition(n):
+    data, key = os.urandom(n), os.urandom(4)
+    assert web_ui._ws_unmask(data, key) == naive_unmask(data, key)
+
+
+def test_unmask_is_its_own_inverse():
+    data, key = os.urandom(777), os.urandom(4)
+    assert web_ui._ws_unmask(web_ui._ws_unmask(data, key), key) == data
+
+
+# ── message parser ─────────────────────────────────────────────────────
+def messages(raw):
+    return list(web_ui._ws_messages(io.BytesIO(raw)))
+
+
+def test_single_masked_binary_frame():
+    payload = b'\xff\xd8' + os.urandom(100) + b'\xff\xd9'
+    assert messages(client_frame(payload)) == [(2, payload)]
+
+
+@pytest.mark.parametrize('n', [125, 126, 65535, 65536, 200_000])
+def test_every_length_encoding(n):
+    # 125 / 126 / 65535 / 65536 are the boundaries between the 7-bit,
+    # 16-bit and 64-bit length forms; 200KB is a real 720p frame's size
+    payload = os.urandom(n)
+    assert messages(client_frame(payload)) == [(2, payload)]
+
+
+def test_fragmented_message_is_reassembled():
+    a, b, c = os.urandom(50), os.urandom(60), os.urandom(70)
+    raw = (client_frame(a, opcode=2, fin=False)
+           + client_frame(b, opcode=0, fin=False)
+           + client_frame(c, opcode=0, fin=True))
+    assert messages(raw) == [(2, a + b + c)]
+
+
+def test_ping_passes_through_without_disturbing_a_fragmented_message():
+    a, b = os.urandom(10), os.urandom(10)
+    raw = (client_frame(a, opcode=2, fin=False)
+           + client_frame(b'hi', opcode=9)
+           + client_frame(b, opcode=0, fin=True))
+    assert messages(raw) == [(9, b'hi'), (2, a + b)]
+
+
+def test_close_frame_ends_the_stream():
+    raw = client_frame(b'one') + client_frame(b'\x03\xe8bye', opcode=8) + client_frame(b'never')
+    assert messages(raw) == [(2, b'one')]
+
+
+def test_truncated_stream_ends_cleanly_without_raising():
+    full = client_frame(os.urandom(300))
+    for cut in (1, 2, 5, 100, len(full) - 1):
+        assert messages(full[:cut]) == []
+    assert messages(client_frame(b'ok') + full[:7]) == [(2, b'ok')]
+
+
+def test_unmasked_frames_are_accepted_too():
+    payload = b'abc'
+    raw = bytes([0x82, len(payload)]) + payload
+    assert messages(raw) == [(2, payload)]
+
+
+def test_stray_continuation_frame_is_ignored():
+    assert messages(client_frame(b'orphan', opcode=0)) == []
+
+
+# ── fanout policy ──────────────────────────────────────────────────────
+def test_fanout_drops_oldest_and_keeps_the_viewer():
+    q = queue.Queue(maxsize=2)
+    web_ui._orbit_subscribers.add(q)
+    frames = [b'f%d' % i for i in range(5)]
+    dropped = sum(web_ui._orbit_fanout(f) for f in frames)
+    assert q in web_ui._orbit_subscribers            # never evicted
+    assert dropped == 3                              # 5 in, room for 2
+    assert [q.get_nowait(), q.get_nowait()] == frames[-2:]   # the newest survive
+
+
+def test_fanout_with_no_viewers_is_a_noop():
+    assert web_ui._orbit_fanout(b'x') == 0
+
+
+# ── end to end against a real server ───────────────────────────────────
+def _hostport(url):
+    host, _, port = url[len('http://'):].partition(':')
+    return host, int(port)
+
+
+def _read_until(sock, marker):
+    buf = b''
+    while marker not in buf:
+        chunk = sock.recv(4096)
+        assert chunk, f'connection closed before {marker!r} arrived'
+        buf += chunk
+    return buf
+
+
+def ws_connect(url, path='/api/orbit-ws'):
+    host, port = _hostport(url)
+    s = socket.create_connection((host, port), timeout=5)
+    key = base64.b64encode(os.urandom(16)).decode()
+    s.sendall((f'GET {path} HTTP/1.1\r\nHost: {host}:{port}\r\n'
+               'Upgrade: websocket\r\nConnection: Upgrade\r\n'
+               f'Sec-WebSocket-Key: {key}\r\nSec-WebSocket-Version: 13\r\n\r\n').encode())
+    resp = _read_until(s, b'\r\n\r\n')
+    assert resp.startswith(b'HTTP/1.1 101 ')
+    expected = base64.b64encode(hashlib.sha1((key + WS_GUID).encode()).digest()).decode()
+    assert f'Sec-WebSocket-Accept: {expected}'.encode() in resp
+    return s
+
+
+class Viewer:
+    """A raw-socket MJPEG viewer: the socket plus whatever bytes past the
+    current part have already been read off it (socket objects can't
+    carry that themselves -- no __dict__)."""
+    def __init__(self, sock, leftover):
+        self.sock = sock
+        self.leftover = leftover
+
+    def close(self):
+        self.sock.close()
+
+
+def viewer_connect(url):
+    """Returns a Viewer once the response headers are in -- the server
+    registers the viewer's queue *before* sending them, so any frame
+    pushed after this returns is guaranteed to reach it."""
+    host, port = _hostport(url)
+    s = socket.create_connection((host, port), timeout=5)
+    s.sendall(f'GET /api/orbit-view HTTP/1.1\r\nHost: {host}:{port}\r\n\r\n'.encode())
+    head = _read_until(s, b'\r\n\r\n')
+    assert b'HTTP/1.1 200' in head
+    assert b'multipart/x-mixed-replace; boundary=orbit' in head
+    return Viewer(s, head.split(b'\r\n\r\n', 1)[1])
+
+
+def read_part(viewer):
+    """One multipart part off the viewer; returns its JPEG bytes."""
+    buf = viewer.leftover
+    while b'\r\n\r\n' not in buf:
+        chunk = viewer.sock.recv(65536)
+        assert chunk, 'viewer connection closed'
+        buf += chunk
+    head, body = buf.split(b'\r\n\r\n', 1)
+    assert head.startswith(b'--orbit\r\n')
+    assert b'Content-Type: image/jpeg' in head
+    length = int(head.split(b'Content-Length: ')[1].split(b'\r\n')[0])
+    while len(body) < length + 2:
+        chunk = viewer.sock.recv(65536)
+        assert chunk, 'viewer connection closed mid-frame'
+        body += chunk
+    jpeg, trailer, rest = body[:length], body[length:length + 2], body[length + 2:]
+    assert trailer == b'\r\n'
+    viewer.leftover = rest
+    return jpeg
+
+
+def wait_status(url, pred, timeout=3.0):
+    deadline = time.time() + timeout
+    st = None
+    while time.time() < deadline:
+        st = http_get_json(f'{url}/api/orbit-stream')
+        if pred(st):
+            return st
+        time.sleep(0.05)
+    pytest.fail(f'status never matched; last seen: {st}')
+
+
+def test_frame_pushed_over_websocket_comes_out_of_the_mjpeg_view(web_server):
+    viewer = viewer_connect(web_server)
+    ws = ws_connect(web_server)
+    try:
+        # 100KB forces the 8-byte length form, the one a real frame uses
+        frame = b'\xff\xd8' + os.urandom(100_000) + b'\xff\xd9'
+        ws.sendall(client_frame(frame))
+        assert read_part(viewer) == frame
+        # a second part proves the viewer connection stays open between frames
+        frame2 = b'\xff\xd8' + os.urandom(500) + b'\xff\xd9'
+        ws.sendall(client_frame(frame2))
+        assert read_part(viewer) == frame2
+    finally:
+        ws.close()
+        viewer.close()
+
+
+def test_fragmented_frame_is_reassembled_end_to_end(web_server):
+    viewer = viewer_connect(web_server)
+    ws = ws_connect(web_server)
+    try:
+        a, b = os.urandom(3000), os.urandom(3000)
+        ws.sendall(client_frame(a, opcode=2, fin=False))
+        ws.sendall(client_frame(b, opcode=0, fin=True))
+        assert read_part(viewer) == a + b
+    finally:
+        ws.close()
+        viewer.close()
+
+
+def test_server_answers_ping_with_pong(web_server):
+    ws = ws_connect(web_server)
+    try:
+        ws.sendall(client_frame(b'marco', opcode=9))
+        pong = _read_until(ws, b'marco')
+        assert pong[:2] == bytes([0x8a, 5])   # FIN|pong, unmasked, length 5
+    finally:
+        ws.close()
+
+
+def test_status_tracks_the_streamer_and_its_resolution(web_server):
+    st = http_get_json(f'{web_server}/api/orbit-stream')
+    assert st['active'] is False and st['viewers'] == 0 and st['res'] is None
+    assert st['rx'] == {'fps': 0.0, 'kbps': 0, 'dropped': 0}
+    assert st['url'].endswith('/api/orbit-view')
+
+    ws = ws_connect(web_server, '/api/orbit-ws?res=480')
+    viewer = viewer_connect(web_server)
+    try:
+        st = wait_status(web_server, lambda s: s['active'] and s['viewers'] == 1)
+        assert st['res'] == '480'
+    finally:
+        ws.close()
+    # the streamer going away ends every viewer too, and zeroes the counters
+    st = wait_status(web_server, lambda s: not s['active'] and s['viewers'] == 0)
+    assert st['res'] is None
+    assert st['rx'] == {'fps': 0.0, 'kbps': 0, 'dropped': 0}
+    viewer.close()
+
+
+def test_one_viewer_leaving_does_not_disturb_another(web_server):
+    ws = ws_connect(web_server)
+    v1 = viewer_connect(web_server)
+    v2 = viewer_connect(web_server)
+    try:
+        wait_status(web_server, lambda s: s['viewers'] == 2)
+        v1.close()
+        ws.sendall(client_frame(b'\xff\xd8still here\xff\xd9'))
+        assert read_part(v2) == b'\xff\xd8still here\xff\xd9'
+    finally:
+        ws.close()
+        v2.close()

{weed_cli-1.9.5 → weed_cli-2.0.2}/web_ui.py

@@ -21,7 +21,12 @@ import mimetypes
 import os
 import signal
 import socket
+import queue
+import ssl
+import struct
+import subprocess
 import sys
+import tempfile
 import threading
 import time
 import uuid
@@ -138,6 +143,120 @@ def _with_captured_detail(msg, captured):
 
 _hosts = {}   # host_id -> dict describing an actively-hosted file
 _jobs = {}    # job_id -> dict describing a download's progress/result
+
+# ── orbit MJPEG stream ───────────────────────────────────────────────────
+# Browser sends JPEG frames via WebSocket /api/orbit-ws; server fans them
+# out as MJPEG (multipart/x-mixed-replace) on /api/orbit-view.
+_orbit_ws_connected = False  # True while a browser WS is open and pushing frames
+_orbit_res = None            # the streamer's ?res= ('720'/'480'/'360') while connected
+_orbit_ws_lock = threading.Lock()
+# last 5s window of what the WS reader actually received / had to drop,
+# written by the reader thread, read by /api/orbit-stream -- see the
+# matching console line the browser prints on its send side
+_orbit_rx = {'fps': 0.0, 'kbps': 0, 'dropped': 0}
+_orbit_subscribers = set()   # set of queue.Queue, one per HTTP client
+_orbit_subs_lock = threading.Lock()
+
+
+def _orbit_fanout(payload):
+    """Hand one JPEG to every viewer's queue. Returns how many viewers
+    were behind (queue full) when it arrived.
+
+    A full queue means that viewer's writer thread hasn't kept up. The
+    policy is drop-oldest, never disconnect: pop its stalest frame and
+    put this one, so a momentary stall (VLC buffering, a wifi hiccup)
+    costs a skipped frame rather than the whole stream -- and never
+    letting a backlog build is what keeps a viewer's latency pinned
+    near zero."""
+    dropped = 0
+    with _orbit_subs_lock:
+        for q in _orbit_subscribers:
+            try:
+                q.put_nowait(payload)
+            except queue.Full:
+                try: q.get_nowait()
+                except queue.Empty: pass
+                try: q.put_nowait(payload)
+                except queue.Full: pass
+                dropped += 1
+    return dropped
+
+
+def _ws_unmask(data, mask_key):
+    """Client->server WebSocket payloads arrive XOR-masked with a 4-byte
+    key. Done as one big-int XOR rather than a per-byte Python loop:
+    ~25x faster (0.4ms vs ~9ms per 120KB frame on a desktop; on the Pi
+    the per-byte loop alone was eating most of a 30fps frame budget and
+    showed up as stutter on every viewer)."""
+    n = len(data)
+    if n == 0:
+        return data
+    mask = (mask_key * (n // 4 + 1))[:n]
+    return (int.from_bytes(data, 'little') ^ int.from_bytes(mask, 'little')).to_bytes(n, 'little')
+
+
+def _ws_messages(rfile):
+    """Yield (opcode, payload) for each complete WebSocket message read
+    from the file-like `rfile`: length prefixes decoded, masks removed,
+    continuation frames reassembled. Stops at EOF, at a truncated frame,
+    or at a close frame (opcode 8). Control frames (ping 9 / pong 10)
+    are yielded as they arrive so the caller can answer them; only data
+    frames take part in reassembly. A pure function of the byte stream
+    -- no socket, no globals -- so tests drive it with io.BytesIO."""
+    def read_exact(n):
+        buf = b''
+        while len(buf) < n:
+            chunk = rfile.read(n - len(buf))
+            if not chunk:
+                return None
+            buf += chunk
+        return buf
+
+    fragments = []
+    msg_opcode = 0
+    while True:
+        hdr = read_exact(2)
+        if hdr is None:
+            return
+        b0, b1 = hdr[0], hdr[1]
+        fin = bool(b0 & 0x80)
+        opcode = b0 & 0x0F
+        masked = bool(b1 & 0x80)
+        length = b1 & 0x7F
+        if length == 126:
+            ext = read_exact(2)
+            if ext is None:
+                return
+            length = struct.unpack('>H', ext)[0]
+        elif length == 127:
+            ext = read_exact(8)
+            if ext is None:
+                return
+            length = struct.unpack('>Q', ext)[0]
+        mask_key = read_exact(4) if masked else None
+        if masked and mask_key is None:
+            return
+        chunk = read_exact(length)
+        if chunk is None:
+            return
+        if masked:
+            chunk = _ws_unmask(chunk, mask_key)
+        if opcode == 8:
+            return
+        if opcode >= 8:            # ping / pong: never fragmented
+            yield opcode, chunk
+            continue
+        if opcode != 0:            # text (1) / binary (2): starts a message
+            msg_opcode = opcode
+            fragments = [chunk]
+        elif fragments:            # continuation of one already started
+            fragments.append(chunk)
+        else:
+            continue               # continuation with nothing to continue
+        if fin:
+            payload = b''.join(fragments)
+            fragments = []
+            yield msg_opcode, payload
 _job_logs = {}   # job_id -> the live io.StringIO node.py's prints are captured into (see _quiet)
 _host_logs = {}  # host_id -> same, for a host job (announce progress, [host:PORT] serving, ...)
 _lock = threading.Lock()
@@ -579,12 +698,15 @@ class WebUIServer(ThreadingHTTPServer):
         preconnects all do this. socketserver's default handle_error
         prints a full traceback for every one of these; only genuinely
         unexpected errors get that treatment here."""
-        if sys.exc_info()[0] in (ConnectionResetError, BrokenPipeError, TimeoutError):
+        import ssl as _ssl
+        if sys.exc_info()[0] in (ConnectionResetError, BrokenPipeError, TimeoutError, _ssl.SSLError, _ssl.SSLEOFError):
             return
         super().handle_error(request, client_address)
 
 
 class Handler(BaseHTTPRequestHandler):
+    protocol_version = 'HTTP/1.1'  # needed for streaming responses (orbit-view)
+
     def log_message(self, fmt, *args):
         pass  # quiet — this is a local UI, not a service worth logging every hit for
 
@@ -659,6 +781,12 @@ class Handler(BaseHTTPRequestHandler):
             return self._json({'pubkey': pubkey, 'score': score, 'why': why})
         if path.startswith('/api/stream/'):
             return self._handle_stream(path[len('/api/stream/'):])
+        if path == '/api/orbit-ws':
+            return self._handle_orbit_websocket(qs)
+        if path == '/api/orbit-view':
+            return self._handle_orbit_view()
+        if path == '/api/orbit-stream':
+            return self._handle_orbit_stream_status()
         if path == '/api/qr':
             data = (qs.get('data') or [''])[0]
             if not data:
@@ -1125,6 +1253,154 @@ class Handler(BaseHTTPRequestHandler):
             result = node.verify_local_download(content_hash, relay_urls, rec['path'])
         self._json(result)
 
+    # ── orbit MJPEG stream ─────────────────────────────────────────────
+    def _handle_orbit_stream_status(self):
+        with _orbit_ws_lock:
+            active, res = _orbit_ws_connected, _orbit_res
+        with _orbit_subs_lock:
+            viewers = len(_orbit_subscribers)
+        host = self.headers.get('Host', '192.168.1.137:8080')
+        scheme = 'https' if hasattr(self.connection, 'read') and hasattr(self.server, '_tls') else 'http'
+        return self._json({
+            'active': active,
+            'res': res,
+            'viewers': viewers,
+            'rx': dict(_orbit_rx),
+            'url': f'{scheme}://{host}/api/orbit-view',
+            'vlc': f'{scheme}://{host}/api/orbit-view',
+        })
+
+    def _handle_orbit_view(self):
+        """MJPEG stream — any browser or VLC on the LAN connects here.
+        No ffmpeg, no encoding: the server relays raw JPEG frames from the
+        streamer's browser as multipart/x-mixed-replace.  Browsers display
+        it natively in an <img> tag; VLC plays it with no flags needed."""
+        import queue as _q
+        # 2 deep, not 8: the fanout drops the *oldest* frame when this is
+        # full, so depth is purely how much latency a viewer can accumulate
+        # before it starts skipping -- 2 frames at 30fps is ~66ms, vs the
+        # ~800ms of drift a 10fps x 8-frame backlog used to allow.
+        q = _q.Queue(maxsize=2)
+        with _orbit_subs_lock:
+            _orbit_subscribers.add(q)
+        boundary = b'--orbit\r\n'
+        try:
+            # each frame is one write; don't let Nagle hold it back waiting
+            # for a fuller segment
+            try:
+                self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            except OSError:
+                pass
+            self.send_response(200)
+            self.send_header('Content-Type', 'multipart/x-mixed-replace; boundary=orbit')
+            self.send_header('Cache-Control', 'no-cache')
+            self.send_header('Connection', 'close')
+            self.end_headers()
+            while True:
+                try:
+                    jpeg = q.get(timeout=30)
+                except _q.Empty:
+                    continue
+                if jpeg is None:
+                    break
+                try:
+                    self.wfile.write(
+                        boundary
+                        + b'Content-Type: image/jpeg\r\n'
+                        + f'Content-Length: {len(jpeg)}\r\n\r\n'.encode()
+                        + jpeg
+                        + b'\r\n'
+                    )
+                    self.wfile.flush()
+                except OSError:
+                    break
+        except Exception:
+            pass
+        finally:
+            with _orbit_subs_lock:
+                _orbit_subscribers.discard(q)
+
+    def _handle_orbit_websocket(self, qs):
+        """The streamer's side: one browser pushes JPEG frames here as
+        binary WebSocket messages; each one is fanned out to every
+        /api/orbit-view subscriber. Frame parsing lives in _ws_messages
+        and the fanout policy in _orbit_fanout -- this method is just
+        the handshake, the loop, and the 5-second rx counters."""
+        import base64, hashlib
+        global _orbit_ws_connected, _orbit_res
+
+        # WebSocket handshake — write directly to the raw socket to avoid
+        # BaseHTTPRequestHandler's headers buffer interfering with the upgrade.
+        key = self.headers.get('Sec-WebSocket-Key', '')
+        if not key:
+            self.send_response(400)
+            self.end_headers()
+            return
+        accept = base64.b64encode(
+            hashlib.sha1(
+                (key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11').encode()
+            ).digest()
+        ).decode()
+        self.connection.sendall((
+            'HTTP/1.1 101 Switching Protocols\r\n'
+            'Upgrade: websocket\r\n'
+            'Connection: Upgrade\r\n'
+            f'Sec-WebSocket-Accept: {accept}\r\n'
+            '\r\n'
+        ).encode())
+
+        res = (qs.get('res') or [None])[0]
+        with _orbit_ws_lock:
+            _orbit_ws_connected = True
+            _orbit_res = res
+        print(f'[orbit] WebSocket open ({res or "?"}p) — streaming MJPEG to /api/orbit-view', flush=True)
+
+        try:
+            rx_n = rx_bytes = rx_dropped = 0
+            rx_t0 = time.monotonic()
+            for opcode, payload in _ws_messages(self.rfile):
+                if opcode == 9:
+                    # ping -> pong with the same payload. Browsers don't
+                    # send these unprompted, but a proxy in between might;
+                    # server->client frames are never masked.
+                    if len(payload) < 126:
+                        self.connection.sendall(b'\x8a' + bytes([len(payload)]) + payload)
+                    continue
+                if opcode != 2 or not payload:
+                    continue
+                rx_dropped += _orbit_fanout(payload)
+                rx_n += 1
+                rx_bytes += len(payload)
+                now = time.monotonic()
+                if now - rx_t0 >= 5:
+                    dt = now - rx_t0
+                    _orbit_rx['fps'] = round(rx_n / dt, 1)
+                    _orbit_rx['kbps'] = round(rx_bytes / dt / 1024)
+                    _orbit_rx['dropped'] = rx_dropped
+                    with _orbit_subs_lock:
+                        nviewers = len(_orbit_subscribers)
+                    # dropped > 0 here means a *viewer* write is the slow
+                    # link (its queue filled); fps well under what the
+                    # browser's own console line says it sent means the
+                    # network between browser and this socket is.
+                    print(f"[orbit] rx {_orbit_rx['fps']} fps, {_orbit_rx['kbps']} KB/s, "
+                          f"viewers={nviewers}, dropped={rx_dropped}", flush=True)
+                    rx_n = rx_bytes = rx_dropped = 0
+                    rx_t0 = now
+        except Exception:
+            pass
+        finally:
+            print('[orbit] WebSocket closed', flush=True)
+            _orbit_rx.update(fps=0.0, kbps=0, dropped=0)
+            with _orbit_ws_lock:
+                _orbit_ws_connected = False
+                _orbit_res = None
+            with _orbit_subs_lock:
+                subs = list(_orbit_subscribers)
+            for q in subs:
+                try: q.put_nowait(None)
+                except Exception: pass
+
     def _handle_stream(self, job_id):
         """Serve an already-downloaded job's file with real HTTP range
         support, so a <video> tag can seek/scrub instead of just
@@ -1239,7 +1515,56 @@ class Handler(BaseHTTPRequestHandler):
         self.wfile.write(body)
 
 
-def run_web_ui(port=8080, bind_host='127.0.0.1', quiet=False, advertise_host=None):
+def _generate_self_signed_cert(host):
+    """Return (cert_path, key_path) for a self-signed cert written to a temp dir.
+
+    The temp dir is NOT cleaned up — it lives for the process lifetime so the
+    files stay valid as long as the server is running. Uses the `cryptography`
+    package already in requirements.txt.
+    """
+    from cryptography import x509
+    from cryptography.hazmat.primitives import hashes, serialization
+    from cryptography.hazmat.primitives.asymmetric import rsa
+    from cryptography.x509.oid import NameOID
+    import datetime, ipaddress
+
+    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, host)])
+    san_list = [x509.DNSName(host)]
+    try:
+        san_list.append(x509.IPAddress(ipaddress.ip_address(host)))
+    except ValueError:
+        pass
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(name)
+        .issuer_name(name)
+        .public_key(key.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(now)
+        .not_valid_after(now + datetime.timedelta(days=825))
+        .add_extension(x509.SubjectAlternativeName(san_list), critical=False)
+        .sign(key, hashes.SHA256())
+    )
+
+    tmp = tempfile.mkdtemp(prefix='weed-tls-')
+    cert_path = os.path.join(tmp, 'cert.pem')
+    key_path = os.path.join(tmp, 'key.pem')
+    with open(cert_path, 'wb') as f:
+        f.write(cert.public_bytes(serialization.Encoding.PEM))
+    with open(key_path, 'wb') as f:
+        f.write(key.private_bytes(
+            serialization.Encoding.PEM,
+            serialization.PrivateFormat.TraditionalOpenSSL,
+            serialization.NoEncryption(),
+        ))
+    return cert_path, key_path
+
+
+def run_web_ui(port=8080, bind_host='127.0.0.1', quiet=False, advertise_host=None,
+               tls=False, certfile=None, keyfile=None):
     global _lan_url
     _load_library()
     _rehydrate_jobs_from_library()
@@ -1247,6 +1572,20 @@ def run_web_ui(port=8080, bind_host='127.0.0.1', quiet=False, advertise_host=Non
     _resume_persisted_hosts()
     srv = WebUIServer((bind_host, port), Handler)
 
+    if tls:
+        if not certfile or not keyfile:
+            reachable_for_cert = advertise_host or (_detect_lan_ip() if bind_host == '0.0.0.0' else bind_host) or bind_host
+            if not quiet:
+                print(f"[web] generating self-signed TLS cert for {reachable_for_cert} …", flush=True)
+            certfile, keyfile = _generate_self_signed_cert(reachable_for_cert)
+            if not quiet:
+                print(f"[web] cert: {certfile}", flush=True)
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        ctx.load_cert_chain(certfile, keyfile)
+        srv.socket = ctx.wrap_socket(srv.socket, server_side=True)
+
+    scheme = 'https' if tls else 'http'
+
     # `docker compose down` (and plain Ctrl-C) sends SIGTERM -- without
     # this, a host that goes offline just leaves a stale, now-unreachable
     # publish event sitting in discover results until a relay's per-signer
@@ -1270,7 +1609,7 @@ def run_web_ui(port=8080, bind_host='127.0.0.1', quiet=False, advertise_host=Non
     # just fixed by telling this explicitly instead of guessing
     reachable_host = advertise_host or (_detect_lan_ip() if bind_host == '0.0.0.0' else bind_host)
     if bind_host != '127.0.0.1' and reachable_host:
-        _lan_url = f'http://{reachable_host}:{port}/'
+        _lan_url = f'{scheme}://{reachable_host}:{port}/'
 
     if not quiet:
         # answers "is this container actually running the code I think it
@@ -1280,7 +1619,7 @@ def run_web_ui(port=8080, bind_host='127.0.0.1', quiet=False, advertise_host=Non
         # place; printing it here means the same question doesn't need a
         # docker exec + grep to answer for the web UI specifically
         print(f"[web:{port}] {node.weed_banner()}", flush=True)
-        print(f"[web:{port}] weed control UI at http://{bind_host}:{port}/", flush=True)
+        print(f"[web:{port}] weed control UI at {scheme}://{bind_host}:{port}/", flush=True)
         if bind_host == '127.0.0.1':
             print("  bound to localhost only -- pass --bind 0.0.0.0 to reach this from your "
                   "phone (and get a scan-to-open QR here)", flush=True)
@@ -1324,9 +1663,21 @@ def main():
                               "or pointed at the wrong address (auto-detection guesses via an "
                               "outbound route, which can pick the wrong interface or fail "
                               "outright on unusual networking)")
+    parser.add_argument('--tls', action='store_true',
+                         help='enable HTTPS; auto-generates a self-signed cert if --cert/--key '
+                              'are not provided (required for Chromecast and other browser APIs '
+                              'that need a secure origin)')
+    parser.add_argument('--cert', metavar='CERTFILE',
+                         help='path to PEM certificate file (used with --tls; auto-generated if omitted)')
+    parser.add_argument('--key', metavar='KEYFILE',
+                         help='path to PEM private key file (used with --tls; auto-generated if omitted)')
     args = parser.parse_args()
     port = args.port_flag if args.port_flag is not None else args.port
-    run_web_ui(port, bind_host=args.bind, advertise_host=args.advertise_host)
+    certfile = args.cert or os.environ.get('WEED_TLS_CERT')
+    keyfile  = args.key  or os.environ.get('WEED_TLS_KEY')
+    tls = args.tls or bool(certfile)
+    run_web_ui(port, bind_host=args.bind, advertise_host=args.advertise_host,
+               tls=tls, certfile=certfile, keyfile=keyfile)
 
 
 if __name__ == '__main__':

{weed_cli-1.9.5 → weed_cli-2.0.2}/weed.py

@@ -157,6 +157,10 @@ def build_parser():
                         help='IP/hostname for the phone QR and lan-url instead of '
                              'auto-detecting it — use this if the startup QR was missing or '
                              'pointed at the wrong address')
+    p_web.add_argument('--tls', action='store_true',
+                        help='enable HTTPS; auto-generates a self-signed cert if --cert/--key omitted')
+    p_web.add_argument('--cert', metavar='CERTFILE', help='PEM certificate file (used with --tls)')
+    p_web.add_argument('--key', metavar='KEYFILE', help='PEM private key file (used with --tls)')
 
     p_serve = sub.add_parser('serve', help='alias for "web" with positional args, '
                                             'e.g. `serve 0.0.0.0 8080`')
@@ -273,7 +277,10 @@ def cmd_subscribe(args):
 
 def cmd_web(args):
     import web_ui
-    web_ui.run_web_ui(port=args.port, bind_host=args.bind, advertise_host=args.advertise_host)
+    web_ui.run_web_ui(port=args.port, bind_host=args.bind, advertise_host=args.advertise_host,
+                      tls=getattr(args, 'tls', False),
+                      certfile=getattr(args, 'cert', None),
+                      keyfile=getattr(args, 'key', None))
 
 
 NATIVE_COMMANDS = {

{weed_cli-1.9.5 → weed_cli-2.0.2}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.9.5
+Version: 2.0.2
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal

{weed_cli-1.9.5 → weed_cli-2.0.2}/weed_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ tests/test_dht.py
 tests/test_discovery_relay.py
 tests/test_host_live_reload.py
 tests/test_node_manifest.py
+tests/test_orbit_ws.py
 tests/test_web_ui_api.py
 tests/testutil.py
 weed_cli.egg-info/PKG-INFO