remoteRF-server 0.1.63__tar.gz → 0.1.64__tar.gz

{remoterf_server-0.1.63 → remoterf_server-0.1.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.63
+Version: 0.1.64
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf

{remoterf_server-0.1.63 → remoterf_server-0.1.64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "0.1.63"
+version = "0.1.64"
 dependencies = [
   "grpcio",
   "protobuf",

{remoterf_server-0.1.63 → remoterf_server-0.1.64}/src/remoteRF_server/host/host_tunnel_server.py

@@ -34,10 +34,12 @@ from .host_directory_store import (
 
 import hashlib
 
+
 def host_key(host_id: str) -> str:
     h = hashlib.sha256((host_id or "").encode("utf-8")).hexdigest()
     return h[:16]  # short stable key
 
+
 def _copy_argument_map(dst_map: Any, src_map: Any) -> None:
     if src_map is None:
         return
@@ -108,6 +110,7 @@ class HostSession:
                     fut.set_exception(RuntimeError(f"Host '{self.host_id}' disconnected"))
             self.inflight.clear()
 
+
 class HostTunnelRegistry:
     """
     Persistent host/device directory + live sessions.
@@ -193,16 +196,6 @@ class HostTunnelRegistry:
         known_hosts = csv_split(kv_lists.get("KNOWN_HOSTS", ""))
         known_devices = csv_split(kv_lists.get("KNOWN_DEVICES", ""))
 
-        # also accept hosts referenced by HOST_*_DEVICES keys even if KNOWN_HOSTS drifted
-        hosts_from_keys: Set[str] = set()
-        for k, v in kv_lists.items():
-            if k.startswith("HOST_") and k.endswith("_DEVICES"):
-                # We don't know the original host_id from the sanitized key reliably.
-                # That's fine; we still load routes primarily from DEVICE_*_HOST in meta.
-                # But we DO want to retain the device list; we’ll stitch it via meta host ids.
-                # So: just collect devices from these keys.
-                pass
-
         # Reset directory + status (do not touch live sessions)
         with self._lock:
             self._routes.clear()
@@ -223,9 +216,6 @@ class HostTunnelRegistry:
                 if k.startswith("HOST_") and k.endswith("_DEVICES"):
                     devices_from_host_lists.update(csv_split(v))
 
-            devices_from_meta: Set[str] = set()
-            # any DEVICE_<X>_HOST implies a known device id (but we can’t reverse sanitize_env_key)
-            # so we rely on KNOWN_DEVICES + HOST_*_DEVICES as primary device-id sources.
             # meta augments those devices; it can’t introduce new raw device ids safely.
             all_devices: List[str] = sorted(set(known_devices) | devices_from_host_lists)
 
@@ -247,15 +237,11 @@ class HostTunnelRegistry:
                 kind = (kv_meta.get(f"DEVICE_{dk}_KIND", "") or "").strip()
 
                 if host_id:
-                    # ensure host exists
                     if host_id not in self._host_status:
                         self._host_status[host_id] = HostStatus(host_id=host_id, online=False, last_seen_ms=0)
                     self._host_devices.setdefault(host_id, set()).add(device_id)
-
-                    # route exists even while offline
                     self._routes[device_id] = DeviceRoute(host_id=host_id, host_local_id=int(local_id))
 
-                # keep info visible even when offline
                 self._device_infos[device_id] = host_tunnel_pb2.DeviceInfo(
                     device_id=str(device_id),
                     local_id=int(local_id),
@@ -277,6 +263,7 @@ class HostTunnelRegistry:
     # ---------------------------
     # persistence write helpers
     # ---------------------------
+
     def _persist_host_meta(self, host_id: str, *, host_name: str = "", platform: str = "", version: str = "") -> None:
         hk = host_key(host_id)
         self._env_meta.set_kv_if_absent(f"HOST_{hk}_ID", host_id)
@@ -287,6 +274,18 @@ class HostTunnelRegistry:
         if version:
             self._env_meta.upsert_kv(f"HOST_{hk}_VERSION", version)
 
+    def persist_host_meta_from_hello(self, hello: Any) -> None:
+        """
+        Safe helper so HostTunnelServicer can persist from HostHello without needing to know field names.
+        """
+        try:
+            hid = str(getattr(hello, "host_id", "") or "").strip()
+            ver = str(getattr(hello, "version", "") or "").strip()
+            if hid:
+                self._persist_host_meta(hid, version=ver)
+        except Exception:
+            pass
+
     def _persist_host(self, host_id: str) -> None:
         self._env_lists.append_to_csv_list("KNOWN_HOSTS", host_id)
 
@@ -296,7 +295,6 @@ class HostTunnelRegistry:
         self._env_meta.set_kv_if_absent(f"HOST_{hk}_ID", host_id)  # reverse map
         self._env_lists.append_to_csv_list(f"HOST_{hk}_DEVICES", device_id)
 
-
         dk = sanitize_env_key(device_id)
         self._env_meta.upsert_kv(f"DEVICE_{dk}_HOST", host_id)
         self._env_meta.upsert_kv(f"DEVICE_{dk}_LOCAL_ID", str(int(local_id)))
@@ -367,8 +365,6 @@ class HostTunnelRegistry:
                     ds.online = True
                     ds.last_seen_ms = now
 
-            # no need to invalidate full cache; active-cache TTL handles this
-            # but host status flips can matter; be conservative:
             self._invalidate_caches_locked()
 
     def announce_devices(self, host_id: str, devices: list) -> None:
@@ -399,17 +395,14 @@ class HostTunnelRegistry:
                 if not device_id:
                     continue
 
-                # local_id is basically not used; keep for completeness
                 try:
                     local_id = int(getattr(d, "local_id", 0))
                 except Exception:
                     local_id = 0
 
-                # route
                 self._routes[device_id] = DeviceRoute(host_id=host_id, host_local_id=local_id)
                 self._host_devices[host_id].add(device_id)
 
-                # status
                 ds = self._device_status.get(device_id) or DeviceStatus(
                     device_id=device_id,
                     host_id=host_id,
@@ -421,13 +414,11 @@ class HostTunnelRegistry:
                 ds.last_seen_ms = now
                 self._device_status[device_id] = ds
 
-                # info (copy protobuf if possible)
                 try:
                     tmp = host_tunnel_pb2.DeviceInfo()
                     tmp.CopyFrom(d)
                     self._device_infos[device_id] = tmp
                 except Exception:
-                    # fallback minimal
                     self._device_infos[device_id] = host_tunnel_pb2.DeviceInfo(
                         device_id=device_id,
                         local_id=int(local_id),
@@ -445,10 +436,6 @@ class HostTunnelRegistry:
     # ---------------------------
 
     def is_host_device(self, device_id: str) -> bool:
-        """
-        O(1): does the directory route this device_id to a host?
-        (Host may be offline.)
-        """
         did = (device_id or "").strip()
         if not did:
             return False
@@ -456,10 +443,6 @@ class HostTunnelRegistry:
             return did in self._routes
 
     def is_host_device_active(self, device_id: str) -> bool:
-        """
-        O(1) route lookup + cached host-alive check (TTL).
-        True iff device routes to a host AND that host's tunnel session is alive.
-        """
         did = (device_id or "").strip()
         if not did:
             return False
@@ -485,12 +468,6 @@ class HostTunnelRegistry:
     # ---------------------------
 
     def device_directory_cached(self, *, ttl_ms: Optional[int] = None) -> Dict[str, Tuple[str, Any, bool]]:
-        """
-        Returns:
-          { device_id: (host_id, device_info, is_active) }
-
-        Cached rebuild at most once per ttl_ms.
-        """
         now = now_ms()
         ttl = int(self._dir_cache_ttl_ms if ttl_ms is None else ttl_ms)
 
@@ -647,6 +624,7 @@ class HostTunnelRegistry:
             cancel_on_timeout=cancel_on_timeout,
         )
 
+
 def handle_host_device(
     registry: HostTunnelRegistry,
     *,
@@ -711,6 +689,23 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                         self.registry.register_host(host_id, session)
                         self.registry.persist_host_meta_from_hello(hello)
 
+                        # Ask host for metadata immediately on join (best-effort)
+                        try:
+                            mrid = secrets.token_hex(12)
+                            session.send(
+                                host_tunnel_pb2.HostFrame(
+                                    meta_request=host_tunnel_pb2.MetaRequest(
+                                        req_id=mrid,
+                                        include_platform=True,
+                                        include_env=True,
+                                        include_devices=True,
+                                    )
+                                )
+                            )
+                        except Exception:
+                            pass
+
+                        # Also ping/ack
                         try:
                             session.send(
                                 host_tunnel_pb2.HostFrame(
@@ -753,6 +748,35 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                         if fut is not None and not fut.done():
                             fut.set_result(resp)
 
+                    elif which == "meta_response":
+                        # Print host metadata (best-effort diagnostics)
+                        try:
+                            mr = frame.meta_response
+                            if not mr.ok:
+                                print(f"[HOST META] host_id={host_id or '?'} ERROR: {mr.error}")
+                                continue
+
+                            meta = mr.meta
+                            print(f"\n[HOST META] host_id={meta.host_id} version={meta.version} unix_ms={meta.unix_ms}")
+
+                            if meta.kv:
+                                for k in sorted(meta.kv.keys()):
+                                    print(f"  {k}={meta.kv[k]}")
+
+                            if meta.devices:
+                                print("  devices:")
+                                for d in meta.devices:
+                                    print(
+                                        f"    - local_id={d.local_id} "
+                                        f"label={d.label!r} "
+                                        f"device_id={d.device_id!r} "
+                                        f"serial={d.serial!r} "
+                                        f"kind={d.kind!r}"
+                                    )
+                            print()
+                        except Exception:
+                            pass
+
                     elif which == "heartbeat":
                         if session is not None and host_id is not None:
                             session.last_heartbeat_ms = int(frame.heartbeat.unix_ms) or now_ms()
@@ -844,4 +868,4 @@ def start_host_tunnel_server(
 
     th = threading.Thread(target=run, daemon=True)
     th.start()
-    return server, th, reg
+    return server, th, reg

{remoterf_server-0.1.63 → remoterf_server-0.1.64}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.63
+Version: 0.1.64
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf