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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 2.7.0
+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
@@ -285,6 +285,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -335,8 +342,8 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield and
-Spectrum 3D, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
 blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
 Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
 draw perspective faces as runs of affine strips, since Canvas 2D has no
@@ -378,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.0 → weed_cli-2.7.2}/README.md

@@ -253,6 +253,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -303,8 +310,8 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield and
-Spectrum 3D, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
 blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
 Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
 draw perspective faces as runs of affine strips, since Canvas 2D has no
@@ -346,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.0 → 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.0 → 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.0 → weed_cli-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "2.7.0"
+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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0
+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
@@ -285,6 +285,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -335,8 +342,8 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield and
-Spectrum 3D, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
 blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
 Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
 draw perspective faces as runs of affine strips, since Canvas 2D has no
@@ -378,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.0/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')