weed-cli 1.6.2__tar.gz → 1.6.8__tar.gz

{weed_cli-1.6.2/weed_cli.egg-info → weed_cli-1.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.6.2
+Version: 1.6.8
 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
@@ -174,19 +174,28 @@ blind.
 ### Docker
 
 `Dockerfile.node` + `docker-compose.node.yml` package `web_ui.py` to run
-somewhere other than a laptop.
+somewhere other than a laptop — alongside its own local discovery relay
+(`Dockerfile.discovery-relay`), so there's always something real for it
+to announce to and discover from out of the box.
 
 ```bash
 make node                            # build + run, http://127.0.0.1:8080
 make node-down                       # stop it — data persists
+make node-shell                      # interactive weed shell, same container as the running node
 WEED_SHARE_DIR=~/Movies make node    # mount a real directory of .ott archives at /share
-docker compose -f docker-compose.node.yml exec node python3 shell.py   # interactive shell, same container
 docker compose -f docker-compose.node.yml exec node python3 weed.py discover  # or a one-off CLI command
 ```
 
 - Identity key, reputation store, and library manifest all persist in a
   named volume (`node-data`, mounted at `$HOME=/data`) — one node keeps
   the same pubkey (and everything vouching for it) across restarts.
+- The `relay` service is `node`'s default `WEED_RELAY` (`http://relay:9101`,
+  resolved over Compose's own network) — its events persist in their own
+  `relay-data` volume, and port 9101 is published to the host too, for
+  curling `/events` directly or pointing a non-Docker `weed`/shell session
+  at the exact same relay. Override `WEED_RELAY` (shell env or `.env`,
+  see `.env.sample`) to point at public infra instead, e.g. for a real
+  end-to-end test.
 - `/share` is a separate *bind* mount, not a named volume, so the actual
   `.ott` archives you're hosting are real files on the host you can see
   and manage directly. Point the web UI's Host form at `/share`.

{weed_cli-1.6.2 → weed_cli-1.6.8}/README.md

@@ -144,19 +144,28 @@ blind.
 ### Docker
 
 `Dockerfile.node` + `docker-compose.node.yml` package `web_ui.py` to run
-somewhere other than a laptop.
+somewhere other than a laptop — alongside its own local discovery relay
+(`Dockerfile.discovery-relay`), so there's always something real for it
+to announce to and discover from out of the box.
 
 ```bash
 make node                            # build + run, http://127.0.0.1:8080
 make node-down                       # stop it — data persists
+make node-shell                      # interactive weed shell, same container as the running node
 WEED_SHARE_DIR=~/Movies make node    # mount a real directory of .ott archives at /share
-docker compose -f docker-compose.node.yml exec node python3 shell.py   # interactive shell, same container
 docker compose -f docker-compose.node.yml exec node python3 weed.py discover  # or a one-off CLI command
 ```
 
 - Identity key, reputation store, and library manifest all persist in a
   named volume (`node-data`, mounted at `$HOME=/data`) — one node keeps
   the same pubkey (and everything vouching for it) across restarts.
+- The `relay` service is `node`'s default `WEED_RELAY` (`http://relay:9101`,
+  resolved over Compose's own network) — its events persist in their own
+  `relay-data` volume, and port 9101 is published to the host too, for
+  curling `/events` directly or pointing a non-Docker `weed`/shell session
+  at the exact same relay. Override `WEED_RELAY` (shell env or `.env`,
+  see `.env.sample`) to point at public infra instead, e.g. for a real
+  end-to-end test.
 - `/share` is a separate *bind* mount, not a named volume, so the actual
   `.ott` archives you're hosting are real files on the host you can see
   and manage directly. Point the web UI's Host form at `/share`.

{weed_cli-1.6.2 → weed_cli-1.6.8}/node.py

@@ -1034,6 +1034,26 @@ def _relay_url_hint(relay_url):
     return None
 
 
+def _normalize_relay_url(relay_url):
+    """A bare host:port with no scheme (e.g. '127.0.0.1:9101', the most
+    natural way to type a local relay) isn't a URL urllib can parse at
+    all -- everything before the first ':' becomes the *scheme*, so this
+    reads as scheme '127.0.0.1' and raises "unknown url type", not a
+    connection error. That already lands on post_event/fetch_events'
+    existing except clauses (an unreachable relay is routine, not
+    exceptional), which is exactly the trap: hosting against a
+    scheme-less relay used to report status: running with zero actual
+    announcements ever reaching it, and discover against one silently
+    came back empty -- nothing hinted that the URL itself, not the
+    relay, was the problem. Every relay this project actually ships or
+    documents is plain HTTP(S), so defaulting a missing scheme to
+    http:// turns the common typo into the thing the user obviously
+    meant instead of a silent no-op."""
+    if '://' not in relay_url:
+        return 'http://' + relay_url
+    return relay_url
+
+
 _dns_bound_pool = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_prefix='urlopen')
 
 
@@ -1059,6 +1079,7 @@ def post_event(relay_url, event):
     hint = _relay_url_hint(relay_url)
     if hint:
         return {'ok': False, 'error': hint}
+    relay_url = _normalize_relay_url(relay_url)
     req = urllib.request.Request(
         f'{relay_url}/event', data=json.dumps(event).encode(),
         headers={'Content-Type': 'application/json'}, method='POST')
@@ -1082,6 +1103,7 @@ def fetch_events(relay_url, event_type=None):
     if hint:
         print(f"  {relay_url}: {hint}")
         return None
+    relay_url = _normalize_relay_url(relay_url)
     url = f'{relay_url}/events' + (f'?type={event_type}' if event_type else '')
     try:
         with _urlopen_bounded(url, timeout=5) as resp:

{weed_cli-1.6.2 → weed_cli-1.6.8}/pyproject.toml

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

@@ -179,6 +179,23 @@ class WeedShell(cmd.Cmd):
         # and only fail later, in the background server thread (onecmd's
         # exception net doesn't reach into background threads)
         all_leaves = {e['sha256']: node.load_leaves(archive_dir, e['sha256']) for e in entries}
+        # Same reasoning as web_ui.py's _run_host_job: bind the real,
+        # permanent listening socket now, before announcing anything to a
+        # relay, and hand this exact socket to run_host_server below
+        # instead of it binding a second one later. Without this, a port
+        # already in use (another `host` still running from earlier in
+        # this same session, or a persisted web-UI host on the same
+        # default port) only fails once the background thread started
+        # below gets around to its own bind — by then `announced ... on
+        # relay: {'ok': True, ...}` has already printed, and the relay
+        # has a listing for a host that was never actually reachable, with
+        # nothing pointing back at why until a downloader's own possession
+        # challenge mysteriously fails against it.
+        try:
+            bound_sock = node.bind_host_port(port)
+        except OSError as e:
+            print(f'  ✗ cannot bind port {port}: {e} — not announcing, nothing started')
+            return
         if relay and not no_announce:
             ott_status = node.ott_commit_status(archive_dir)
             for entry in entries:
@@ -204,7 +221,8 @@ class WeedShell(cmd.Cmd):
                 self._host_threads.append(tt)
         t = threading.Thread(target=_bg,
                               args=(node.run_host_server, archive_dir, file_name, port),
-                              kwargs={'quiet': True, 'price': price, 'ln_node': ln_node}, daemon=True)
+                              kwargs={'quiet': True, 'price': price, 'ln_node': ln_node, 'sock': bound_sock},
+                              daemon=True)
         t.start()
         self._host_threads.append(t)
         price_note = f', {price} sat/download' if price else ', free'

{weed_cli-1.6.2 → weed_cli-1.6.8}/web_ui.py

@@ -125,8 +125,14 @@ _lock = threading.Lock()
 # reload -- or a server restart -- doesn't forget any of it. Downloads
 # are keyed by content_hash (one record per piece of content, most
 # recent job wins); likes/subscriptions are just lists of hashes/pubkeys.
-# All access goes through _lock, same as _hosts/_jobs.
-_library = {'downloads': {}, 'likes': [], 'subscriptions': []}
+# playlists are purely local organization -- unlike likes/subscriptions
+# they're never signed or gossiped to a relay, nobody else has any
+# business seeing how you've grouped your own downloads -- a list of
+# {id, name, items: [{content_hash, title, signer_pubkey}, ...]}, id
+# stable across renames so the UI can keep pointing at the same playlist
+# while its name changes underneath it. All access goes through _lock,
+# same as _hosts/_jobs.
+_library = {'downloads': {}, 'likes': [], 'subscriptions': [], 'playlists': []}
 
 # what to (re-)host on startup -- _hosts above is pure in-memory runtime
 # state, so a restart (a fresh `make node`, a Docker container recreated
@@ -245,6 +251,7 @@ def _load_library():
             'downloads': data.get('downloads') or {},
             'likes': data.get('likes') or [],
             'subscriptions': data.get('subscriptions') or [],
+            'playlists': data.get('playlists') or [],
         }
     except (FileNotFoundError, json.JSONDecodeError):
         pass
@@ -351,8 +358,21 @@ def _run_host_job(host_id, archive_dir, file_name, port, price, relay_urls, adve
             for entry in entries:
                 for relay_url in relay_urls:
                     host_addr = f'{advertise_host}:{port}'
-                    node.publish(identity, relay_url, entry['sha256'], entry['name'], host_addr,
-                                  tunnel=tunnel, ott_status=ott_status)
+                    result = node.publish(identity, relay_url, entry['sha256'], entry['name'], host_addr,
+                                           tunnel=tunnel, ott_status=ott_status)
+                    # publish()/post_event() report a failed announce as a
+                    # normal {'ok': False, ...} return, not an exception (an
+                    # unreachable or malformed relay is routine, not
+                    # exceptional -- see post_event's own docstring) -- which
+                    # this loop used to just ignore entirely, so a host could
+                    # sit at status: running, "announced" on a relay it never
+                    # actually reached, with nothing in the UI to say so.
+                    # do_host (shell.py) already prints every result
+                    # unconditionally; this only prints the failures; a
+                    # working host's log staying free of routine "ok: True"
+                    # noise matters more here than in a CLI's own scrollback.
+                    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]
             with _lock:
@@ -479,6 +499,7 @@ class Handler(BaseHTTPRequestHandler):
                     'downloads': list(_library['downloads'].values()),
                     'likes': list(_library['likes']),
                     'subscriptions': list(_library['subscriptions']),
+                    'playlists': list(_library['playlists']),
                 })
         if path.startswith('/api/download/'):
             job_id = path[len('/api/download/'):]
@@ -539,6 +560,12 @@ class Handler(BaseHTTPRequestHandler):
             '/api/host': self._handle_host, '/api/download': self._handle_download,
             '/api/like': self._handle_like, '/api/subscribe': self._handle_subscribe,
             '/api/verify': self._handle_verify,
+            '/api/playlists/create': self._handle_playlist_create,
+            '/api/playlists/rename': self._handle_playlist_rename,
+            '/api/playlists/delete': self._handle_playlist_delete,
+            '/api/playlists/add': self._handle_playlist_add,
+            '/api/playlists/remove': self._handle_playlist_remove,
+            '/api/playlists/move': self._handle_playlist_move,
         }
         handler = handlers.get(path)
         if not handler:
@@ -617,6 +644,94 @@ class Handler(BaseHTTPRequestHandler):
                 _save_library()
         self._json({'result': result})
 
+    def _handle_playlist_create(self, body):
+        name = (body.get('name') or '').strip()
+        if not name:
+            return self._json({'error': 'name required'}, status=400)
+        playlist = {'id': uuid.uuid4().hex[:12], 'name': name, 'items': []}
+        with _lock:
+            _library['playlists'].append(playlist)
+            _save_library()
+        self._json({'playlist': playlist})
+
+    def _handle_playlist_rename(self, body):
+        playlist_id = body.get('playlist_id')
+        name = (body.get('name') or '').strip()
+        if not playlist_id or not name:
+            return self._json({'error': 'playlist_id and name required'}, status=400)
+        with _lock:
+            playlist = next((p for p in _library['playlists'] if p['id'] == playlist_id), None)
+            if not playlist:
+                return self._json({'error': 'no such playlist'}, status=404)
+            playlist['name'] = name
+            _save_library()
+            self._json({'playlist': playlist})
+
+    def _handle_playlist_delete(self, body):
+        playlist_id = body.get('playlist_id')
+        if not playlist_id:
+            return self._json({'error': 'playlist_id required'}, status=400)
+        with _lock:
+            _library['playlists'] = [p for p in _library['playlists'] if p['id'] != playlist_id]
+            _save_library()
+        self._json({'ok': True})
+
+    def _handle_playlist_add(self, body):
+        playlist_id = body.get('playlist_id')
+        content_hash = body.get('content_hash')
+        if not playlist_id or not content_hash:
+            return self._json({'error': 'playlist_id and content_hash required'}, status=400)
+        with _lock:
+            playlist = next((p for p in _library['playlists'] if p['id'] == playlist_id), None)
+            if not playlist:
+                return self._json({'error': 'no such playlist'}, status=404)
+            # re-adding something already in the playlist just moves it to
+            # this spot instead of piling up a duplicate entry -- same
+            # dedup-by-content_hash instinct _library['downloads'] already
+            # has, just for a list instead of a dict
+            playlist['items'] = [it for it in playlist['items'] if it['content_hash'] != content_hash]
+            playlist['items'].append({
+                'content_hash': content_hash,
+                'title': body.get('title') or None,
+                'signer_pubkey': body.get('signer_pubkey') or None,
+            })
+            _save_library()
+            self._json({'playlist': playlist})
+
+    def _handle_playlist_remove(self, body):
+        playlist_id = body.get('playlist_id')
+        content_hash = body.get('content_hash')
+        if not playlist_id or not content_hash:
+            return self._json({'error': 'playlist_id and content_hash required'}, status=400)
+        with _lock:
+            playlist = next((p for p in _library['playlists'] if p['id'] == playlist_id), None)
+            if not playlist:
+                return self._json({'error': 'no such playlist'}, status=404)
+            playlist['items'] = [it for it in playlist['items'] if it['content_hash'] != content_hash]
+            _save_library()
+            self._json({'playlist': playlist})
+
+    def _handle_playlist_move(self, body):
+        playlist_id = body.get('playlist_id')
+        content_hash = body.get('content_hash')
+        direction = body.get('direction')
+        if not playlist_id or not content_hash or direction not in ('up', 'down'):
+            return self._json({'error': "playlist_id, content_hash, and direction ('up'|'down') required"},
+                               status=400)
+        with _lock:
+            playlist = next((p for p in _library['playlists'] if p['id'] == playlist_id), None)
+            if not playlist:
+                return self._json({'error': 'no such playlist'}, status=404)
+            items = playlist['items']
+            idx = next((i for i, it in enumerate(items) if it['content_hash'] == content_hash), None)
+            if idx is None:
+                return self._json({'error': 'content_hash not in this playlist'}, status=404)
+            swap_with = idx - 1 if direction == 'up' else idx + 1
+            if 0 <= swap_with < len(items):
+                items[idx], items[swap_with] = items[swap_with], items[idx]
+                _save_library()
+            self._json({'playlist': playlist})
+
     def _handle_verify(self, body):
         """Re-checks an already-downloaded file against its own
         Merkle-committed chunk hashes without re-fetching it -- see

{weed_cli-1.6.2 → weed_cli-1.6.8}/weed.py

@@ -188,6 +188,18 @@ def cmd_host(args):
     # matching chunk data would otherwise get announced to the relay and
     # only fail later, in the background server thread
     all_leaves = {e['sha256']: node.load_leaves(args.archive_dir, e['sha256']) for e in entries}
+    # Bind the real listening socket now, before announcing anything --
+    # same reasoning as web_ui.py's _run_host_job and shell.py's do_host:
+    # a port already in use only used to surface once run_host_server got
+    # around to its own (later) bind, by which point every relay below
+    # had already been told this host is reachable at host_addr. Binding
+    # first and reusing the same socket in run_host_server (see sock=
+    # below) means a taken port fails loudly here instead, before a
+    # single relay ever hears about it.
+    try:
+        bound_sock = node.bind_host_port(args.port)
+    except OSError as e:
+        sys.exit(f'cannot bind port {args.port}: {e} — not announcing, nothing started')
     # one archive_dir, one merkle root, one commit -- computed once outside
     # the per-relay/per-entry loops below, not per file
     ott_status = node.ott_commit_status(args.archive_dir)
@@ -213,7 +225,7 @@ def cmd_host(args):
                               kwargs={'use_tls': use_tls, 'ln_node': args.lightning_node},
                               daemon=True).start()
     node.run_host_server(args.archive_dir, args.file, args.port, price=args.price,
-                          ln_node=args.lightning_node)
+                          ln_node=args.lightning_node, sock=bound_sock)
 
 
 def cmd_discover(args):

{weed_cli-1.6.2 → weed_cli-1.6.8/weed_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.6.2
+Version: 1.6.8
 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
@@ -174,19 +174,28 @@ blind.
 ### Docker
 
 `Dockerfile.node` + `docker-compose.node.yml` package `web_ui.py` to run
-somewhere other than a laptop.
+somewhere other than a laptop — alongside its own local discovery relay
+(`Dockerfile.discovery-relay`), so there's always something real for it
+to announce to and discover from out of the box.
 
 ```bash
 make node                            # build + run, http://127.0.0.1:8080
 make node-down                       # stop it — data persists
+make node-shell                      # interactive weed shell, same container as the running node
 WEED_SHARE_DIR=~/Movies make node    # mount a real directory of .ott archives at /share
-docker compose -f docker-compose.node.yml exec node python3 shell.py   # interactive shell, same container
 docker compose -f docker-compose.node.yml exec node python3 weed.py discover  # or a one-off CLI command
 ```
 
 - Identity key, reputation store, and library manifest all persist in a
   named volume (`node-data`, mounted at `$HOME=/data`) — one node keeps
   the same pubkey (and everything vouching for it) across restarts.
+- The `relay` service is `node`'s default `WEED_RELAY` (`http://relay:9101`,
+  resolved over Compose's own network) — its events persist in their own
+  `relay-data` volume, and port 9101 is published to the host too, for
+  curling `/events` directly or pointing a non-Docker `weed`/shell session
+  at the exact same relay. Override `WEED_RELAY` (shell env or `.env`,
+  see `.env.sample`) to point at public infra instead, e.g. for a real
+  end-to-end test.
 - `/share` is a separate *bind* mount, not a named volume, so the actual
   `.ott` archives you're hosting are real files on the host you can see
   and manage directly. Point the web UI's Host form at `/share`.