Merge remote-tracking branch 'origin/main'

5 files changed, 215 insertions, 1 deletions

diff --git a/packages/meshbay-node/src/meshbay_node/daemon.py b/packages/meshbay-node/src/meshbay_node/daemon.py
index 266693a..e1e4dee 100644
--- a/packages/meshbay-node/src/meshbay_node/daemon.py
+++ b/packages/meshbay-node/src/meshbay_node/daemon.py
@@ -267,6 +267,20 @@ class NodeDaemon:
             await self._roster.open()
             await self._roster.purge_expired()
 
+            # Apply any roster overrides to node config (panel-edited values
+            # take precedence over node.toml defaults).
+            nd = self._config.node
+            defaults = {
+                "invite_ttl_hours": nd.invite_ttl_hours,
+                "pair_ttl_hours": nd.pair_ttl_hours,
+                "device_request_ttl_minutes": nd.device_request_ttl_minutes,
+                "max_concurrent_streams": nd.max_concurrent_streams,
+                "transcode_incompatible_video": nd.transcode_incompatible_video,
+            }
+            effective = await self._roster.node_settings(defaults)
+            for k, v in effective.items():
+                setattr(nd, k, v)
+
             # X25519 key material for GEK unwrapping
             from cryptography.hazmat.primitives import serialization
             sk_x_raw = keys.sk_x25519.private_bytes(
diff --git a/packages/meshbay-node/src/meshbay_node/ops.py b/packages/meshbay-node/src/meshbay_node/ops.py
index c921b05..d1314f0 100644
--- a/packages/meshbay-node/src/meshbay_node/ops.py
+++ b/packages/meshbay-node/src/meshbay_node/ops.py
@@ -332,7 +332,19 @@ async def list_groups(state: dict) -> dict:
         members = await roster.list_members()
         has_operator = any(m["role"] == "operator" and m["status"] == "active"
                           for m in members)
-    return {"groups": out, "operator_paired": has_operator}
+    nd = config.node if config else None
+    defaults = {
+        "invite_ttl_hours": nd.invite_ttl_hours if nd else 168,
+        "pair_ttl_hours": nd.pair_ttl_hours if nd else 24,
+        "device_request_ttl_minutes": nd.device_request_ttl_minutes if nd else 60,
+        "max_concurrent_streams": nd.max_concurrent_streams if nd else 8,
+        "transcode_incompatible_video": nd.transcode_incompatible_video if nd else True,
+    }
+    if roster:
+        settings = await roster.node_settings(defaults)
+    else:
+        settings = defaults
+    return {"groups": out, "operator_paired": has_operator, "settings": settings}
 
 
 async def attach_group(state: dict, name: str, shared_dir: str,
@@ -472,6 +484,57 @@ def _find_group_range(lines: list[str], group_id: str) -> tuple[int, int] | None
     return None
 
 
+def _update_node_toml(conf_path: Path, updates: dict) -> None:
+    """Write changed [node] settings back to node.toml without disturbing comments.
+
+    For each key, if the line exists (commented or not) it is replaced in place;
+    otherwise the key is appended to the end of the [node] section.
+    """
+    if not conf_path.exists():
+        return
+    text = conf_path.read_text()
+    lines = text.split("\n")
+
+    node_start = None
+    node_end = len(lines)
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped == "[node]":
+            node_start = i
+        elif node_start is not None and re.match(r'^\[', stripped):
+            node_end = i
+            break
+
+    if node_start is None:
+        lines.append("")
+        lines.append("[node]")
+        node_start = len(lines) - 1
+        node_end = len(lines)
+
+    remaining = dict(updates)
+    for i in range(node_start + 1, node_end):
+        for key in list(remaining):
+            pattern = re.compile(
+                r'^(\s*#?\s*)' + re.escape(key) + r'\s*=\s*.*$')
+            if pattern.match(lines[i]):
+                value = remaining.pop(key)
+                if isinstance(value, bool):
+                    lines[i] = f"{key} = {'true' if value else 'false'}"
+                else:
+                    lines[i] = f"{key} = {value}"
+                break
+
+    for key, value in remaining.items():
+        if isinstance(value, bool):
+            insert_line = f"{key} = {'true' if value else 'false'}"
+        else:
+            insert_line = f"{key} = {value}"
+        lines.insert(node_end, insert_line)
+        node_end += 1
+
+    conf_path.write_text("\n".join(lines))
+
+
 def _insert_roots_block(conf_path: Path, group_id: str,
                         root_block: str) -> None:
     """Append a [[groups.roots]] block inside the matching [[groups]] section."""
@@ -718,6 +781,56 @@ async def set_member_upload(state: dict, group_id: str, allowed: bool) -> dict:
     return {"allowed": allowed, "group_id": group_id}
 
 
+# ── Node settings ────────────────────────────────────────────────────────────
+
+async def set_node_settings(state: dict, settings: dict) -> dict:
+    """Update node-level daemon settings. Writes to both roster.db and node.toml."""
+    roster = _roster(state)
+    config = _config(state)
+    nd = config.node
+    conf_path = Path(state.get("config_path") or DEFAULT_CONFIG_PATH)
+
+    allowed_keys = {
+        "invite_ttl_hours": ("int", roster.SETTING_INVITE_TTL),
+        "pair_ttl_hours": ("int", roster.SETTING_PAIR_TTL),
+        "device_request_ttl_minutes": ("int", roster.SETTING_DEVICE_TTL),
+        "max_concurrent_streams": ("int", roster.SETTING_MAX_STREAMS),
+        "transcode_incompatible_video": ("bool", roster.SETTING_TRANSCODE),
+    }
+
+    set_by = state.get("node_user_id", "")
+    updated = {}
+    for key, value in settings.items():
+        if key not in allowed_keys:
+            continue
+        kind, setting_key = allowed_keys[key]
+        if kind == "int":
+            try:
+                v = int(value)
+            except (TypeError, ValueError):
+                raise OpError(f"{key} must be an integer")
+            if v < 1:
+                raise OpError(f"{key} must be positive")
+            setattr(nd, key, v)
+            await roster.set_node_setting(setting_key, str(v), set_by)
+            updated[key] = v
+        elif kind == "bool":
+            v = bool(value)
+            setattr(nd, key, v)
+            await roster.set_node_setting(setting_key, "1" if v else "0", set_by)
+            updated[key] = v
+
+    if updated:
+        _update_node_toml(conf_path, updated)
+        if "max_concurrent_streams" in updated:
+            webrtc = state.get("webrtc")
+            if webrtc and hasattr(webrtc, '_stream_sem'):
+                webrtc._stream_sem = asyncio.Semaphore(updated["max_concurrent_streams"])
+
+    log.info("Node settings updated: %s", updated)
+    return {"updated": updated}
+
+
 # ── Applications ─────────────────────────────────────────────────────────────
 
 async def set_enabled_apps(state: dict, group_id: str, apps: list[str]) -> dict:
diff --git a/packages/meshbay-node/src/meshbay_node/roster.py b/packages/meshbay-node/src/meshbay_node/roster.py
index ff5282d..cf0d421 100644
--- a/packages/meshbay-node/src/meshbay_node/roster.py
+++ b/packages/meshbay-node/src/meshbay_node/roster.py
@@ -754,6 +754,41 @@ class Roster:
                                str(float(debounce_secs)), set_by)
         return await self.scan_settings(group_id)
 
+    # ── Node-wide daemon settings ───────────────────────────────────────────
+    # Same pattern as TMDB config: stored under NODE_WIDE_GROUP_ID.
+    # On startup, node.toml values are the defaults; the roster override
+    # takes precedence at runtime. Changing a setting writes to both
+    # roster.db (immediate) and node.toml (survives a DB wipe).
+    SETTING_INVITE_TTL = "invite_ttl_hours"
+    SETTING_PAIR_TTL = "pair_ttl_hours"
+    SETTING_DEVICE_TTL = "device_request_ttl_minutes"
+    SETTING_MAX_STREAMS = "max_concurrent_streams"
+    SETTING_TRANSCODE = "transcode_incompatible_video"
+
+    async def node_settings(self, defaults: dict) -> dict:
+        """Current effective settings: roster override if present, else config default."""
+        result = {}
+        for key, setting in [
+            ("invite_ttl_hours", self.SETTING_INVITE_TTL),
+            ("pair_ttl_hours", self.SETTING_PAIR_TTL),
+            ("device_request_ttl_minutes", self.SETTING_DEVICE_TTL),
+            ("max_concurrent_streams", self.SETTING_MAX_STREAMS),
+            ("transcode_incompatible_video", self.SETTING_TRANSCODE),
+        ]:
+            stored = await self.get_setting(self.NODE_WIDE_GROUP_ID, setting)
+            if stored is not None:
+                if key == "transcode_incompatible_video":
+                    result[key] = stored != "0"
+                else:
+                    result[key] = int(stored)
+            else:
+                result[key] = defaults.get(key)
+        return result
+
+    async def set_node_setting(self, key: str, value: str,
+                               set_by: str = "") -> None:
+        await self.set_setting(self.NODE_WIDE_GROUP_ID, key, value, set_by)
+
     async def create_invite(
         self,
         group_id: str,
diff --git a/packages/meshbay-node/src/meshbay_node/transport/webrtc_server.py b/packages/meshbay-node/src/meshbay_node/transport/webrtc_server.py
index 1bd7203..a934418 100644
--- a/packages/meshbay-node/src/meshbay_node/transport/webrtc_server.py
+++ b/packages/meshbay-node/src/meshbay_node/transport/webrtc_server.py
@@ -504,6 +504,8 @@ class WebRTCPeerSession:
                 self._do_group_attach(msg)
             elif mtype == MNP.GROUP_DETACH:
                 self._do_group_detach(msg)
+            elif mtype == MNP.NODE_SETTINGS_SET:
+                self._spawn(self._do_node_settings_set(msg))
             elif mtype == MNP.NODE_RELOAD:
                 self._spawn(self._do_node_reload(msg))
             elif mtype == MNP.KEYPAIR_BUNDLE_STORE:
@@ -2187,6 +2189,24 @@ class WebRTCPeerSession:
             log.error("node_status failed: %s", e, exc_info=True)
             self._send({"type": "error", "detail": "Internal error"})
 
+    async def _do_node_settings_set(self, msg: dict) -> None:
+        if not self._is_node_admin():
+            self._send({"type": "error", "detail": "Not the node operator"})
+            return
+        settings = msg.get("settings", {})
+        if not settings:
+            self._send({"type": "error", "detail": "No settings provided"})
+            return
+        try:
+            result = await self._run_op(ops.set_node_settings, settings)
+            self._send({"type": MNP.NODE_SETTINGS_SET_ACK, "v": MNP_VERSION,
+                         **result})
+        except ops.OpError as e:
+            self._send({"type": "error", "detail": e.message})
+        except Exception as e:
+            log.error("node_settings_set failed: %s", e, exc_info=True)
+            self._send({"type": "error", "detail": "Internal error"})
+
     async def _do_roster_read(self, msg: dict) -> None:
         if not self._is_node_admin():
             self._send({"type": "error", "detail": "Not the node operator"})
diff --git a/packages/meshbay-node/src/meshbay_node/ui/app.py b/packages/meshbay-node/src/meshbay_node/ui/app.py
index 514a143..b25b36a 100644
--- a/packages/meshbay-node/src/meshbay_node/ui/app.py
+++ b/packages/meshbay-node/src/meshbay_node/ui/app.py
@@ -291,6 +291,13 @@ def create_ui_app(state: dict) -> FastAPI:
             "quic_port": config.node.quic_port,
             "ui_port": config.node.ui_port,
             "data_dir": str(config.data_dir),
+            "settings": {
+                "invite_ttl_hours": config.node.invite_ttl_hours,
+                "pair_ttl_hours": config.node.pair_ttl_hours,
+                "device_request_ttl_minutes": config.node.device_request_ttl_minutes,
+                "max_concurrent_streams": config.node.max_concurrent_streams,
+                "transcode_incompatible_video": config.node.transcode_incompatible_video,
+            },
             "groups": [
                 {
                     "id": g.id,
@@ -438,6 +445,12 @@ def create_ui_app(state: dict) -> FastAPI:
         # seconds, on a real library) — see ops.start_reload for why.
         return await _op(lambda: ops.start_reload(state))
 
+    # ── Node settings (operator only, localhost) ───────────────────────────
+
+    @app.put("/api/node-settings")
+    async def update_node_settings(payload: dict):
+        return await _op(lambda: ops.set_node_settings(state, payload))
+
     # ── Chat endpoints ───────────────────────────────────────────────────────
 
     _chat_subscribers: list[WebSocket] = []
@@ -521,6 +534,24 @@ def _fmt_size(n: int) -> str:
     return f"{n / (1024 * 1024 * 1024):.2f} GB"
 
 
+def _render_node_settings(config) -> str:
+    if not config:
+        return ""
+    nd = config.node
+    transcode = "on" if nd.transcode_incompatible_video else "off"
+    return f"""
+    <table style="margin-top:10px">
+      <thead><tr><th>Setting</th><th>Value</th></tr></thead>
+      <tbody>
+        <tr><td>Invitation TTL</td><td>{nd.invite_ttl_hours} hours</td></tr>
+        <tr><td>Pairing code TTL</td><td>{nd.pair_ttl_hours} hours</td></tr>
+        <tr><td>Device request TTL</td><td>{nd.device_request_ttl_minutes} minutes</td></tr>
+        <tr><td>Max concurrent streams</td><td>{nd.max_concurrent_streams}</td></tr>
+        <tr><td>Transcode incompatible video</td><td>{transcode}</td></tr>
+      </tbody>
+    </table>"""
+
+
 def _render_roster(roster_view: dict | None) -> str:
     """
     Who this node recognises, and which keys are theirs.
@@ -766,6 +797,7 @@ def _render_page(state: dict, roster_view: dict | None = None,
     <p><b>Hub:</b> {state.get("hub_url", "—")}</p>
     <p><b>QUIC port:</b> {state.get("quic_port", "—")}</p>
     <p><b>Node ID:</b> <code>{state.get("endpoint_hint") or "—"}</code></p>
+    {_render_node_settings(config)}
   </div>
 
   <h2>Maintenance</h2>