weed-cli 2.7.1__tar.gz → 2.7.2__tar.gz

{weed_cli-2.7.1 → weed_cli-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 2.7.1
+Version: 2.7.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
@@ -385,9 +385,26 @@ docker compose -f docker-compose.node.yml exec node python3 weed.py discover  #
   Python changes (`web_ui.py`, `node.py`) still need `make node`.
 - An entry's `last_path` (recorded at `ott add` time, on whatever
   machine ran it) is only trusted if it exists on disk; otherwise the
-  node falls back to the given archive directory. This matters the
-  moment the same content is mounted somewhere else than where it was
-  archived — e.g. `/share` here vs. wherever it originally lived.
+  node looks in the given archive directory at the entry's own
+  archive-relative path. This matters the moment the same content is
+  mounted somewhere else than where it was archived — e.g. `/share`
+  here vs. wherever it originally lived.
+- Subdirectories are fine: `ott add` walks a folder, records where
+  each file sits relative to the archive root, and `host` serves the
+  whole tree from one `.ott/`. Two files with the same name in
+  different subdirectories are two files; `--file Live/set.mkv` picks
+  one by its relative path. A folder dropped on the web UI's Host tab
+  is uploaded file by file into the same subdirectories.
+  Files moved into a folder after archiving are found too: `ott
+  fix-renames` (or `ott reindex`) records the new place, and the node
+  looks for a file under the archive by the tail of that path, so the
+  host machine's absolute path not existing inside a container doesn't
+  matter.
+  The folder travels with the listing (a `folder` field on the publish
+  event), so Discover shows it as a crumb ahead of the title with a
+  folder filter, a download keeps it for the Downloads tab's folder
+  chips and sort, the Active hosts table counts files and folders, and
+  the Kodi add-on has a **Folders** screen that walks the tree.
 
 ## Core mechanisms
 

{weed_cli-2.7.1 → weed_cli-2.7.2}/README.md

@@ -353,9 +353,26 @@ docker compose -f docker-compose.node.yml exec node python3 weed.py discover  #
   Python changes (`web_ui.py`, `node.py`) still need `make node`.
 - An entry's `last_path` (recorded at `ott add` time, on whatever
   machine ran it) is only trusted if it exists on disk; otherwise the
-  node falls back to the given archive directory. This matters the
-  moment the same content is mounted somewhere else than where it was
-  archived — e.g. `/share` here vs. wherever it originally lived.
+  node looks in the given archive directory at the entry's own
+  archive-relative path. This matters the moment the same content is
+  mounted somewhere else than where it was archived — e.g. `/share`
+  here vs. wherever it originally lived.
+- Subdirectories are fine: `ott add` walks a folder, records where
+  each file sits relative to the archive root, and `host` serves the
+  whole tree from one `.ott/`. Two files with the same name in
+  different subdirectories are two files; `--file Live/set.mkv` picks
+  one by its relative path. A folder dropped on the web UI's Host tab
+  is uploaded file by file into the same subdirectories.
+  Files moved into a folder after archiving are found too: `ott
+  fix-renames` (or `ott reindex`) records the new place, and the node
+  looks for a file under the archive by the tail of that path, so the
+  host machine's absolute path not existing inside a container doesn't
+  matter.
+  The folder travels with the listing (a `folder` field on the publish
+  event), so Discover shows it as a crumb ahead of the title with a
+  folder filter, a download keeps it for the Downloads tab's folder
+  chips and sort, the Active hosts table counts files and folders, and
+  the Kodi add-on has a **Folders** screen that walks the tree.
 
 ## Core mechanisms
 

{weed_cli-2.7.1 → weed_cli-2.7.2}/discovery_relay.py

@@ -55,7 +55,15 @@ MAX_BODY_SIZE = 256 * 1024
 # free -- but that's a fundamentally bigger attack (unlimited identities)
 # than "spam with one key," and defending against it needs proof-of-
 # work/stake, a bigger design decision than this PoC calls for.
-MAX_EVENTS_PER_SIGNER = 200
+# The cap counts *distinct* things a signer has said: a re-announce of a
+# file (every host start posts one per file) replaces that signer's
+# older publish/unpublish for the same content_hash rather than adding
+# to the pile, so a host with N files holds N events here however often
+# it restarts. Sized for a real library, not a demo -- 200 with the old
+# additive counting meant a 515-file host only ever had its last 200
+# announcements listed (Ryan: "Host shows 515 files in 18 folders, but I
+# only see a subset of those in Discover").
+MAX_EVENTS_PER_SIGNER = 5000
 
 
 def _load_events():
@@ -90,6 +98,26 @@ def _rewrite_events_file():
     os.replace(tmp, DATA_PATH)
 
 
+def _supersede(event):
+    """Caller must hold _lock. A signer's newer publish/unpublish for a
+    content_hash replaces their older one(s) for it; a stale post (older
+    ts than what's held) is the one dropped instead. Returns False when
+    the incoming event is the stale one and should not be stored."""
+    p = event['payload']
+    if p.get('type') not in ('publish', 'unpublish') or not p.get('content_hash') or not p.get('signer_pubkey'):
+        return True
+    same = [e for e in _events if e['payload'].get('type') in ('publish', 'unpublish')
+            and e['payload'].get('content_hash') == p['content_hash']
+            and e['payload'].get('signer_pubkey') == p['signer_pubkey']]
+    if any(e['payload'].get('ts', 0) > p.get('ts', 0) for e in same):
+        return False
+    if same:
+        for e in same:
+            _events.remove(e)
+        _rewrite_events_file()
+    return True
+
+
 def _evict_oldest_for_signer(signer_pubkey):
     """Caller must hold _lock. Drops that signer's own oldest event once
     they're at the cap, making room for the new one -- an active
@@ -133,7 +161,7 @@ class RelayHandler(BaseHTTPRequestHandler):
             return
         eid = attestation_id(event)
         with _lock:
-            if not any(attestation_id(e) == eid for e in _events):
+            if not any(attestation_id(e) == eid for e in _events) and _supersede(event):
                 _evict_oldest_for_signer(event['payload'].get('signer_pubkey'))
                 _events.append(event)
                 _append_event(event)

{weed_cli-2.7.1 → weed_cli-2.7.2}/node.py

@@ -214,6 +214,29 @@ class LineReader:
         return line.decode().strip()
 
 
+def entry_rel_path(entry):
+    """Where the file sits inside its archive: orig_path (ott records it
+    relative to the archive root, so a file added from a subdirectory
+    keeps that subdirectory) when it's a plain relative path, else the
+    bare name. Anything that could climb out of the archive (absolute,
+    or a '..' segment, which ott's own older entries could carry before
+    orig_path was anchored to the root) falls back to the name -- this
+    is joined onto archive_dir by resolve_file_path."""
+    raw = (entry.get('orig_path') or '').replace('\\', '/')
+    rel = raw.strip('/')
+    if not rel or raw.startswith('/') or os.path.isabs(raw) or '..' in rel.split('/'):
+        return entry['name']
+    return rel
+
+
+def _entry_matches(entry, file_name):
+    """--file / file_name matches the bare name or the archive-relative
+    path, so `--file Live/set.mkv` picks one of two files that share a
+    name in different subdirectories."""
+    wanted = file_name.replace('\\', '/').strip('/')
+    return entry['name'] == wanted or entry_rel_path(entry) == wanted
+
+
 def find_manifest_entry(archive_dir, file_name=None):
     archive_dir = os.path.expanduser(archive_dir)  # os.path.join never expands ~, it stays literal
     manifest_path = os.path.join(archive_dir, '.ott', 'manifest.jsonl')
@@ -222,7 +245,7 @@ def find_manifest_entry(archive_dir, file_name=None):
     with open(manifest_path) as f:
         entries = [json.loads(line) for line in f if line.strip()]
     if file_name:
-        entries = [e for e in entries if e['name'] == file_name]
+        entries = [e for e in entries if _entry_matches(e, file_name)]
     if not entries:
         sys.exit(f"no archived file found in {archive_dir}" + (f" matching {file_name}" if file_name else ""))
     return entries[-1]  # last-write-wins, same convention ott itself uses
@@ -232,7 +255,9 @@ 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 archive-relative path (last-write-wins,
+    same convention), so subdirectories are fine and a name can repeat
+    across them.
 
     Only 'video' and 'audio' entries are returned. Hosting depends on
     chunk data (load_leaves) and per-chunk byte math (entry['chunk_size']),
@@ -259,11 +284,14 @@ def load_manifest_entries(archive_dir, file_name=None):
         by_hash[e['sha256']] = e
     deduped = list(by_hash.values())
     if file_name:
-        deduped = [e for e in deduped if e['name'] == file_name]
-    by_name = {}
+        deduped = [e for e in deduped if _entry_matches(e, file_name)]
+    # then by where the file sits in the archive, not its bare name: two
+    # files called the same thing in different subdirectories are two
+    # files (Ryan: "can we support subdirectories?")
+    by_path = {}
     for e in deduped:
-        by_name[e['name']] = e
-    all_entries = list(by_name.values())
+        by_path[entry_rel_path(e)] = e
+    all_entries = list(by_path.values())
     entries = [e for e in all_entries if e.get('type') in ('video', 'audio')]
     if not entries:
         if all_entries:
@@ -300,7 +328,85 @@ def resolve_file_path(entry, archive_dir):
     last_path = entry.get('last_path')
     if last_path and os.path.exists(last_path):
         return last_path
-    return os.path.join(archive_dir, entry['name'])
+    # the file's place inside the archive first -- a file archived from
+    # a subdirectory lives there, not at the archive root -- then the
+    # bare name at the root for entries that predate orig_path
+    rel = entry_rel_path(entry)
+    candidate = os.path.join(archive_dir, *rel.split('/'))
+    if os.path.exists(candidate):
+        return candidate
+    # A file moved into a subfolder and fixed up with `ott fix-renames`
+    # has a fresh last_path but its old orig_path (only `ott reindex`
+    # re-anchors that), and from inside a container that last_path is
+    # the host machine's. Its tail is still where the file sits under
+    # the archive, so try the trailing segments, longest first (Ryan:
+    # "I ran `ott fix-renames` but it still shows them all as skipped").
+    if last_path:
+        parts = last_path.replace('\\', '/').strip('/').split('/')
+        for k in range(len(parts) - 1, 0, -1):
+            tail = os.path.join(archive_dir, *parts[-k:])
+            if os.path.exists(tail):
+                return tail
+    if rel != entry['name'] and os.path.exists(os.path.join(archive_dir, entry['name'])):
+        return os.path.join(archive_dir, entry['name'])
+    # Last resort: the file was moved inside the archive and nothing in
+    # its manifest entry says where (fix-renames wasn't run, or ran
+    # against another copy). Find it by name anywhere under archive_dir,
+    # the same size when there's a choice (Ryan: "I have files in
+    # ./share/folder, but they're not showing up anymore").
+    found = _archive_file_index(archive_dir).get(entry['name']) or []
+    if found:
+        same_size = [p for p in found if entry.get('size') is None or _size_of(p) == entry.get('size')]
+        pick = same_size or found
+        if len(pick) == 1 or same_size:
+            return pick[0]
+    return candidate
+
+
+def _size_of(path):
+    try:
+        return os.path.getsize(path)
+    except OSError:
+        return None
+
+
+_archive_index_cache = {}     # abspath(archive_dir) -> (built_at, {name: [paths]})
+ARCHIVE_INDEX_TTL = 30
+
+
+def _archive_file_index(archive_dir):
+    """Every file under archive_dir by bare name (the archive's own .ott/
+    and hidden directories skipped), rebuilt at most every
+    ARCHIVE_INDEX_TTL seconds, so resolving a whole archive of moved files
+    costs one walk rather than one per file."""
+    key = os.path.abspath(archive_dir)
+    hit = _archive_index_cache.get(key)
+    if hit and time.time() - hit[0] < ARCHIVE_INDEX_TTL:
+        return hit[1]
+    index = {}
+    for dirpath, dirs, files in os.walk(key):
+        dirs[:] = sorted(d for d in dirs if not d.startswith('.'))
+        for name in files:
+            index.setdefault(name, []).append(os.path.join(dirpath, name))
+    _archive_index_cache[key] = (time.time(), index)
+    return index
+
+
+def entry_archive_rel(entry, archive_dir):
+    """Where the file actually sits under archive_dir, as a '/'-joined
+    relative path ('Live/Paris 1993/set.mkv') -- what gets announced as
+    the folder and listed on a host. From the resolved file when it's
+    inside archive_dir (so a moved file reports its new folder even while
+    its manifest entry still says the old one), else the entry's own."""
+    archive_dir = os.path.expanduser(archive_dir)
+    path = resolve_file_path(entry, archive_dir)
+    try:
+        rel = os.path.relpath(os.path.abspath(path), os.path.abspath(archive_dir))
+    except ValueError:            # a different drive on Windows
+        return entry_rel_path(entry)
+    if rel.startswith('..'):
+        return entry_rel_path(entry)
+    return rel.replace(os.sep, '/')
 
 
 def _graceful_close(sock):
@@ -445,7 +551,8 @@ def _load_hostable_entries(archive_dir, file_name):
         if not os.path.exists(file_path):
             if file_name is not None or len(entries) == 1:
                 sys.exit(f"archived file not found on disk at {file_path}")
-            print(f"[host] skipping {entry.get('name')!r}: archived file not found on disk at {file_path}", file=sys.stderr)
+            print(f"[host] skipping {entry.get('name')!r}: archived file not found on disk at {file_path} "
+                  f"(nor anywhere under {archive_dir} by that name)", file=sys.stderr)
             continue
         leaves = load_leaves(archive_dir, entry['sha256'])
         entries_by_hash[entry['sha256']] = (entry, leaves, file_path)
@@ -1589,7 +1696,7 @@ def sync_relays(relay_urls, identity=None, all_signers=False, per_signer_cap=Non
     return {'relays': report, 'unreachable': unreachable, 'events': len(keep)}
 
 
-def publish(identity, relay_url, content_hash, title, host_addr, tunnel=None, ott_status=None):
+def publish(identity, relay_url, content_hash, title, host_addr, tunnel=None, ott_status=None, folder=None):
     """tunnel, if given, is 'relay_host:relay_port' for a tunnel_relay.py
     instance this host registered with — additive and backward compatible,
     same as the optional PRICE wire verb: an event without it just means
@@ -1609,6 +1716,11 @@ def publish(identity, relay_url, content_hash, title, host_addr, tunnel=None, ot
                   tunnel=tunnels[0] if tunnels else None, ott_status=ott_status)
     if len(tunnels) > 1:
         fields['tunnels'] = tunnels
+    # folder: where the file sits inside its archive ('Live/Paris 1993'),
+    # so a listing can show the tree the host has; same additive rule --
+    # a file at the archive root sends nothing new
+    if folder:
+        fields['folder'] = folder
     event = identity.sign_event('publish', **fields)
     return _post_to(relay_url, event)
 
@@ -1687,5 +1799,12 @@ def group_discover_by_content(results):
         rep = dict(group[0])
         rep['host_count'] = len(group)
         rep['hosts'] = [g['host'] for g in group]
+        # the folder from whichever publisher names one (newest first):
+        # a second host of the same file on an older build, or a mirror,
+        # announces without it, and its newer event must not blank it
+        for g in group:
+            if g.get('folder'):
+                rep['folder'] = g['folder']
+                break
         merged.append(rep)
     return merged

{weed_cli-2.7.1 → weed_cli-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "2.7.1"
+version = "2.7.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.7.1 → weed_cli-2.7.2}/shell.py

@@ -203,7 +203,8 @@ class WeedShell(cmd.Cmd):
             ott_status = node.ott_commit_status(archive_dir)
             for entry in entries:
                 result = node.publish(self.identity, relay, entry['sha256'], entry['name'],
-                                       f'{advertise_host}:{port}', tunnel=tunnel, ott_status=ott_status)
+                                       f'{advertise_host}:{port}', tunnel=tunnel, ott_status=ott_status,
+                    folder=os.path.dirname(node.entry_archive_rel(entry, archive_dir)) or None)
                 print(f'  announced {entry["name"]} on {relay}: {result}')
         elif not relay:
             print('  no relay set (run `relay` first, or pass --relay) — hosting without announcing')

{weed_cli-2.7.1 → weed_cli-2.7.2}/tests/test_discovery_relay.py

@@ -226,3 +226,34 @@ def test_publish_records_every_tunnel_in_failover_order(relay):
                  tunnel='127.0.0.1:9199')
     single = next(e for e in node.discover([relay]) if e['content_hash'] == 'd' * 64)
     assert single['tunnel'] == '127.0.0.1:9199' and 'tunnels' not in single   # unchanged shape
+
+
+def test_publish_carries_the_hosts_folder_only_when_there_is_one(relay):
+    """A file hosted from a subdirectory of its archive announces that
+    folder, so a listing can show the host's tree; a file at the root
+    sends the same event it always did."""
+    identity = node.load_or_create_identity()
+    assert node.publish(identity, relay, content_hash='e' * 64, title='set.mkv', host_addr='127.0.0.1:9201',
+                        folder='Live/Paris 1993').get('ok') is True
+    assert node.publish(identity, relay, content_hash='f' * 64, title='root.mkv', host_addr='127.0.0.1:9201').get('ok') is True
+    by_hash = {r['content_hash']: r for r in node.discover([relay])}
+    assert by_hash['e' * 64]['folder'] == 'Live/Paris 1993'
+    assert 'folder' not in by_hash['f' * 64]
+
+
+def test_a_re_announce_replaces_the_signers_older_event_for_that_file(relay):
+    """Ryan: "Host shows 515 files in 18 folders, but I only see a subset
+    of those in Discover" -- the relay's per-signer cap counted every
+    announcement, and a host re-announces every file on every start, so
+    a big library churned its own oldest listings out. A newer
+    publish/unpublish for the same content by the same signer now
+    replaces the older one, so the relay holds one event per file."""
+    import time
+    identity = node.load_or_create_identity()
+    for i in range(3):
+        node.publish(identity, relay, content_hash='1' * 64, title='same file', host_addr='127.0.0.1:%d' % (9201 + i))
+        time.sleep(0.01)
+    node.publish(identity, relay, content_hash='2' * 64, title='another', host_addr='127.0.0.1:9201')
+    mine = [e for e in node.fetch_events(relay, 'publish') if e['payload']['signer_pubkey'] == identity.pubkey_hex()]
+    assert sorted(e['payload']['content_hash'][0] for e in mine) == ['1', '2']          # one event per file, not three
+    assert next(e for e in mine if e['payload']['content_hash'][0] == '1')['payload']['host'] == '127.0.0.1:9203'   # the newest

{weed_cli-2.7.1 → weed_cli-2.7.2}/tests/test_kodi_addon.py

@@ -59,7 +59,7 @@ def test_root_and_downloads_list_finished_tracks_newest_first(web_server):
     _seed()
     ui = FakeUI(web_server)
     plugin.Plugin(ui).run()
-    assert [f[1] for f in ui.folders] == ['downloads', 'playlists', 'tags', 'party', 'live', 'live', 'live', 'autopilot']
+    assert [f[1] for f in ui.folders] == ['downloads', 'folders', 'playlists', 'tags', 'party', 'live', 'live', 'live', 'autopilot']
     ui = FakeUI(web_server)
     plugin.Plugin(ui).run(action='downloads')
     assert [m[0] for m in ui.items] == ['Track 2', 'Track 1', 'Track 0']          # newest first, extension dropped, no unfinished
@@ -187,7 +187,7 @@ def test_kodi_own_url_parameters_are_ignored(web_server):
     _seed()
     ui = FakeUI(web_server)
     plugin.Plugin(ui).run(content_type='video')
-    assert [f[1] for f in ui.folders][:2] == ['downloads', 'playlists'] and not ui.notices
+    assert [f[1] for f in ui.folders][:2] == ['downloads', 'folders'] and not ui.notices
     ui = FakeUI(web_server)
     plugin.Plugin(ui).run(action='downloads', content_type='audio', tag='chill')
     assert [m[0] for m in ui.items] == ['Track 1', 'Track 0'] and not ui.notices
@@ -265,3 +265,44 @@ def test_muxed_live_feed_needs_audio_and_ffmpeg(web_server, monkeypatch):
     ui = FakeUI(web_server)
     plugin.Plugin(ui).run(action='live', what='mux')
     assert ui.played == [(web_server + '/api/orbit-mux', 'weed Orbit', {'title': 'weed Orbit', 'mediatype': 'video'})]
+
+
+def test_folders_screen_walks_the_hosts_folder_tree(web_server):
+    """Ryan: "can the folder structure be visible in the web_ui and kodi
+    app?" A download remembers the folder its host announced; the Folders
+    screen lists subfolders (with counts, subfolders included) then the
+    files in the folder, and a track with no folder sits at the top."""
+    _seed()
+    with web_ui._lock:
+        web_ui._library['downloads']['a' * 64]['folder'] = 'Live/Paris 1993'
+        web_ui._library['downloads']['b' * 64]['folder'] = 'Live'
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='folders')
+    assert ui.folders == [('Live/ (2)', 'folders', {'path': 'Live'})]
+    assert [m[0] for m in ui.items] == ['Track 2']                               # the one with no folder
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='folders', path='Live')
+    assert ui.folders == [('Paris 1993/ (1)', 'folders', {'path': 'Live/Paris 1993'})]
+    assert [m[0] for m in ui.items] == ['Track 1']
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='folders', path='Live/Paris 1993')
+    assert ui.folders == [] and [m[0] for m in ui.items] == ['Track 0']
+    assert ui.ended == ['musicvideos']
+
+
+def test_folders_are_filled_in_for_downloads_made_before_folders_were_announced(web_server):
+    """Ryan: "when I open Folders in kodi, I just see files, no folders" --
+    the library's existing downloads carry no folder. The node fills one
+    in from what it's hosting itself (a file hosted and downloaded on the
+    same node), so the tree appears without re-downloading anything."""
+    _seed()
+    with web_ui._lock:
+        web_ui._hosts['h1'] = {'id': 'h1', 'status': 'running', 'name': 'x', 'files': [
+            {'name': 'Track 0.mp4', 'content_hash': 'a' * 64, 'path': 'Live/Paris 1993/Track 0.mp4'},
+            {'name': 'Track 1.mp4', 'content_hash': 'b' * 64, 'path': 'Track 1.mp4'}]}
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='folders')
+    assert ui.folders == [('Live/ (1)', 'folders', {'path': 'Live'})]
+    assert [m[0] for m in ui.items] == ['Track 2', 'Track 1']
+    with web_ui._lock:
+        assert web_ui._library['downloads']['a' * 64]['folder'] == 'Live/Paris 1993'   # kept on the record

weed_cli-2.7.2/tests/test_node_manifest.py

@@ -0,0 +1,201 @@
+"""
+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 original bug this filter exists for: a non-chunked file
+    (originally an mp3, back when ott's extension-based is_video() typed
+    it 'image' for lack of any 'audio' type at all -- see
+    test_load_manifest_entries_includes_audio_alongside_video below for
+    that no longer being true) sitting in the same archive_dir used to
+    poison-pill hosting the whole directory -- host <dir> with no --file
+    should just skip a genuinely non-hostable entry (a real photo, here)
+    and host the real video."""
+    video = make_fake_archive(tmp_path, name='good.mp4')
+    make_fake_archive(tmp_path, name='photo.jpg', content_type='image')
+
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert [e['sha256'] for e in entries] == [video['sha256']]
+
+
+def test_load_manifest_entries_includes_audio_alongside_video(tmp_path):
+    """Real ask: support audio (mp3, etc.) in addition to video. ott's
+    own cmd_add now chunks audio the same way it always has video (see
+    its own is_audio()), so an audio-typed manifest entry has real chunk
+    data too -- this is the one place every hosting path (weed.py,
+    shell.py, web_ui.py) filters on 'is this actually hostable', and it
+    needs to say yes to both now, not just video."""
+    video = make_fake_archive(tmp_path, name='good.mp4')
+    audio = make_fake_archive(tmp_path, name='song.mp3', content_type='audio')
+
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert {e['sha256'] for e in entries} == {video['sha256'], audio['sha256']}
+    # the audio entry got real chunk data, not the image-style single
+    # whole-file hash with no chunks
+    audio_entry = next(e for e in entries if e['sha256'] == audio['sha256'])
+    assert audio_entry['n_chunks'] > 1
+    assert node.load_leaves(str(tmp_path), audio['sha256']) is not None
+
+
+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='photo.jpg', content_type='image')
+
+    with pytest.raises(SystemExit, match='no hostable video/audio file found'):
+        node.load_manifest_entries(str(tmp_path), 'photo.jpg')
+
+
+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')
+
+
+def test_a_file_in_a_subdirectory_resolves_there_when_last_path_is_stale(tmp_path):
+    """Ryan: "can we support subdirectories?" ott records orig_path relative
+    to the archive root, so a file added from a subdirectory is found
+    there when its absolute last_path is from another machine (the Docker
+    bind mount case) -- not looked for by bare name at the root."""
+    entry = make_fake_archive(tmp_path, name='Live/Paris 1993/set.mkv')
+    entry['last_path'] = '/somewhere/else/set.mkv'
+    assert node.resolve_file_path(entry, str(tmp_path)) == os.path.join(str(tmp_path), 'Live', 'Paris 1993', 'set.mkv')
+    kept, by_hash = node._load_hostable_entries(str(tmp_path), None)
+    assert [e['sha256'] for e in kept] == [entry['sha256']]
+
+
+def test_the_same_name_in_two_subdirectories_is_two_files(tmp_path):
+    a = make_fake_archive(tmp_path, name='Studio/take.mp4')
+    b = make_fake_archive(tmp_path, name='Live/take.mp4')
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert sorted(e['sha256'] for e in entries) == sorted([a['sha256'], b['sha256']])
+    assert all(e['name'] == 'take.mp4' for e in entries)              # the bare name is what gets announced
+    # --file by the archive-relative path picks one; by bare name, both
+    assert [e['sha256'] for e in node.load_manifest_entries(str(tmp_path), 'Live/take.mp4')] == [b['sha256']]
+    assert len(node.load_manifest_entries(str(tmp_path), 'take.mp4')) == 2
+    assert node.find_manifest_entry(str(tmp_path), 'Studio/take.mp4')['sha256'] == a['sha256']
+
+
+def test_entry_rel_path_never_climbs_out_of_the_archive():
+    assert node.entry_rel_path({'name': 'x.mp4', 'orig_path': '../../etc/x.mp4'}) == 'x.mp4'
+    assert node.entry_rel_path({'name': 'x.mp4', 'orig_path': '/abs/x.mp4'}) == 'x.mp4'
+    assert node.entry_rel_path({'name': 'x.mp4', 'orig_path': 'Sub\\x.mp4'}) == 'Sub/x.mp4'
+    assert node.entry_rel_path({'name': 'x.mp4'}) == 'x.mp4'
+
+
+def test_a_file_moved_into_a_folder_and_fixed_with_ott_fix_renames_is_found_by_its_paths_tail(tmp_path):
+    """Ryan: "my old files which I moved into a folder ... I ran `ott
+    fix-renames` but it still shows them all as getting skipped".
+    fix-renames rewrites last_path (absolute, on the host machine) and
+    leaves orig_path as the old bare name; inside the container that
+    last_path doesn't exist. The node now tries the trailing segments of
+    last_path under the archive, so the file is found in its new folder,
+    hosted, and announced with that folder."""
+    entry = make_fake_archive(tmp_path, name='set.mkv')
+    os.makedirs(tmp_path / 'Live' / 'Paris 1993')
+    os.rename(tmp_path / 'set.mkv', tmp_path / 'Live' / 'Paris 1993' / 'set.mkv')
+    entry['last_path'] = '/home/ryan/share/Live/Paris 1993/set.mkv'     # what fix-renames wrote, on the host
+    assert entry['orig_path'] == 'set.mkv'                                # and what it left alone
+    assert node.resolve_file_path(entry, str(tmp_path)) == os.path.join(str(tmp_path), 'Live', 'Paris 1993', 'set.mkv')
+    assert node.entry_archive_rel(entry, str(tmp_path)) == 'Live/Paris 1993/set.mkv'
+    with open(os.path.join(str(tmp_path), '.ott', 'manifest.jsonl'), 'w') as f:
+        f.write(__import__('json').dumps(entry) + '\n')
+    kept, by_hash = node._load_hostable_entries(str(tmp_path), None)
+    assert [e['sha256'] for e in kept] == [entry['sha256']]
+
+
+def test_a_file_moved_into_a_folder_with_an_untouched_manifest_is_found_by_name_and_size(tmp_path):
+    """Ryan: "I have files in ./share/folder, but they're not showing up
+    anymore". Nothing on the entry says where the file went (last_path
+    still the old root location, orig_path the bare name), so the node
+    looks for it by name anywhere under the archive, taking the one of
+    the right size when the name repeats."""
+    entry = make_fake_archive(tmp_path, name='set.mkv', size=120_000)
+    os.makedirs(tmp_path / 'Mid-Air Thief' / 'Crumbling')
+    os.rename(tmp_path / 'set.mkv', tmp_path / 'Mid-Air Thief' / 'Crumbling' / 'set.mkv')
+    os.makedirs(tmp_path / 'Other')
+    with open(tmp_path / 'Other' / 'set.mkv', 'wb') as f:                          # a different file with the same name
+        f.write(b'x' * 10)
+    assert not os.path.exists(entry['last_path'])
+    node._archive_index_cache.clear()
+    assert node.resolve_file_path(entry, str(tmp_path)) == os.path.join(str(tmp_path), 'Mid-Air Thief', 'Crumbling', 'set.mkv')
+    assert node.entry_archive_rel(entry, str(tmp_path)) == 'Mid-Air Thief/Crumbling/set.mkv'
+    kept, by_hash = node._load_hostable_entries(str(tmp_path), None)
+    assert [e['sha256'] for e in kept] == [entry['sha256']]
+
+
+def test_discover_grouping_keeps_a_folder_any_publisher_named():
+    """Ryan: "the folder still doesn't show up in Discover. It does show
+    up in Downloads though". One row per content hash keeps the newest
+    publisher's fields; if that publisher (an older build, a mirror)
+    announced without a folder, the folder comes from one that did."""
+    rows = [
+        {'content_hash': 'a' * 64, 'signer_pubkey': 'old', 'host': '1.2.3.4:9201', 'title': 'set.mkv', 'ts': 200},
+        {'content_hash': 'a' * 64, 'signer_pubkey': 'new', 'host': '5.6.7.8:9201', 'title': 'set.mkv', 'ts': 100, 'folder': 'Live'},
+        {'content_hash': 'b' * 64, 'signer_pubkey': 'old', 'host': '1.2.3.4:9201', 'title': 'root.mkv', 'ts': 300},
+    ]
+    merged = {r['content_hash']: r for r in node.group_discover_by_content(rows)}
+    assert merged['a' * 64]['host'] == '1.2.3.4:9201' and merged['a' * 64]['folder'] == 'Live'
+    assert 'folder' not in merged['b' * 64]

{weed_cli-2.7.1 → weed_cli-2.7.2}/tests/test_web_ui_api.py

@@ -734,3 +734,36 @@ def test_tags_are_set_whole_normalised_and_kept_on_the_record(web_server):
     # a garbage payload clears rather than errors
     status, resp = http_post_json(f'{web_server}/api/tags', {'content_hash': h, 'tags': 'nope'})
     assert status == 200 and resp['tags'] == []
+
+
+def test_upload_keeps_a_dropped_folders_subdirectory(web_server, tmp_path):
+    """A folder dropped on the Host tab arrives file by file as
+    'Folder/Sub/clip.mp4' and lands in that subdirectory of archive_dir,
+    archived with orig_path relative to the archive root, so host finds it
+    there; '..' can't escape the archive."""
+    archive_dir = str(tmp_path / 'archive')
+    data = os.urandom(150_000)
+    status, resp = http_post_raw(_upload_url(web_server, 'Live/Paris 1993/set.mp4', archive_dir), data)
+    assert status == 200 and resp['ok'] is True
+    assert resp['name'] == 'set.mp4' and resp['path'] == 'Live/Paris 1993/set.mp4'
+    dest = os.path.join(archive_dir, 'Live', 'Paris 1993', 'set.mp4')
+    assert os.path.isfile(dest) and os.path.getsize(dest) == len(data)
+    entries = node.load_manifest_entries(archive_dir)
+    assert [(e['name'], e['orig_path']) for e in entries] == [('set.mp4', 'Live/Paris 1993/set.mp4')]
+    entries[0]['last_path'] = '/gone'
+    assert node.resolve_file_path(entries[0], archive_dir) == dest
+
+    status, resp = http_post_raw(_upload_url(web_server, 'Live/../../escape.mp4', archive_dir), b'x' * 10)
+    assert status == 200 and resp['path'] == 'Live/escape.mp4'                  # '..' segments dropped
+    assert not os.path.exists(os.path.join(str(tmp_path), 'escape.mp4'))
+
+
+def test_a_download_keeps_the_folder_its_listing_came_with(web_server):
+    """The Discover row's folder rides along on the download request and
+    is kept on the job (and, once it finishes, the library record), which
+    is what the Downloads tab's folder filter and Kodi's Folders read."""
+    status, resp = http_post_json(f'{web_server}/api/download',
+                                  {'content_hash': 'a' * 64, 'relay': ['http://127.0.0.1:1'], 'title': 'x', 'folder': '/Live/Paris 1993/'})
+    assert status == 200
+    job = http_get_json(f'{web_server}/api/download/' + resp['job_id'])
+    assert job['folder'] == 'Live/Paris 1993'

{weed_cli-2.7.1 → weed_cli-2.7.2}/tests/testutil.py

@@ -109,6 +109,7 @@ def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_
     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)
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)   # name may carry a subdirectory
     with open(file_path, 'wb') as f:
         f.write(os.urandom(size))
 
@@ -120,7 +121,7 @@ def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_
         chunks = chunk_hashes(file_path, chunk_size)
         digest = merkle_root(chunks)
         entry = {
-            'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
+            'sha256': digest, 'name': os.path.basename(name), 'orig_path': name, 'last_path': file_path,
             'size': size, 'added': '2026-01-01T00:00:00Z', 'type': content_type,
             'n_chunks': len(chunks), 'chunk_size': chunk_size,
         }
@@ -129,7 +130,7 @@ def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_
     else:
         digest = hashlib.sha256(open(file_path, 'rb').read()).hexdigest()
         entry = {
-            'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
+            'sha256': digest, 'name': os.path.basename(name), 'orig_path': name, 'last_path': file_path,
             'size': size, 'added': '2026-01-01T00:00:00Z', 'type': content_type,
             'n_chunks': 1, 'chunk_size': None,
         }

{weed_cli-2.7.1 → weed_cli-2.7.2}/web_ui.py

@@ -889,6 +889,55 @@ def _load_library():
         pass
 
 
+_folder_fetch = {'at': 0.0}
+
+
+def _backfill_folders(mapping):
+    """Give downloads that have no folder yet the one their content is
+    known to sit in -- from this node's own hosts (a file hosted and
+    downloaded on the same node) or a relay listing. Downloads made before
+    folders were announced have none on their record (Ryan: "when I open
+    Folders in kodi, I just see files, no folders"), and so would every
+    download of a listing announced by an older node."""
+    changed = False
+    with _lock:
+        for h, rec in _library['downloads'].items():
+            if not rec.get('folder') and mapping.get(h):
+                rec['folder'] = mapping[h]
+                changed = True
+        if changed:
+            _save_library()
+    return changed
+
+
+def _hosted_folders():
+    out = {}
+    with _lock:
+        for h in _hosts.values():
+            for f in h.get('files') or []:
+                folder = os.path.dirname(f.get('path') or '')
+                if folder:
+                    out[f['content_hash']] = folder
+    return out
+
+
+def _fill_folders_for_library():
+    """Before /api/library answers: the cheap local backfill every time,
+    and -- when something still has no folder -- a relay lookup in the
+    background at most every few minutes, so the next request has it."""
+    _backfill_folders(_hosted_folders())
+    with _lock:
+        missing = any(not rec.get('folder') and rec.get('job_id') for rec in _library['downloads'].values())
+    if missing and time.time() - _folder_fetch['at'] > 300:
+        _folder_fetch['at'] = time.time()
+        def fetch():
+            try:
+                _backfill_folders({r['content_hash']: r.get('folder') for r in node.discover([DEFAULT_RELAY])})
+            except Exception:
+                pass
+        threading.Thread(target=fetch, daemon=True).start()
+
+
 def _save_library():
     """Caller must hold _lock. Written to a tmp file + os.replace so a
     crash mid-write can't leave a half-written, unparseable JSON file
@@ -1006,7 +1055,8 @@ def _run_host_job(host_id, archive_dir, file_name, port, price, relay_urls, adve
                 for relay_url in relay_urls:
                     host_addr = f'{advertise_host}:{port}'
                     result = node.publish(identity, relay_url, entry['sha256'], entry['name'], host_addr,
-                                           tunnel=tunnel, ott_status=ott_status)
+                                           tunnel=tunnel, ott_status=ott_status,
+                                           folder=os.path.dirname(node.entry_archive_rel(entry, archive_dir)) or None)
                     # publish()/post_event() report a failed announce as a
                     # normal {'ok': False, ...} return, not an exception (an
                     # unreachable or malformed relay is routine, not
@@ -1021,7 +1071,7 @@ def _run_host_job(host_id, archive_dir, file_name, port, price, relay_urls, adve
                     if isinstance(result, dict) and not result.get('ok', True):
                         print(f'  ✗ announce to {relay_url} failed: {result.get("error")}')
                 announced = relay_urls
-            files = [{'name': e['name'], 'content_hash': e['sha256']} for e in entries]
+            files = [{'name': e['name'], 'content_hash': e['sha256'], 'path': node.entry_archive_rel(e, archive_dir)} for e in entries]
             with _lock:
                 _hosts[host_id].update(files=files, name=files[0]['name'],
                                         content_hash=files[0]['content_hash'],
@@ -1088,7 +1138,7 @@ def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightni
             _library['downloads'][content_hash] = {
                 'content_hash': content_hash, 'job_id': job_id, 'path': path,
                 'title': title, 'downloaded_at': time.time(), 'size': size, 'bps': bps,
-                'signer_pubkey': signer_pubkey,
+                'signer_pubkey': signer_pubkey, 'folder': _jobs[job_id].get('folder'),
                 **{k: prev[k] for k in ('tags', 'play_count', 'last_played') if k in prev},
             }
             _save_library()
@@ -1279,6 +1329,7 @@ class Handler(BaseHTTPRequestHandler):
             return self._handle_chat_get(qs)
         if path == '/api/discover':
             results = node.group_discover_by_content(node.discover(qs.get('relay') or [DEFAULT_RELAY]))
+            _backfill_folders({r['content_hash']: r.get('folder') for r in results})
             return self._json({'results': results})
         if path == '/api/hosts':
             with _lock:
@@ -1296,6 +1347,7 @@ class Handler(BaseHTTPRequestHandler):
                     h['ott_status'] = _ott_status(h['archive_dir'])
             return self._json({'hosts': hosts})
         if path == '/api/library':
+            _fill_folders_for_library()
             with _lock:
                 return self._json({
                     'downloads': list(_library['downloads'].values()),
@@ -1461,11 +1513,16 @@ class Handler(BaseHTTPRequestHandler):
         if not raw_name:
             return self._json({'error': 'name query param required'}, status=400)
 
-        # basename only -- '..' or an absolute path in the filename
-        # can't escape archive_dir this way
-        safe_name = os.path.basename(raw_name)
-        if not safe_name or safe_name in ('.', '..'):
+        # a dropped folder arrives as 'Folder/Sub/clip.mp4' and lands in
+        # that subdirectory of archive_dir. '..' and empty segments are
+        # dropped (an absolute path loses its leading slash the same
+        # way), so nothing can climb out of archive_dir -- same effect as
+        # the basename-only rule this replaces, for any file's own name
+        parts = [seg for seg in raw_name.replace('\\', '/').split('/') if seg not in ('', '.', '..')]
+        if not parts:
             return self._json({'error': f'invalid file name: {raw_name!r}'}, status=400)
+        safe_name = parts[-1]
+        rel_path = '/'.join(parts)
 
         if is_video(safe_name):
             content_type = 'video'
@@ -1478,8 +1535,8 @@ class Handler(BaseHTTPRequestHandler):
                 status=400)
 
         archive_dir = os.path.expanduser(archive_dir)
-        os.makedirs(archive_dir, exist_ok=True)
-        dest_path = os.path.join(archive_dir, safe_name)
+        dest_path = os.path.join(archive_dir, *parts)
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
 
         length = int(self.headers.get('Content-Length', 0))
         if length <= 0:
@@ -1519,7 +1576,7 @@ class Handler(BaseHTTPRequestHandler):
         chunks = chunk_hashes(dest_path, chunk_size)
         digest = merkle_root(chunks) if chunks else hashlib.sha256(b'').hexdigest()
         entry = {
-            'sha256': digest, 'name': safe_name, 'orig_path': safe_name, 'last_path': dest_path,
+            'sha256': digest, 'name': safe_name, 'orig_path': rel_path, 'last_path': dest_path,
             'size': written, 'added': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
             'type': content_type, 'n_chunks': len(chunks), 'chunk_size': chunk_size,
         }
@@ -1564,7 +1621,7 @@ class Handler(BaseHTTPRequestHandler):
                 f.write(existing + json.dumps(entry) + '\n')
             os.replace(manifest_tmp, manifest_path)
 
-        self._json({'ok': True, 'name': safe_name, 'content_hash': digest, 'type': content_type,
+        self._json({'ok': True, 'name': safe_name, 'path': rel_path, 'content_hash': digest, 'type': content_type,
                      'size': written, 'n_chunks': len(chunks), 'archive_dir': archive_dir})
 
     def _handle_host(self, body):
@@ -1652,12 +1709,13 @@ class Handler(BaseHTTPRequestHandler):
             return self._json({'error': "lightning requires lightning_node (who's paying)"}, status=400)
         title = body.get('title')
         signer_pubkey = body.get('signer_pubkey')
+        folder = (body.get('folder') or '').strip('/') or None   # the host's folder, from the listing
 
         job_id = uuid.uuid4().hex[:12]
         with _lock:
             _jobs[job_id] = {'status': 'running', 'idx': 0, 'n_chunks': None,
                               'content_hash': content_hash, 'path': None, 'title': title,
-                              'signer_pubkey': signer_pubkey, 'error': None}
+                              'signer_pubkey': signer_pubkey, 'folder': folder, 'error': None}
         threading.Thread(target=_run_download_job,
                           args=(job_id, content_hash, relay_urls, out_path, k, use_lightning, title,
                                 signer_pubkey),

{weed_cli-2.7.1 → weed_cli-2.7.2}/weed.py

@@ -256,7 +256,8 @@ def cmd_host(args):
         host_addr = f'{args.advertise_host}:{args.port}'
         for entry in entries:
             result = node.publish(identity, relay_url, entry['sha256'], entry['name'], host_addr,
-                                   tunnel=args.tunnel, ott_status=ott_status)
+                                   tunnel=args.tunnel, ott_status=ott_status,
+                folder=os.path.dirname(node.entry_archive_rel(entry, archive_dir)) or None)
             print(f"announced {entry['name']} on {relay_url}: {result}")
     # REGISTER's token is the file's own content hash (see
     # run_host_tunnel/connect_via_tunnel), so a whole tree just means one

{weed_cli-2.7.1 → weed_cli-2.7.2}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 2.7.1
+Version: 2.7.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
@@ -385,9 +385,26 @@ docker compose -f docker-compose.node.yml exec node python3 weed.py discover  #
   Python changes (`web_ui.py`, `node.py`) still need `make node`.
 - An entry's `last_path` (recorded at `ott add` time, on whatever
   machine ran it) is only trusted if it exists on disk; otherwise the
-  node falls back to the given archive directory. This matters the
-  moment the same content is mounted somewhere else than where it was
-  archived — e.g. `/share` here vs. wherever it originally lived.
+  node looks in the given archive directory at the entry's own
+  archive-relative path. This matters the moment the same content is
+  mounted somewhere else than where it was archived — e.g. `/share`
+  here vs. wherever it originally lived.
+- Subdirectories are fine: `ott add` walks a folder, records where
+  each file sits relative to the archive root, and `host` serves the
+  whole tree from one `.ott/`. Two files with the same name in
+  different subdirectories are two files; `--file Live/set.mkv` picks
+  one by its relative path. A folder dropped on the web UI's Host tab
+  is uploaded file by file into the same subdirectories.
+  Files moved into a folder after archiving are found too: `ott
+  fix-renames` (or `ott reindex`) records the new place, and the node
+  looks for a file under the archive by the tail of that path, so the
+  host machine's absolute path not existing inside a container doesn't
+  matter.
+  The folder travels with the listing (a `folder` field on the publish
+  event), so Discover shows it as a crumb ahead of the title with a
+  folder filter, a download keeps it for the Downloads tab's folder
+  chips and sort, the Active hosts table counts files and folders, and
+  the Kodi add-on has a **Folders** screen that walks the tree.
 
 ## Core mechanisms
 

weed_cli-2.7.1/tests/test_node_manifest.py

@@ -1,114 +0,0 @@
-"""
-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 original bug this filter exists for: a non-chunked file
-    (originally an mp3, back when ott's extension-based is_video() typed
-    it 'image' for lack of any 'audio' type at all -- see
-    test_load_manifest_entries_includes_audio_alongside_video below for
-    that no longer being true) sitting in the same archive_dir used to
-    poison-pill hosting the whole directory -- host <dir> with no --file
-    should just skip a genuinely non-hostable entry (a real photo, here)
-    and host the real video."""
-    video = make_fake_archive(tmp_path, name='good.mp4')
-    make_fake_archive(tmp_path, name='photo.jpg', content_type='image')
-
-    entries = node.load_manifest_entries(str(tmp_path))
-    assert [e['sha256'] for e in entries] == [video['sha256']]
-
-
-def test_load_manifest_entries_includes_audio_alongside_video(tmp_path):
-    """Real ask: support audio (mp3, etc.) in addition to video. ott's
-    own cmd_add now chunks audio the same way it always has video (see
-    its own is_audio()), so an audio-typed manifest entry has real chunk
-    data too -- this is the one place every hosting path (weed.py,
-    shell.py, web_ui.py) filters on 'is this actually hostable', and it
-    needs to say yes to both now, not just video."""
-    video = make_fake_archive(tmp_path, name='good.mp4')
-    audio = make_fake_archive(tmp_path, name='song.mp3', content_type='audio')
-
-    entries = node.load_manifest_entries(str(tmp_path))
-    assert {e['sha256'] for e in entries} == {video['sha256'], audio['sha256']}
-    # the audio entry got real chunk data, not the image-style single
-    # whole-file hash with no chunks
-    audio_entry = next(e for e in entries if e['sha256'] == audio['sha256'])
-    assert audio_entry['n_chunks'] > 1
-    assert node.load_leaves(str(tmp_path), audio['sha256']) is not None
-
-
-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='photo.jpg', content_type='image')
-
-    with pytest.raises(SystemExit, match='no hostable video/audio file found'):
-        node.load_manifest_entries(str(tmp_path), 'photo.jpg')
-
-
-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')