weed-cli 1.7.4__tar.gz → 1.8.0__tar.gz

{weed_cli-1.7.4/weed_cli.egg-info → weed_cli-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.7.4
+Version: 1.8.0
 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
@@ -20,6 +20,7 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
 Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: pytest-playwright>=0.5; extra == "dev"
 Provides-Extra: dht
 Requires-Dist: kademlia>=2.2; extra == "dht"
 Provides-Extra: qr

{weed_cli-1.7.4 → weed_cli-1.8.0}/node.py

@@ -232,7 +232,18 @@ def load_manifest_entries(archive_dir, file_name=None):
     """Every distinct file in the archive, not just one — find_manifest_entry
     collapses to a single entries[-1], which is exactly why `host <dir>` with
     no --file only ever served the single most-recently-added file out of a
-    45-video archive. Dedupes by name (last-write-wins, same convention)."""
+    45-video archive. Dedupes by name (last-write-wins, same convention).
+
+    Only 'video' entries are returned. Hosting depends on chunk data
+    (load_leaves) and per-chunk byte math (entry['chunk_size']), and ott
+    only ever writes either for video-type entries — everything else
+    (photos, or any file whose extension ott's is_video() doesn't
+    recognize, which is also where a plain .mp3 lands, since ott only has
+    two types) has chunk_size: None and no .ott/chunks/<hash>.json at all.
+    Filtering here, the one function every hosting path (weed.py,
+    shell.py, web_ui.py) goes through, means one non-video file sitting
+    in an archive_dir no longer poison-pills hosting everything else in
+    it with 'no chunks file at ...'."""
     archive_dir = os.path.expanduser(archive_dir)
     manifest_path = os.path.join(archive_dir, '.ott', 'manifest.jsonl')
     if not os.path.exists(manifest_path):
@@ -244,8 +255,15 @@ def load_manifest_entries(archive_dir, file_name=None):
     by_name = {}
     for e in raw:
         by_name[e['name']] = e
-    entries = list(by_name.values())
+    all_entries = list(by_name.values())
+    entries = [e for e in all_entries if e.get('type') == 'video']
     if not entries:
+        if all_entries:
+            n = len(all_entries)
+            sys.exit(f"no hostable video file found in {archive_dir}" +
+                     (f" matching {file_name}" if file_name else "") +
+                     f" — found {n} non-video entr{'y' if n == 1 else 'ies'} "
+                     f"(only video files can be hosted; see ott's is_video())")
         sys.exit(f"no archived file found in {archive_dir}" + (f" matching {file_name}" if file_name else ""))
     return entries
 

{weed_cli-1.7.4 → weed_cli-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "1.7.4"
+version = "1.8.0"
 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" }
@@ -36,6 +36,15 @@ dev = [
   "pytest>=8.0",
   "pytest-cov>=5.0",
   "ruff>=0.5",
+  # e2e (tests/e2e/) drives the real web UI in a real browser -- Python
+  # Playwright rather than the JS package, so `pip install -e .[dev]` is
+  # the only setup step; this repo otherwise has zero npm/node_modules
+  # footprint (web/ is vanilla JS, no build step -- see its own README
+  # note) and introducing one just for test tooling would be a bigger
+  # structural change than the tests themselves. Needs a Chromium binary
+  # too -- `playwright install chromium`, or point WEED_TEST_CHROMIUM at
+  # an existing one (see tests/e2e/conftest.py).
+  "pytest-playwright>=0.5",
 ]
 dht = [
   "kademlia>=2.2",
@@ -60,7 +69,7 @@ py-modules = [
 ]
 
 [tool.pytest.ini_options]
-testpaths = ["."]
+testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_functions = ["test_*"]
 

weed_cli-1.8.0/tests/test_discovery_relay.py

@@ -0,0 +1,115 @@
+"""
+discovery_relay.py + node.discover()/publish()/unpublish() against a real
+running relay (subprocess, real sockets) -- no mocking of HTTP or
+signatures. Covers the actual trust model: relays store-and-forward
+signed events and do nothing else, so "the network" only knows what a
+client explicitly told a relay it happened to reach.
+"""
+import time
+
+import node
+from poc_reputation import Identity
+
+
+def test_publish_then_discover_round_trip(relay):
+    identity = Identity('alice')
+    result = node.publish(identity, relay, content_hash='c' * 64, title='My Video',
+                           host_addr='127.0.0.1:9201')
+    assert result.get('ok') is True
+
+    results = node.discover([relay])
+    assert len(results) == 1
+    assert results[0]['content_hash'] == 'c' * 64
+    assert results[0]['title'] == 'My Video'
+    assert results[0]['signer_pubkey'] == identity.pubkey_hex()
+
+
+def test_tampered_event_rejected(relay):
+    """The relay verifies signatures itself (node.py's own module
+    docstring: 'garbage in doesn't get stored') -- posting a payload that
+    doesn't match its signature must be refused, not silently stored."""
+    identity = Identity('alice')
+    event = identity.sign_event('publish', content_hash='c' * 64, title='Real Title',
+                                 host='127.0.0.1:9201', tunnel=None, ott_status=None)
+    event['payload']['title'] = 'Tampered Title'  # mutate after signing
+
+    result = node.post_event(relay, event)
+    assert result.get('ok') is False
+
+    results = node.discover([relay])
+    assert results == []
+
+
+def test_unpublish_delists(relay):
+    identity = Identity('alice')
+    node.publish(identity, relay, content_hash='c' * 64, title='My Video', host_addr='127.0.0.1:9201')
+    assert len(node.discover([relay])) == 1
+
+    node.unpublish(identity, relay, content_hash='c' * 64)
+    assert node.discover([relay]) == []
+
+
+def test_republish_by_same_signer_replaces_not_duplicates(relay):
+    """Re-running `host` always signs a fresh ts -- discover() must key on
+    (content_hash, signer_pubkey) and keep only the newest, not grow one
+    entry per re-announcement forever."""
+    identity = Identity('alice')
+    node.publish(identity, relay, content_hash='c' * 64, title='v1', host_addr='127.0.0.1:9201')
+    time.sleep(0.01)
+    node.publish(identity, relay, content_hash='c' * 64, title='v2', host_addr='127.0.0.1:9202')
+
+    results = node.discover([relay])
+    assert len(results) == 1
+    assert results[0]['title'] == 'v2'
+    assert results[0]['host'] == '127.0.0.1:9202'
+
+
+def test_two_signers_same_content_both_show_up(relay):
+    """Keyed on (content_hash, signer_pubkey), not content_hash alone --
+    two independent hosts of the same file are two separate listings."""
+    alice, bob = Identity('alice'), Identity('bob')
+    node.publish(alice, relay, content_hash='c' * 64, title='v', host_addr='127.0.0.1:9201')
+    node.publish(bob, relay, content_hash='c' * 64, title='v', host_addr='127.0.0.1:9202')
+
+    results = node.discover([relay])
+    assert {r['signer_pubkey'] for r in results} == {alice.pubkey_hex(), bob.pubkey_hex()}
+
+
+def test_dead_relay_is_skipped_not_fatal(relay):
+    """One relay in the list being unreachable must not lose events that
+    genuinely live on a *different*, healthy relay -- discover() degrades,
+    it doesn't fail closed."""
+    identity = Identity('alice')
+    node.publish(identity, relay, content_hash='c' * 64, title='v', host_addr='127.0.0.1:9201')
+
+    dead_relay = 'http://127.0.0.1:1'  # nothing listens here
+    results = node.discover([relay, dead_relay])
+    assert len(results) == 1
+    assert results[0]['content_hash'] == 'c' * 64
+
+
+def test_content_only_on_a_relay_you_dont_query_is_invisible(relay, tmp_path):
+    """The actual answer to 'how long for full network coordination via
+    gossip': never, automatically -- relays never talk to each other.
+    Publishing to relay A and only ever querying relay B must not surface
+    the content, no matter what."""
+    import subprocess, sys, os
+    from testutil import free_port, wait_for_port
+
+    other_port = free_port()
+    env = dict(os.environ, WEED_RELAY_DATA=str(tmp_path / 'other_relay_events.jsonl'))
+    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    proc = subprocess.Popen([sys.executable, os.path.join(repo_root, 'discovery_relay.py'), str(other_port)],
+                             env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    try:
+        other_relay = f'http://127.0.0.1:{other_port}'
+        assert wait_for_port('127.0.0.1', other_port)
+
+        identity = Identity('alice')
+        node.publish(identity, other_relay, content_hash='c' * 64, title='v', host_addr='127.0.0.1:9201')
+
+        assert node.discover([relay]) == []  # querying the *other* relay only
+        assert len(node.discover([other_relay])) == 1  # but it's really there
+    finally:
+        proc.terminate()
+        proc.wait(timeout=5)

weed_cli-1.8.0/tests/test_node_manifest.py

@@ -0,0 +1,91 @@
+"""
+node.py's manifest/chunk-loading logic -- pure filesystem + JSON, no
+network, no servers. Includes a regression test for the real incident
+this session: an .mp3 in the same archive_dir as a hosted video crashed
+`host` entirely (see node.load_manifest_entries's own docstring).
+"""
+import os
+
+import pytest
+
+import node
+from testutil import make_fake_archive
+
+
+def test_load_manifest_entries_single_video(tmp_path):
+    entry = make_fake_archive(tmp_path, name='good.mp4')
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert [e['sha256'] for e in entries] == [entry['sha256']]
+
+
+def test_load_manifest_entries_filters_non_video(tmp_path):
+    """The actual bug: an mp3 (typed 'image' by ott's extension-based
+    is_video()) sitting in the same archive_dir used to poison-pill
+    hosting the whole directory -- host <dir> with no --file should just
+    skip it and host the real video."""
+    video = make_fake_archive(tmp_path, name='good.mp4')
+    make_fake_archive(tmp_path, name='song.mp3', video=False)
+
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert [e['sha256'] for e in entries] == [video['sha256']]
+
+
+def test_load_manifest_entries_explicit_non_video_file_errors_clearly(tmp_path):
+    make_fake_archive(tmp_path, name='good.mp4')
+    make_fake_archive(tmp_path, name='song.mp3', video=False)
+
+    with pytest.raises(SystemExit, match='no hostable video file found'):
+        node.load_manifest_entries(str(tmp_path), 'song.mp3')
+
+
+def test_load_manifest_entries_no_manifest_at_all(tmp_path):
+    with pytest.raises(SystemExit, match='no .ott/manifest.jsonl'):
+        node.load_manifest_entries(str(tmp_path))
+
+
+def test_load_manifest_entries_dedupes_by_name_last_write_wins(tmp_path):
+    """Two manifest lines for the same file name (re-added after a real
+    edit) should collapse to the newer entry, not double-list it."""
+    os.makedirs(os.path.join(tmp_path, '.ott'), exist_ok=True)
+    manifest = os.path.join(tmp_path, '.ott', 'manifest.jsonl')
+    old = {'sha256': 'a' * 64, 'name': 'clip.mp4', 'orig_path': 'clip.mp4',
+           'last_path': str(tmp_path / 'clip.mp4'), 'size': 1, 'added': '2020-01-01T00:00:00Z',
+           'type': 'video', 'n_chunks': 1, 'chunk_size': 65536}
+    new = {**old, 'sha256': 'b' * 64, 'added': '2026-01-01T00:00:00Z'}
+    with open(manifest, 'w') as f:
+        f.write('%s\n%s\n' % (__import__('json').dumps(old), __import__('json').dumps(new)))
+
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert len(entries) == 1
+    assert entries[0]['sha256'] == 'b' * 64
+
+
+def test_load_leaves_round_trips_real_chunks(tmp_path):
+    entry = make_fake_archive(tmp_path, name='good.mp4', size=200_000, chunk_size=65_536)
+    leaves = node.load_leaves(str(tmp_path), entry['sha256'])
+    assert len(leaves) == entry['n_chunks']
+    assert len(leaves) > 1  # 200_000 bytes / 65_536 chunk_size genuinely spans multiple chunks
+
+
+def test_load_leaves_missing_chunks_file_errors_clearly(tmp_path):
+    entry = make_fake_archive(tmp_path, name='good.mp4', video=False)
+    with pytest.raises(SystemExit, match='no chunks file at'):
+        node.load_leaves(str(tmp_path), entry['sha256'])
+
+
+def test_resolve_file_path_prefers_last_path_when_it_exists(tmp_path):
+    entry = make_fake_archive(tmp_path, name='good.mp4')
+    resolved = node.resolve_file_path(entry, str(tmp_path))
+    assert resolved == entry['last_path']
+    assert os.path.exists(resolved)
+
+
+def test_resolve_file_path_falls_back_when_last_path_is_stale(tmp_path):
+    """last_path is recorded at archive time on whatever machine ran
+    `ott add` -- trusting it unconditionally breaks the moment archive_dir
+    is the same content mounted somewhere else (see node.py's own
+    docstring for the real Docker-bind-mount incident this guards)."""
+    entry = make_fake_archive(tmp_path, name='good.mp4')
+    entry['last_path'] = '/nonexistent/path/on/a/different/machine/good.mp4'
+    resolved = node.resolve_file_path(entry, str(tmp_path))
+    assert resolved == os.path.join(str(tmp_path), 'good.mp4')

weed_cli-1.8.0/tests/test_web_ui_api.py

@@ -0,0 +1,127 @@
+"""
+web_ui.py's REST API against a real, isolated WebUIServer instance (see
+conftest.web_server) -- real HTTP requests via the stdlib, same as the
+rest of this codebase's own "no new dependency" convention. Every
+identity/library/hosts file this touches is redirected into tmp_path by
+the isolated_paths fixture web_server depends on; nothing here can ever
+read or write a real ~/.weed_* file.
+"""
+from testutil import http_get_json, http_post_json
+
+
+def test_whoami_and_empty_library(web_server):
+    who = http_get_json(f'{web_server}/api/whoami')
+    assert len(who['pubkey']) == 64  # 32-byte Ed25519 pubkey, hex-encoded
+
+    lib = http_get_json(f'{web_server}/api/library')
+    assert lib == {'downloads': [], 'likes': [], 'subscriptions': [], 'playlists': [], 'history': []}
+
+
+def test_like_is_idempotent(web_server):
+    status, resp = http_post_json(f'{web_server}/api/like', {'content_hash': 'c' * 64})
+    assert status == 200
+    for _ in range(3):
+        http_post_json(f'{web_server}/api/like', {'content_hash': 'c' * 64})
+    lib = http_get_json(f'{web_server}/api/library')
+    assert lib['likes'] == ['c' * 64]
+
+
+def test_like_requires_content_hash(web_server):
+    status, resp = http_post_json(f'{web_server}/api/like', {})
+    assert status == 400
+    assert 'content_hash' in resp['error']
+
+
+def test_playlist_create_add_reorder_remove_delete(web_server):
+    status, resp = http_post_json(f'{web_server}/api/playlists/create', {'name': 'My List'})
+    assert status == 200
+    playlist_id = resp['playlist']['id']
+
+    for h in ('a' * 64, 'b' * 64):
+        status, resp = http_post_json(f'{web_server}/api/playlists/add', {
+            'playlist_id': playlist_id, 'content_hash': h, 'title': h[:8],
+        })
+        assert status == 200
+
+    lib = http_get_json(f'{web_server}/api/library')
+    pl = next(p for p in lib['playlists'] if p['id'] == playlist_id)
+    assert [it['content_hash'] for it in pl['items']] == ['a' * 64, 'b' * 64]
+
+    status, _ = http_post_json(f'{web_server}/api/playlists/reorder', {
+        'playlist_id': playlist_id, 'order': ['b' * 64, 'a' * 64],
+    })
+    assert status == 200
+    lib = http_get_json(f'{web_server}/api/library')
+    pl = next(p for p in lib['playlists'] if p['id'] == playlist_id)
+    assert [it['content_hash'] for it in pl['items']] == ['b' * 64, 'a' * 64]
+
+    status, _ = http_post_json(f'{web_server}/api/playlists/remove', {
+        'playlist_id': playlist_id, 'content_hash': 'a' * 64,
+    })
+    assert status == 200
+    lib = http_get_json(f'{web_server}/api/library')
+    pl = next(p for p in lib['playlists'] if p['id'] == playlist_id)
+    assert [it['content_hash'] for it in pl['items']] == ['b' * 64]
+
+    status, _ = http_post_json(f'{web_server}/api/playlists/delete', {'playlist_id': playlist_id})
+    assert status == 200
+    lib = http_get_json(f'{web_server}/api/library')
+    assert lib['playlists'] == []
+
+
+def test_play_requires_content_hash(web_server):
+    status, resp = http_post_json(f'{web_server}/api/play', {})
+    assert status == 400
+
+
+def test_play_bumps_count_and_history_for_a_known_download(web_server):
+    import web_ui
+    web_ui._library['downloads']['c' * 64] = {
+        'content_hash': 'c' * 64, 'job_id': 'job1', 'path': '/tmp/x.mp4',
+        'title': 'X', 'downloaded_at': 0, 'size': 1, 'bps': 1, 'signer_pubkey': None,
+    }
+
+    status, resp = http_post_json(f'{web_server}/api/play', {'content_hash': 'c' * 64, 'title': 'X'})
+    assert status == 200
+    assert resp['play_count'] == 1
+    assert resp['last_played'] is not None
+
+    status, resp = http_post_json(f'{web_server}/api/play', {'content_hash': 'c' * 64, 'title': 'X'})
+    assert resp['play_count'] == 2
+
+    lib = http_get_json(f'{web_server}/api/library')
+    rec = next(d for d in lib['downloads'] if d['content_hash'] == 'c' * 64)
+    assert rec['play_count'] == 2
+    assert len(lib['history']) == 2
+    assert lib['history'][0]['content_hash'] == 'c' * 64  # newest first
+
+
+def test_play_for_unknown_content_hash_still_logs_history_but_no_count(web_server):
+    """A play_count only exists on a downloads record -- playing something
+    that isn't (yet, or ever) in _library['downloads'] shouldn't 500, it
+    just can't report a play_count."""
+    status, resp = http_post_json(f'{web_server}/api/play', {'content_hash': 'z' * 64, 'title': 'Ghost'})
+    assert status == 200
+    assert resp['play_count'] is None
+
+    lib = http_get_json(f'{web_server}/api/library')
+    assert len(lib['history']) == 1
+    assert lib['history'][0]['title'] == 'Ghost'
+
+
+def test_cross_origin_post_rejected(web_server):
+    """No auth at all by design (see web_ui.py's module docstring) --
+    Origin-checking is the only thing standing between this and any other
+    open tab silently POSTing here. A request claiming a different Origin
+    must be refused."""
+    status, resp = http_post_json(f'{web_server}/api/like', {'content_hash': 'c' * 64},
+                                   headers={'Origin': 'http://evil.example'})
+    assert status == 403
+
+
+def test_request_with_no_origin_header_is_allowed(web_server):
+    """curl / server-to-server / direct API use never sets Origin -- only
+    a real cross-site browser request does, so a missing header is let
+    through (see web_ui.py's _check_origin docstring)."""
+    status, resp = http_post_json(f'{web_server}/api/like', {'content_hash': 'd' * 64})
+    assert status == 200

weed_cli-1.8.0/tests/testutil.py

@@ -0,0 +1,114 @@
+"""
+Plain (non-fixture) test helpers, deliberately NOT named conftest.py --
+pytest auto-imports every conftest.py it finds under a module name derived
+from its path, and tests/e2e/conftest.py needing helpers from
+tests/conftest.py hits a real name collision that way (both would want the
+bare module name "conftest" under this repo's flat, __init__.py-less
+layout). A uniquely-named module both conftest.py files can import from
+sidesteps that entirely.
+"""
+import http.client
+import hashlib
+import json
+import os
+import socket
+import time
+
+from ott import chunk_hashes, merkle_root
+
+
+def free_port():
+    """Ask the OS for a genuinely free port instead of guessing one and
+    racing every other test (and anything else on the machine) for it."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(('127.0.0.1', 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+def wait_for_port(host, port, timeout=5.0):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            with socket.create_connection((host, port), timeout=0.2):
+                return True
+        except OSError:
+            time.sleep(0.05)
+    return False
+
+
+def http_get(url):
+    conn_host, conn_port, path = _split_url(url)
+    conn = http.client.HTTPConnection(conn_host, conn_port, timeout=5)
+    try:
+        conn.request('GET', path)
+        resp = conn.getresponse()
+        return resp.read().decode()
+    finally:
+        conn.close()
+
+
+def http_get_json(url):
+    return json.loads(http_get(url))
+
+
+def http_post_json(url, body, headers=None):
+    conn_host, conn_port, path = _split_url(url)
+    conn = http.client.HTTPConnection(conn_host, conn_port, timeout=5)
+    try:
+        h = {'Content-Type': 'application/json'}
+        h.update(headers or {})
+        conn.request('POST', path, body=json.dumps(body), headers=h)
+        resp = conn.getresponse()
+        return resp.status, json.loads(resp.read().decode())
+    finally:
+        conn.close()
+
+
+def _split_url(url):
+    # http.client wants (host, port) and a bare path, not a full URL
+    assert url.startswith('http://')
+    rest = url[len('http://'):]
+    hostport, _, path = rest.partition('/')
+    host, _, port = hostport.partition(':')
+    return host, int(port), '/' + path
+
+
+def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_536, video=True):
+    """Hand-writes a minimal but real .ott/manifest.jsonl + chunks file --
+    real sha256 chunk hashes and a real merkle root via the same ott
+    helpers node.py itself calls, just skipping ott's own add/stage/commit
+    workflow (irrelevant to what node.py/web_ui.py actually read: the
+    final manifest.jsonl + chunks/<hash>.json shape). video=False produces
+    an 'image'-typed entry with no chunks file, for regression-testing the
+    mp3/photo-mixed-into-an-archive fix (load_manifest_entries filtering
+    to video-only)."""
+    os.makedirs(archive_dir, exist_ok=True)
+    ott_dir = os.path.join(archive_dir, '.ott')
+    os.makedirs(os.path.join(ott_dir, 'chunks'), exist_ok=True)
+    file_path = os.path.join(archive_dir, name)
+    with open(file_path, 'wb') as f:
+        f.write(os.urandom(size))
+
+    if video:
+        chunks = chunk_hashes(file_path, chunk_size)
+        digest = merkle_root(chunks)
+        entry = {
+            'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
+            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': 'video',
+            'n_chunks': len(chunks), 'chunk_size': chunk_size,
+        }
+        with open(os.path.join(ott_dir, 'chunks', f'{digest}.json'), 'w') as f:
+            json.dump(chunks, f)
+    else:
+        digest = hashlib.sha256(open(file_path, 'rb').read()).hexdigest()
+        entry = {
+            'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
+            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': 'image',
+            'n_chunks': 1, 'chunk_size': None,
+        }
+
+    with open(os.path.join(ott_dir, 'manifest.jsonl'), 'a') as f:
+        f.write(json.dumps(entry) + '\n')
+    return entry

{weed_cli-1.7.4 → weed_cli-1.8.0}/web_ui.py

@@ -45,6 +45,11 @@ WEB_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'web')
 DEFAULT_RELAY = os.environ.get('WEED_RELAY', 'http://127.0.0.1:9101')
 DEFAULT_TUNNEL = os.environ.get('WEED_TUNNEL')
 LIBRARY_PATH = os.path.expanduser('~/.weed_library.json')
+# play history is a log, not a set -- it grows forever otherwise (every
+# playlist "next" and every re-watch appends). This caps ~/.weed_library.json
+# from growing unbounded while still keeping far more history than anyone
+# is realistically going to scroll back through.
+MAX_HISTORY = 500
 # every real POST body here is a handful of JSON fields (hashes, URLs,
 # titles) -- no endpoint ever legitimately needs anywhere near this much,
 # it's purely a cap against a client claiming a huge Content-Length and
@@ -89,7 +94,8 @@ class _JobStdout:
         return getattr(self._real, name)
 
 
-sys.stdout = _JobStdout(sys.stdout)
+_job_stdout = _JobStdout(sys.stdout)
+sys.stdout = _job_stdout
 
 
 @contextlib.contextmanager
@@ -102,13 +108,27 @@ def _quiet():
     (...)" lines (exactly the detail that explains *why* a download
     failed) used to get captured here and then thrown away unread, so the
     web UI only ever showed "no candidate host passed the possession
-    challenge" with zero indication of which candidate failed how."""
+    challenge" with zero indication of which candidate failed how.
+
+    Re-asserts sys.stdout = _job_stdout on every call rather than trusting
+    it's still set from module-import time, and manipulates _job_stdout
+    directly rather than via sys.stdout -- something else with its own
+    reason to reassign sys.stdout globally afterward (pytest's own output
+    capturing is the concrete case that surfaced this: it swaps sys.stdout
+    to its own capture object between tests, silently detaching
+    _JobStdout from the global) would otherwise make this line crash with
+    an AttributeError on whatever replaced it, instead of muting output
+    like it's supposed to. Nothing in this app's own normal run path ever
+    reassigns sys.stdout again after the module-level line above, so this
+    is a no-op there -- purely a defensive re-assert."""
+    if sys.stdout is not _job_stdout:
+        sys.stdout = _job_stdout
     buf = io.StringIO()
-    sys.stdout._local.buf = buf
+    _job_stdout._local.buf = buf
     try:
         yield buf
     finally:
-        sys.stdout._local.buf = None
+        _job_stdout._local.buf = None
 
 
 def _with_captured_detail(msg, captured):
@@ -130,9 +150,12 @@ _lock = threading.Lock()
 # business seeing how you've grouped your own downloads -- a list of
 # {id, name, items: [{content_hash, title, signer_pubkey}, ...]}, id
 # stable across renames so the UI can keep pointing at the same playlist
-# while its name changes underneath it. All access goes through _lock,
-# same as _hosts/_jobs.
-_library = {'downloads': {}, 'likes': [], 'subscriptions': [], 'playlists': []}
+# while its name changes underneath it. history is a chronological log of
+# plays (newest last), each {content_hash, title, played_at} -- separate
+# from downloads' own play_count/last_played (see _handle_play) since
+# those two are aggregates per content_hash, while this is the actual
+# per-play timeline. All access goes through _lock, same as _hosts/_jobs.
+_library = {'downloads': {}, 'likes': [], 'subscriptions': [], 'playlists': [], 'history': []}
 
 # what to (re-)host on startup -- _hosts above is pure in-memory runtime
 # state, so a restart (a fresh `make node`, a Docker container recreated
@@ -252,6 +275,7 @@ def _load_library():
             'likes': data.get('likes') or [],
             'subscriptions': data.get('subscriptions') or [],
             'playlists': data.get('playlists') or [],
+            'history': data.get('history') or [],
         }
     except (FileNotFoundError, json.JSONDecodeError):
         pass
@@ -500,6 +524,9 @@ class Handler(BaseHTTPRequestHandler):
                     'likes': list(_library['likes']),
                     'subscriptions': list(_library['subscriptions']),
                     'playlists': list(_library['playlists']),
+                    # newest first -- the only order a "recently played" list
+                    # is ever actually consumed in
+                    'history': list(reversed(_library['history'])),
                 })
         if path.startswith('/api/download/'):
             job_id = path[len('/api/download/'):]
@@ -559,7 +586,7 @@ class Handler(BaseHTTPRequestHandler):
         handlers = {
             '/api/host': self._handle_host, '/api/download': self._handle_download,
             '/api/like': self._handle_like, '/api/subscribe': self._handle_subscribe,
-            '/api/verify': self._handle_verify,
+            '/api/verify': self._handle_verify, '/api/play': self._handle_play,
             '/api/playlists/create': self._handle_playlist_create,
             '/api/playlists/rename': self._handle_playlist_rename,
             '/api/playlists/delete': self._handle_playlist_delete,
@@ -644,6 +671,32 @@ class Handler(BaseHTTPRequestHandler):
                 _save_library()
         self._json({'result': result})
 
+    def _handle_play(self, body):
+        """Called once per openPlayer() on the frontend (Discover's ▶ Play,
+        a Downloads row, a playlist item, or onPlayerEnded's own auto-
+        advance) -- not inferred from /api/stream's byte-range requests,
+        which fire many times per single watch (seeking, buffering) and
+        would massively overcount. No relay/event involved, unlike
+        like/subscribe above -- what you've watched is purely local, same
+        reasoning as playlists' own docstring on why those aren't gossiped
+        either."""
+        content_hash = body.get('content_hash')
+        if not content_hash:
+            return self._json({'error': 'content_hash required'}, status=400)
+        now = time.time()
+        with _lock:
+            rec = _library['downloads'].get(content_hash)
+            title = body.get('title') or (rec.get('title') if rec else None)
+            play_count = None
+            if rec is not None:
+                rec['play_count'] = rec.get('play_count', 0) + 1
+                rec['last_played'] = now
+                play_count = rec['play_count']
+            _library['history'].append({'content_hash': content_hash, 'title': title, 'played_at': now})
+            _library['history'] = _library['history'][-MAX_HISTORY:]
+            _save_library()
+        self._json({'play_count': play_count, 'last_played': now})
+
     def _handle_playlist_create(self, body):
         name = (body.get('name') or '').strip()
         if not name:

{weed_cli-1.7.4 → weed_cli-1.8.0/weed_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.7.4
+Version: 1.8.0
 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
@@ -20,6 +20,7 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
 Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: pytest-playwright>=0.5; extra == "dev"
 Provides-Extra: dht
 Requires-Dist: kademlia>=2.2; extra == "dht"
 Provides-Extra: qr

{weed_cli-1.7.4 → weed_cli-1.8.0}/weed_cli.egg-info/SOURCES.txt

@@ -10,6 +10,10 @@ shell.py
 tunnel_relay.py
 web_ui.py
 weed.py
+tests/test_discovery_relay.py
+tests/test_node_manifest.py
+tests/test_web_ui_api.py
+tests/testutil.py
 weed_cli.egg-info/PKG-INFO
 weed_cli.egg-info/SOURCES.txt
 weed_cli.egg-info/dependency_links.txt

{weed_cli-1.7.4 → weed_cli-1.8.0}/weed_cli.egg-info/requires.txt

@@ -5,6 +5,7 @@ cryptography>=41.0
 pytest>=8.0
 pytest-cov>=5.0
 ruff>=0.5
+pytest-playwright>=0.5
 
 [dht]
 kademlia>=2.2