tests on dash

packages/node/meshnet_node/cli.py

@@ -43,6 +43,9 @@ def _load_env_defaults() -> None:
         _load_env_file(Path.cwd() / f".env.{machine}")
     _load_env_file(Path.cwd() / ".env")
     _load_env_file(Path.home() / ".config" / "meshnet" / "secrets.env")
+    for path in os.environ.get("PYTHONPATH", "").split(os.pathsep):
+        if path and path not in sys.path:
+            sys.path.insert(0, path)
 
 
 def _run_node(cfg: dict) -> None:

packages/tracker/meshnet_tracker/cli.py

@@ -60,6 +60,9 @@ def _load_env_defaults() -> None:
         _load_env_file(Path.cwd() / f".env.{machine}")
     _load_env_file(Path.cwd() / ".env")
     _load_env_file(Path.home() / ".config" / "meshnet" / "secrets.env")
+    for path in os.environ.get("PYTHONPATH", "").split(os.pathsep):
+        if path and path not in sys.path:
+            sys.path.insert(0, path)
 
 
 def _routing_config_from_args(args: argparse.Namespace) -> RoutingConfig | None:
@@ -357,6 +360,11 @@ def main() -> None:
         metavar="N",
         help=f"Number of rotated tracker log files to keep per level (default: {DEFAULT_LOG_BACKUP_COUNT})",
     )
+    common.add_argument(
+        "--enable-test-runner",
+        action="store_true",
+        help="Enable development test-runner hooks for this tracker",
+    )
     common.add_argument(
         "--no-file-logs",
         action="store_true",
@@ -373,6 +381,8 @@ def main() -> None:
     subparsers.add_parser("start", help="Start the tracker server", parents=[common])
 
     args = parser.parse_args()
+    if args.enable_test_runner:
+        os.environ["MESHNET_ENABLE_TEST_RUNNER"] = "1"
 
     if args.command in {None, "start"}:
         if not args.no_file_logs:

packages/tracker/meshnet_tracker/dashboard.html

@@ -254,6 +254,7 @@
           <label>Model
             <select id="chat-model" onchange="selectChatModel(this.value)"></select>
           </label>
+          <button type="button" id="request-model-load" style="display:none" onclick="requestSelectedModelLoad()">Load on available node</button>
           <div id="chat-status" class="chat-status">select a model to start</div>
         </div>
         <div id="chat-history" class="chat-messages empty">
@@ -1386,6 +1387,20 @@ function selectChatModel(value) {
   }
 }
 
+async function requestSelectedModelLoad() {
+  if (!selectedChatModel) return;
+  const button = $("request-model-load");
+  if (button) button.disabled = true;
+  const result = await apiCall("/v1/models/load", "POST", { model: selectedChatModel });
+  if (button) button.disabled = false;
+  if (!result.ok) {
+    alert(result.data.error || "model load request failed");
+    return;
+  }
+  const assignment = result.data.assignment || {};
+  $("chat-status").textContent = `load queued on ${short(assignment.node_id || "node")} for layers ${assignment.shard_start}-${assignment.shard_end}`;
+}
+
 function chatAuthToken() {
   if (accountApiKeys.length) return accountApiKeys[0];
   return null;
@@ -1394,6 +1409,7 @@ function chatAuthToken() {
 function setAdminMode(enabled) {
   isAdmin = enabled;
   $("tab-admin").style.display = enabled ? "" : "none";
+  $("request-model-load").style.display = enabled ? "" : "none";
   if (!enabled && dashboardTab === "admin") {
     switchDashboardTab("overview");
   } else {

packages/tracker/meshnet_tracker/server.py

@@ -1276,6 +1276,35 @@ def _scale_demanded_models_locked(server: "_TrackerHTTPServer") -> None:
             break
 
 
+def _request_model_load_locked(server: "_TrackerHTTPServer", model_key: str) -> dict | None:
+    """Queue an explicitly requested model on the best available joined node."""
+    resolved_name, preset = _resolve_model_preset(server.model_presets, model_key)
+    if preset is None or not preset.get("hf_repo"):
+        return None
+    required_start, required_end = _preset_layer_bounds(preset)
+    total_layers = required_end - required_start + 1
+    for host in _memory_pool_map(server)["hosts"]:
+        if host["spare_slots"] <= 0:
+            continue
+        host_nodes = [server.registry[item["node_id"]] for item in host["loaded"] if item["node_id"] in server.registry]
+        if not host_nodes:
+            continue
+        anchor = max(host_nodes, key=lambda node: node.benchmark_tokens_per_sec)
+        if anchor.status != "ready" or anchor.pending_new_assignment is not None:
+            continue
+        capacity = min(_node_layer_capacity(anchor, preset), total_layers)
+        if capacity <= 0:
+            continue
+        quantization = _node_quantization(anchor, preset)
+        shard_end = min(required_end, required_start + capacity - 1)
+        directive = _add_shard_directive(anchor, str(preset["hf_repo"]), required_start, shard_end, quantization)
+        anchor.pending_new_assignment = directive
+        anchor.pending_directives.append(directive)
+        _tracker_log(server, "info", "model load requested", node_id=anchor.node_id, model=resolved_name, hf_repo=preset["hf_repo"], shard=f"{required_start}-{shard_end}")
+        return {"node_id": anchor.node_id, "model": resolved_name, "hf_repo": preset["hf_repo"], "shard_start": required_start, "shard_end": shard_end}
+    return None
+
+
 def _deployment_summary(nodes: list[_NodeEntry], preset: dict | None) -> dict:
     if preset is None:
         return {"recommended": False}
@@ -2672,6 +2701,9 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         if self.path == "/v1/benchmark/hop-penalty":
             self._handle_benchmark_hop_penalty()
             return
+        if self.path == "/v1/models/load":
+            self._handle_model_load_request()
+            return
         if self.path == "/v1/calibration/toploc/run":
             self._handle_toploc_calibration_run()
             return
@@ -4294,6 +4326,25 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             server.gossip.merge({k: float(v) for k, v in body.items()})
         self._send_json(200, {})
 
+    def _handle_model_load_request(self):
+        server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
+        if not self._require_role("admin"):
+            return
+        body = self._read_json_body()
+        if body is None:
+            return
+        model = body.get("model")
+        if not isinstance(model, str) or not model.strip():
+            self._send_json(400, {"error": "model is required"})
+            return
+        with server.lock:
+            self._purge_expired_nodes()
+            assignment = _request_model_load_locked(server, model)
+        if assignment is None:
+            self._send_json(409, {"error": "no ready joined node has an available model slot and sufficient capacity"})
+            return
+        self._send_json(202, {"status": "queued", "assignment": assignment})
+
     def _handle_stats(self):
         server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
         if server.stats is None: