weed-cli 1.2.3__tar.gz → 1.2.7__tar.gz

{weed_cli-1.2.3 → weed_cli-1.2.7}/PKG-INFO

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

{weed_cli-1.2.3 → weed_cli-1.2.7}/discovery_relay.py

@@ -20,14 +20,46 @@ Ed25519 signing):
   subscribe  {target_pubkey}                        — a viewer follows a creator/signer
 """
 import json
+import os
 import sys
+import threading
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import urlparse, parse_qs
 
-sys.path.insert(0, __import__('os').path.dirname(__import__('os').path.abspath(__file__)))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from poc_reputation import verify_attestation, attestation_id
 
-_events = []  # in-memory store — a real relay would use a real DB; irrelevant to the design
+# Events are still held in-memory for serving (a real relay would use a
+# real DB; irrelevant to the design) -- but write-through to a JSONL file
+# too, so a restart (deploy, crash, or Fly scaling this to zero when
+# idle) doesn't silently wipe every event that's ever been posted. Point
+# WEED_RELAY_DATA at a mounted Fly Volume path (e.g. /data/events.jsonl)
+# to survive machine restarts; the local relative-path default is fine
+# for dev/shell.py use where nothing's actually being deployed.
+DATA_PATH = os.environ.get('WEED_RELAY_DATA',
+                            os.path.join(os.path.dirname(os.path.abspath(__file__)), 'relay_events.jsonl'))
+_events = []
+_lock = threading.Lock()
+
+
+def _load_events():
+    if not os.path.exists(DATA_PATH):
+        return
+    with open(DATA_PATH) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                _events.append(json.loads(line))
+            except json.JSONDecodeError:
+                pass  # tolerate a truncated last line from a killed-mid-write process
+
+
+def _append_event(event):
+    os.makedirs(os.path.dirname(DATA_PATH) or '.', exist_ok=True)
+    with open(DATA_PATH, 'a') as f:
+        f.write(json.dumps(event) + '\n')
 
 
 class RelayHandler(BaseHTTPRequestHandler):
@@ -50,8 +82,10 @@ class RelayHandler(BaseHTTPRequestHandler):
             self.wfile.write(json.dumps({'ok': False, 'reason': reason}).encode())
             return
         eid = attestation_id(event)
-        if not any(attestation_id(e) == eid for e in _events):
-            _events.append(event)
+        with _lock:
+            if not any(attestation_id(e) == eid for e in _events):
+                _events.append(event)
+                _append_event(event)
         self.send_response(200)
         self.send_header('Content-Type', 'application/json')
         self.end_headers()
@@ -61,7 +95,8 @@ class RelayHandler(BaseHTTPRequestHandler):
         if self.path.split('?')[0] != '/events':
             self.send_response(404); self.end_headers(); return
         qs = parse_qs(urlparse(self.path).query)
-        out = _events
+        with _lock:
+            out = list(_events)
         if 'type' in qs:
             out = [e for e in out if e['payload'].get('type') == qs['type'][0]]
         self.send_response(200)
@@ -79,9 +114,11 @@ def run_relay_server(port, quiet=False):
     read, so the two interleave and the prompt looks like it "disappeared."
     The shell already prints its own equivalent confirmation line, so this
     fixes it at the source instead of patching the visual symptom."""
+    _load_events()
     srv = ThreadingHTTPServer(('0.0.0.0', port), RelayHandler)
     if not quiet:
-        print(f"[relay:{port}] up, no opinion on content, just store-and-forward", flush=True)
+        print(f"[relay:{port}] up, no opinion on content, just store-and-forward "
+              f"({len(_events)} event(s) loaded from {DATA_PATH})", flush=True)
     srv.serve_forever()
 
 

{weed_cli-1.2.3 → weed_cli-1.2.7}/node.py

@@ -825,7 +825,26 @@ def download_with_auction(content_hash, relay_urls, out_path=None, k=3, use_ligh
 
 # ── discovery + social signals ──────────────────────────────────────────
 
+def _relay_url_hint(relay_url):
+    """Relays are plain HTTP(S) endpoints, hit via urllib -- tls:// is a
+    completely different, unrelated convention that only means something
+    to --tunnel (a hand-rolled raw-TCP-plus-TLS protocol, see
+    _connect_tunnel_socket/connect_via_tunnel). Easy to mix up since both
+    flags take a host:port-shaped value and this same tool uses tls://
+    for the other one; without this check the failure is just urllib's
+    raw 'unknown url type: tls' with no hint about why."""
+    if relay_url.startswith('tls://'):
+        return (f"{relay_url!r} looks like a --tunnel address, not a relay URL — "
+                f"relays are plain HTTP(S) endpoints, try "
+                f"'https://{relay_url[len('tls://'):]}' for --relay instead "
+                f"(tls:// only means something to --tunnel)")
+    return None
+
+
 def post_event(relay_url, event):
+    hint = _relay_url_hint(relay_url)
+    if hint:
+        return {'ok': False, 'error': hint}
     req = urllib.request.Request(
         f'{relay_url}/event', data=json.dumps(event).encode(),
         headers={'Content-Type': 'application/json'}, method='POST')
@@ -845,6 +864,10 @@ def post_event(relay_url, event):
 
 
 def fetch_events(relay_url, event_type=None):
+    hint = _relay_url_hint(relay_url)
+    if hint:
+        print(f"  {relay_url}: {hint}")
+        return None
     url = f'{relay_url}/events' + (f'?type={event_type}' if event_type else '')
     try:
         with urllib.request.urlopen(url, timeout=5) as resp:

{weed_cli-1.2.3 → weed_cli-1.2.7}/pyproject.toml

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

@@ -52,7 +52,15 @@ class WeedShell(cmd.Cmd):
         self.identity = node.load_or_create_identity()
         self._last_discovery = []   # cache of the last `discover` results, for tab completion
         self._host_threads = []     # background host() threads started this session
-        self.default_relay = 'http://127.0.0.1:9101'
+        # $WEED_RELAY/$WEED_TUNNEL seed the session's defaults, same as
+        # weed.py's own CLI subcommands (see its _default_relay) -- so a
+        # real relay/tunnel deployment can be set once per shell session
+        # (or once in your shell rc) instead of retyped on every `host`/
+        # `discover`/`download`/`like`/`subscribe`. Explicit --relay/
+        # --tunnel on any command still always wins; `set` (below) can
+        # also change either mid-session.
+        self.default_relay = os.environ.get('WEED_RELAY', 'http://127.0.0.1:9101')
+        self.default_tunnel = os.environ.get('WEED_TUNNEL')
         self.dht_node = None        # active dht.DHTNode, once `dht start` has run
 
     def preloop(self):
@@ -103,15 +111,18 @@ class WeedShell(cmd.Cmd):
         — serve every archived file in archive_dir in a background thread
         (shell stays usable), one port, downloaders SELECT which by content
         hash. Pass --file to restrict to a single file. Announces each file
-        on --relay (default: your session's default relay — see `relay`)
-        unless --no-announce is given. --price sets what download charges
-        (default free). --tunnel registers with a tunnel_relay.py instead of
-        relying on a reachable inbound port — for hosting behind NAT/CGNAT.
-        Registers one control connection per file (REGISTER's token is
-        each file's own content hash), so a whole tree tunnels fine, not
-        just a single file. Prefix tls:// if the relay terminates TLS at
-        the edge (e.g. a Fly service with handlers = ["tls"]) — the relay
-        process itself never needs to know."""
+        on --relay (default: your session's default relay — see `relay`,
+        `set relay`, or $WEED_RELAY) unless --no-announce is given. --price
+        sets what download charges (default free). --tunnel registers with
+        a tunnel_relay.py instead of relying on a reachable inbound port —
+        for hosting behind NAT/CGNAT (default: your session's default
+        tunnel — see `set tunnel` or $WEED_TUNNEL). Registers one control
+        connection per file (REGISTER's token is each file's own content
+        hash), so a whole tree tunnels fine, not just a single file. Prefix
+        tls:// if the relay terminates TLS at the edge (e.g. a Fly service
+        with handlers = ["tls"]) — the relay process itself never needs to
+        know. An explicit --relay/--tunnel here also becomes the new
+        session default, same as `discover` already does for --relay."""
         parts = shlex.split(arg)
         if not parts:
             print('  usage: host <archive_dir> [--file NAME] [--port N] [--price SAT] '
@@ -125,7 +136,7 @@ class WeedShell(cmd.Cmd):
         relay = self.default_relay
         no_announce = '--no-announce' in parts
         advertise_host = '127.0.0.1'
-        tunnel = None
+        tunnel = self.default_tunnel
         i = 1
         while i < len(parts):
             if parts[i] == '--file' and i + 1 < len(parts):
@@ -148,6 +159,11 @@ class WeedShell(cmd.Cmd):
                 tunnel = parts[i]
             i += 1
 
+        # remember an explicit --relay/--tunnel for the rest of the
+        # session, same as `discover` already does for --relay
+        self.default_relay = relay
+        self.default_tunnel = tunnel
+
         entries = node.load_manifest_entries(archive_dir, file_name)
         # fail fast, before announcing anything — a manifest entry with no
         # matching chunk data would otherwise get announced to the relay
@@ -201,6 +217,36 @@ class WeedShell(cmd.Cmd):
         self.default_relay = f'http://127.0.0.1:{port}'
         print(f'  relay running on port {port} in the background — set as your default relay')
 
+    def complete_set(self, text, line, begidx, endidx):
+        parts = shlex.split(line[:begidx])
+        if len(parts) == 1:
+            return [s for s in ('relay', 'tunnel') if s.startswith(text)]
+        return []
+
+    def do_set(self, arg):
+        """set relay <URL>  — set the session's default relay directly,
+        without needing to start one (`relay`) or run `discover` first.
+        set tunnel <[tls://]HOST:PORT>  — same, for the default tunnel.
+        set  (no args)  — show both current defaults.
+        Either can also be set once via $WEED_RELAY/$WEED_TUNNEL before
+        launching the shell, and an explicit --relay/--tunnel on `host`
+        or `discover` updates the session default too."""
+        parts = shlex.split(arg)
+        if not parts:
+            print(f'  relay:  {self.default_relay or "(none)"}')
+            print(f'  tunnel: {self.default_tunnel or "(none)"}')
+            return
+        if len(parts) != 2 or parts[0] not in ('relay', 'tunnel'):
+            print('  usage: set relay <URL> | set tunnel <[tls://]HOST:PORT> | set')
+            return
+        what, value = parts
+        if what == 'relay':
+            self.default_relay = value
+            print(f'  default relay set to {value}')
+        else:
+            self.default_tunnel = value
+            print(f'  default tunnel set to {value}')
+
     def do_serve(self, arg):
         """serve [bind] [port]  — run the local web control UI in the background
         (default 127.0.0.1:8080; pass 0.0.0.0 to reach it from your phone).
@@ -297,7 +343,7 @@ class WeedShell(cmd.Cmd):
 
     def do_discover(self, arg):
         """discover [relay_url ...]  — list content announced on one or more relays
-        (default: the last relay used, or http://127.0.0.1:9101)."""
+        (default: the last relay used, $WEED_RELAY, or http://127.0.0.1:9101)."""
         relays = shlex.split(arg) or [self.default_relay]
         self.default_relay = relays[0]
         results = node.discover(relays)

{weed_cli-1.2.3 → weed_cli-1.2.7}/web_ui.py

@@ -137,7 +137,7 @@ def _rehydrate_jobs_from_library():
             'status': 'done', 'idx': 0, 'n_chunks': None,
             'content_hash': content_hash, 'path': rec['path'],
             'title': rec.get('title'), 'size': rec.get('size'), 'bps': rec.get('bps'),
-            'signer_pubkey': rec.get('signer_pubkey'), 'error': None,
+            'error': None,
         }
 _lan_url = None   # set once in run_web_ui() -- the base URL a phone on the
                    # same LAN can actually reach this server at, or None if
@@ -211,8 +211,7 @@ def _run_host_job(host_id, archive_dir, file_name, port, price, relay_urls, adve
             _hosts[host_id].update(status='error', error=f'{type(e).__name__}: {e}')
 
 
-def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightning, title=None,
-                       signer_pubkey=None):
+def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightning, title=None):
     def on_progress(idx, n_chunks):
         with _lock:
             _jobs[job_id].update(idx=idx, n_chunks=n_chunks)
@@ -230,7 +229,6 @@ 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,
             }
             _save_library()
     except SystemExit as e:
@@ -358,16 +356,13 @@ class Handler(BaseHTTPRequestHandler):
         k = int(body.get('k') or 3)
         use_lightning = bool(body.get('lightning'))
         title = body.get('title')
-        signer_pubkey = body.get('signer_pubkey')
 
         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}
+                              'content_hash': content_hash, 'path': None, 'title': title, 'error': None}
         threading.Thread(target=_run_download_job,
-                          args=(job_id, content_hash, relay_urls, out_path, k, use_lightning, title,
-                                signer_pubkey),
+                          args=(job_id, content_hash, relay_urls, out_path, k, use_lightning, title),
                           daemon=True).start()
         self._json({'job_id': job_id})
 

{weed_cli-1.2.3 → weed_cli-1.2.7}/weed.py

@@ -48,6 +48,26 @@ def run_make(target):
     sys.exit(result.returncode)
 
 
+# $WEED_RELAY/$WEED_TUNNEL let a real relay/tunnel deployment (not just
+# the loopback defaults everything below otherwise falls back to) be set
+# once per shell session instead of retyped on every host/discover/
+# download/like/subscribe invocation -- an explicit --relay/--tunnel
+# flag still always wins, this only changes what happens when neither is
+# given. shell.py's WeedShell reads the same two variables for the same
+# reason (see its own default_relay/default_tunnel).
+def _default_relay():
+    return os.environ.get('WEED_RELAY', 'http://127.0.0.1:9101')
+
+
+def _default_relay_list():
+    # --relay is action='append' on p_host specifically, which normally
+    # defaults to [] (empty = "don't announce anywhere" is a valid,
+    # deliberate choice there — see cmd_host) rather than falling back to
+    # loopback; only seed that list from $WEED_RELAY when it's actually set
+    relay = os.environ.get('WEED_RELAY')
+    return [relay] if relay else []
+
+
 def build_parser():
     import node
     parser = argparse.ArgumentParser(
@@ -73,21 +93,24 @@ def build_parser():
     p_host.add_argument('--file', help='which archived file, if more than one (default: most recent)')
     p_host.add_argument('--port', type=int, default=9201)
     p_host.add_argument('--price', type=int, default=0, help='sats to charge per download (default: free)')
-    p_host.add_argument('--relay', action='append', default=[], help='relay URL to announce on (repeatable)')
+    p_host.add_argument('--relay', action='append', default=_default_relay_list(),
+                         help='relay URL to announce on (repeatable; default: $WEED_RELAY if set)')
     p_host.add_argument('--advertise-host', default='127.0.0.1',
                          help='address to tell the relay to advertise (set this to your real '
                               'reachable IP if hosting off localhost — or use --tunnel if you '
                               'have no reachable address at all, e.g. behind NAT/CGNAT)')
-    p_host.add_argument('--tunnel', metavar='[tls://]RELAY_HOST:PORT',
+    p_host.add_argument('--tunnel', metavar='[tls://]RELAY_HOST:PORT', default=os.environ.get('WEED_TUNNEL'),
                          help='tunnel_relay.py address to register with instead of relying on a '
                               'reachable inbound port — see tunnel_relay.py. Downloaders connect '
                               'through the relay, not to you directly. Prefix with tls:// if the '
                               'relay terminates TLS at the edge (e.g. a Fly service with '
-                              'handlers = ["tls"]) — the relay process itself never needs to know')
+                              'handlers = ["tls"]) — the relay process itself never needs to know. '
+                              'Default: $WEED_TUNNEL if set.')
 
     p_discover = sub.add_parser('discover', help='list real content announced on one or more relays')
-    p_discover.add_argument('--relay', action='append', default=['http://127.0.0.1:9101'],
-                             help='relay URL to query (repeatable)')
+    p_discover.add_argument('--relay', action='append', default=[_default_relay()],
+                             help='relay URL to query (repeatable; default: $WEED_RELAY if set, '
+                                  'else http://127.0.0.1:9101)')
 
     p_download = sub.add_parser('download', aliases=['get'],
                                  help='discover, possession-challenge, auction, optionally pay, '
@@ -95,8 +118,9 @@ def build_parser():
     p_download.add_argument('content_hash', nargs='?', help='content hash to resolve via --relay')
     p_download.add_argument('--from', dest='from_addr', help='host:port to connect to directly, skipping '
                              'discovery/auction entirely (no possession challenge, no reputation, no payment)')
-    p_download.add_argument('--relay', action='append', default=['http://127.0.0.1:9101'],
-                             help='relay URL to resolve content_hash against (repeatable)')
+    p_download.add_argument('--relay', action='append', default=[_default_relay()],
+                             help='relay URL to resolve content_hash against (repeatable; '
+                                  'default: $WEED_RELAY if set, else http://127.0.0.1:9101)')
     p_download.add_argument('--out', help='output path (default: the advertised filename)')
     p_download.add_argument('--challenge-rounds', type=int, default=3,
                              help='chunks to sample-verify per candidate host before trusting it (default: 3)')
@@ -106,11 +130,13 @@ def build_parser():
 
     p_like = sub.add_parser('like', help='sign and post a real like event')
     p_like.add_argument('content_hash')
-    p_like.add_argument('--relay', default='http://127.0.0.1:9101')
+    p_like.add_argument('--relay', default=_default_relay(),
+                         help='default: $WEED_RELAY if set, else http://127.0.0.1:9101')
 
     p_subscribe = sub.add_parser('subscribe', help='sign and post a real subscribe event')
     p_subscribe.add_argument('target_pubkey')
-    p_subscribe.add_argument('--relay', default='http://127.0.0.1:9101')
+    p_subscribe.add_argument('--relay', default=_default_relay(),
+                              help='default: $WEED_RELAY if set, else http://127.0.0.1:9101')
 
     p_web = sub.add_parser('web', help='local web UI — discover/host/download/like/subscribe '
                                         'from a browser instead of the CLI')

{weed_cli-1.2.3 → weed_cli-1.2.7}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.2.3
+Version: 1.2.7
 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