@jheavenknows/bluerouter 5.2.63 → 5.2.65

package/app/.next-cli-build/server/chunks/7478.js

@@ -0,0 +1,617 @@
+"use strict";exports.id=7478,exports.ids=[7478],exports.modules={60592:(a,b,c)=>{c.d(b,{P:()=>g,h:()=>h});var d=c(79646);function e(a){return`'${String(a??"").replace(/'/g,"'\"'\"'")}'`}function f(a,b,{input:c="",timeoutMs:e=12e4,env:g={}}={}){return new Promise(f=>{let h=(0,d.spawn)(a,b,{stdio:["pipe","pipe","pipe"],env:{...process.env,...g}}),i="",j="",k=!1,l=setTimeout(()=>{k||h.kill("SIGKILL")},e);h.stdout.on("data",a=>{i+=a.toString()}),h.stderr.on("data",a=>{j+=a.toString()}),h.on("error",a=>{k=!0,clearTimeout(l),f({ok:!1,code:-1,stdout:i,stderr:a.message})}),h.on("close",a=>{k||(k=!0,clearTimeout(l),f({ok:0===a,code:a,stdout:i,stderr:j}))}),c&&h.stdin.write(c),h.stdin.end()})}async function g(a,b={}){let c,d=`${a.sshUser||"root"}@${a.host}`,h=!0===a.useSudo&&"root"!==a.sshUser,i=String(b.sshPassword||""),j=String(b.sudoPassword||i),k=(c="/opt/bluerouter-resource-agent",`#!/usr/bin/env bash
+set -euo pipefail
+command -v python3 >/dev/null 2>&1 || { echo "python3 is required"; exit 1; }
+mkdir -p ${e(c)}
+cat > ${e(`${c}/agent.py`)} <<'PY_AGENT'
+${String.raw`#!/usr/bin/env python3
+import json
+import math
+import os
+import platform
+import re
+import shutil
+import socket
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.request import ProxyHandler, Request, build_opener
+
+PORT = int(os.environ.get("AGENT_PORT", "19998"))
+TOKEN = os.environ.get("AGENT_TOKEN", "")
+AGENT_VERSION = "2.1.0"
+NETWORK_SAMPLE = None
+VLLM_DISCOVERY_AT = 0.0
+VLLM_TARGETS = []
+VLLM_DISCOVERY_MODE = "none"
+VLLM_DISCOVERY_INTERVAL = 30.0
+VLLM_MAX_DISCOVERY_PORTS = 64
+HTTP_OPENER = build_opener(ProxyHandler({}))
+MODEL_LABEL_RE = re.compile(r'(?:model_name|model)="((?:\\.|[^"\\])*)"')
+
+
+def cmd(args, timeout=4):
+    try:
+        return subprocess.check_output(args, stderr=subprocess.DEVNULL, text=True, timeout=timeout).strip()
+    except Exception:
+        return ""
+
+
+def cpu_times():
+    try:
+        values = [int(x) for x in open("/proc/stat").readline().split()[1:]]
+        return sum(values), values[3] + (values[4] if len(values) > 4 else 0)
+    except Exception:
+        return 0, 0
+
+
+def cpu_status():
+    total1, idle1 = cpu_times()
+    time.sleep(0.15)
+    total2, idle2 = cpu_times()
+    delta = total2 - total1
+    usage = ((delta - (idle2 - idle1)) / delta * 100) if delta else 0
+    model = ""
+    try:
+        for line in open("/proc/cpuinfo", errors="ignore"):
+            if line.lower().startswith("model name"):
+                model = line.split(":", 1)[1].strip(); break
+    except Exception:
+        pass
+    load = os.getloadavg()
+    return {"usagePercent": round(usage, 2), "cores": os.cpu_count() or 1, "model": model,
+            "load1": round(load[0], 2), "load5": round(load[1], 2), "load15": round(load[2], 2)}
+
+
+def memory_status():
+    values = {}
+    try:
+        for line in open("/proc/meminfo"):
+            key, raw = line.split(":", 1)
+            values[key] = int(raw.strip().split()[0]) * 1024
+    except Exception:
+        pass
+    total = values.get("MemTotal", 0)
+    available = values.get("MemAvailable", values.get("MemFree", 0))
+    used = max(0, total - available)
+    swap_total = values.get("SwapTotal", 0)
+    swap_used = max(0, swap_total - values.get("SwapFree", 0))
+    return {"totalBytes": total, "usedBytes": used, "availableBytes": available,
+            "usagePercent": round(used / total * 100, 2) if total else 0,
+            "swapTotalBytes": swap_total, "swapUsedBytes": swap_used}
+
+
+def disk_status():
+    disks = []
+    seen = set()
+    try:
+        for line in open("/proc/mounts", errors="ignore"):
+            parts = line.split()
+            if len(parts) < 3: continue
+            device, mount, fs_type = parts[:3]
+            if not device.startswith("/dev/") or mount in seen: continue
+            seen.add(mount)
+            try:
+                usage = shutil.disk_usage(mount)
+                disks.append({"device": device, "mount": mount, "filesystem": fs_type,
+                    "totalBytes": usage.total, "usedBytes": usage.used, "freeBytes": usage.free,
+                    "usagePercent": round(usage.used / usage.total * 100, 2) if usage.total else 0})
+            except Exception: pass
+    except Exception: pass
+    if not disks:
+        usage = shutil.disk_usage("/")
+        disks.append({"device": "root", "mount": "/", "filesystem": "",
+            "totalBytes": usage.total, "usedBytes": usage.used, "freeBytes": usage.free,
+            "usagePercent": round(usage.used / usage.total * 100, 2) if usage.total else 0})
+    return disks
+
+
+def read_network():
+    rows = {}; total_rx = total_tx = 0
+    try:
+        for line in open("/proc/net/dev").readlines()[2:]:
+            name, raw = line.split(":", 1); values = raw.split()
+            name = name.strip()
+            if name == "lo": continue
+            rx, tx = int(values[0]), int(values[8])
+            rows[name] = {"rxBytes": rx, "txBytes": tx}; total_rx += rx; total_tx += tx
+    except Exception: pass
+    return rows, total_rx, total_tx
+
+
+def network_status():
+    global NETWORK_SAMPLE
+    interfaces, rx, tx = read_network(); current = time.time()
+    rx_rate = tx_rate = 0
+    if NETWORK_SAMPLE:
+        elapsed = max(0.001, current - NETWORK_SAMPLE[0])
+        rx_rate = max(0, (rx - NETWORK_SAMPLE[1]) / elapsed)
+        tx_rate = max(0, (tx - NETWORK_SAMPLE[2]) / elapsed)
+    NETWORK_SAMPLE = (current, rx, tx)
+    return {"rxBytes": rx, "txBytes": tx, "rxBytesPerSecond": round(rx_rate),
+            "txBytesPerSecond": round(tx_rate), "interfaces": interfaces}
+
+
+def number(value):
+    try: return round(float(value), 2)
+    except Exception: return None
+
+
+def gpu_status():
+    query = "index,uuid,name,driver_version,utilization.gpu,memory.total,memory.used,memory.free,temperature.gpu,power.draw,power.limit"
+    output = cmd(["nvidia-smi", "--query-gpu=" + query, "--format=csv,noheader,nounits"], 6)
+    gpus = []
+    for line in output.splitlines():
+        parts = [part.strip() for part in line.split(",")]
+        if len(parts) < 11: continue
+        index, uuid, name, driver, util, total, used, free, temp, power, limit = parts[:11]
+        total_n, used_n = number(total) or 0, number(used) or 0
+        gpus.append({"index": int(number(index) or 0), "uuid": uuid, "name": name, "driverVersion": driver,
+            "usagePercent": number(util) or 0, "memoryTotalMb": total_n, "memoryUsedMb": used_n,
+            "memoryFreeMb": number(free) or 0, "memoryUsagePercent": round(used_n / total_n * 100, 2) if total_n else 0,
+            "temperatureC": number(temp), "powerDrawW": number(power), "powerLimitW": number(limit)})
+    return gpus
+
+
+def decode_proc_address(value, ipv6=False):
+    try:
+        raw = bytes.fromhex(value)
+        if ipv6:
+            raw = b"".join(raw[index:index + 4][::-1] for index in range(0, 16, 4))
+            return socket.inet_ntop(socket.AF_INET6, raw)
+        return socket.inet_ntop(socket.AF_INET, raw[::-1])
+    except Exception:
+        return "::1" if ipv6 else "127.0.0.1"
+
+
+def listening_targets():
+    targets = {}
+    for filename, ipv6 in (("/proc/net/tcp", False), ("/proc/net/tcp6", True)):
+        try:
+            for line in open(filename, errors="ignore").readlines()[1:]:
+                parts = line.split()
+                if len(parts) < 4 or parts[3] != "0A":
+                    continue
+                address_hex, port_hex = parts[1].split(":", 1)
+                port = int(port_hex, 16)
+                if port <= 0 or port == PORT:
+                    continue
+                address = decode_proc_address(address_hex, ipv6)
+                if address == "0.0.0.0": address = "127.0.0.1"
+                if address == "::": address = "::1"
+                hosts = targets.setdefault(port, [])
+                if address not in hosts:
+                    hosts.append(address)
+        except Exception:
+            pass
+    return targets
+
+
+def metric_float(value):
+    try:
+        parsed = float(value)
+        return parsed if math.isfinite(parsed) else None
+    except Exception:
+        return None
+
+
+def parse_vllm_metrics(text):
+    values = {
+        "running": [],
+        "waiting": [],
+        "kv": [],
+        "preemptions": [],
+    }
+    models = set()
+    found_vllm = False
+    aliases = {
+        "vllm:num_requests_running": "running",
+        "vllm:num_requests_waiting": "waiting",
+        "vllm:kv_cache_usage_perc": "kv",
+        "vllm:gpu_cache_usage_perc": "kv",
+        "vllm:num_preemptions_total": "preemptions",
+        "vllm:num_preemptions": "preemptions",
+    }
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        columns = line.split()
+        if len(columns) < 2:
+            continue
+        token = columns[0]
+        name = token.split("{", 1)[0]
+        if name.startswith("vllm:"):
+            found_vllm = True
+        key = aliases.get(name)
+        if not key:
+            continue
+        value = metric_float(columns[1])
+        if value is None:
+            continue
+        values[key].append(value)
+        match = MODEL_LABEL_RE.search(token)
+        if match:
+            models.add(match.group(1).replace('\\"', '"').replace('\\\\', '\\'))
+    if not found_vllm:
+        return None
+    running = sum(values["running"]) if values["running"] else 0
+    waiting = sum(values["waiting"]) if values["waiting"] else 0
+    kv = max(values["kv"]) if values["kv"] else None
+    preemptions = sum(values["preemptions"]) if values["preemptions"] else 0
+    return {
+        "running": round(running, 2),
+        "waiting": round(waiting, 2),
+        "kvCacheUsagePercent": round(kv * 100, 1) if kv is not None else None,
+        "preemptions": round(preemptions, 2),
+        "models": sorted(models),
+    }
+
+
+def http_vllm_metrics(host, port, timeout=0.6):
+    url_host = "[%s]" % host if ":" in host else host
+    try:
+        request = Request(
+            "http://%s:%d/metrics" % (url_host, int(port)),
+            headers={"User-Agent": "BlueRouter-Resource-Agent/%s" % AGENT_VERSION},
+        )
+        with HTTP_OPENER.open(request, timeout=timeout) as response:
+            if response.status != 200:
+                return None
+            text = response.read(6 * 1024 * 1024).decode("utf-8", errors="ignore")
+        return parse_vllm_metrics(text)
+    except Exception:
+        return None
+
+
+def probe_socket_target(port, hosts, timeout=0.45):
+    for host in hosts or ["127.0.0.1", "::1"]:
+        metrics = http_vllm_metrics(host, port, timeout)
+        if metrics is None:
+            continue
+        metrics.update({
+            "port": int(port),
+            "endpoint": "%s:%d" % (host, int(port)),
+            "metricsAvailable": True,
+            "discovery": "socket",
+        })
+        return metrics
+    return None
+
+
+def scrape_socket_targets(targets, timeout):
+    if not targets:
+        return []
+    items = list(targets.items())
+    results = []
+    with ThreadPoolExecutor(max_workers=min(8, len(items))) as pool:
+        futures = {
+            pool.submit(probe_socket_target, port, hosts, timeout): (port, hosts)
+            for port, hosts in items
+        }
+        for future in as_completed(futures):
+            try:
+                result = future.result()
+                if result:
+                    results.append(result)
+            except Exception:
+                pass
+    return sorted(results, key=lambda item: item.get("port", 0))
+
+
+def docker_command_tokens(config):
+    tokens = []
+    for value in (config.get("Entrypoint"), config.get("Cmd")):
+        if isinstance(value, list):
+            tokens.extend(str(item) for item in value if item is not None)
+        elif value:
+            tokens.append(str(value))
+    return tokens
+
+
+def docker_service_port(config):
+    tokens = docker_command_tokens(config)
+    for index, token in enumerate(tokens):
+        if token == "--port" and index + 1 < len(tokens):
+            try: return int(tokens[index + 1])
+            except Exception: pass
+        if token.startswith("--port="):
+            try: return int(token.split("=", 1)[1])
+            except Exception: pass
+    return 8000
+
+
+def add_endpoint(endpoints, seen, host, port, kind):
+    try:
+        port = int(port)
+    except Exception:
+        return
+    host = str(host or "").strip()
+    if not host or port <= 0 or port > 65535:
+        return
+    key = (host, port)
+    if key in seen:
+        return
+    seen.add(key)
+    endpoints.append({"host": host, "port": port, "kind": kind})
+
+
+def docker_vllm_targets():
+    if not shutil.which("docker"):
+        return []
+    container_ids = [item.strip() for item in cmd(["docker", "ps", "-q"], 5).splitlines() if item.strip()]
+    if not container_ids:
+        return []
+    raw = cmd(["docker", "inspect"] + container_ids[:128], 10)
+    if not raw:
+        return []
+    try:
+        containers = json.loads(raw)
+    except Exception:
+        return []
+
+    targets = []
+    for item in containers:
+        config = item.get("Config") or {}
+        host_config = item.get("HostConfig") or {}
+        network = item.get("NetworkSettings") or {}
+        name = str(item.get("Name") or "").lstrip("/")
+        image = str(config.get("Image") or "")
+        labels = config.get("Labels") or {}
+        tokens = docker_command_tokens(config)
+        identity = " ".join([
+            name,
+            image,
+            " ".join(tokens),
+            " ".join("%s=%s" % (key, value) for key, value in labels.items()),
+        ]).lower()
+        if "vllm" not in identity:
+            continue
+
+        service_port = docker_service_port(config)
+        internal_ports = {service_port}
+        for key in (config.get("ExposedPorts") or {}).keys():
+            try: internal_ports.add(int(str(key).split("/", 1)[0]))
+            except Exception: pass
+        for key in (network.get("Ports") or {}).keys():
+            try: internal_ports.add(int(str(key).split("/", 1)[0]))
+            except Exception: pass
+
+        endpoints = []
+        seen = set()
+        network_mode = str(host_config.get("NetworkMode") or "")
+
+        if network_mode == "host":
+            add_endpoint(endpoints, seen, "127.0.0.1", service_port, "host-network")
+
+        for port_key, bindings in (network.get("Ports") or {}).items():
+            if not bindings:
+                continue
+            for binding in bindings:
+                host_port = binding.get("HostPort")
+                host_ip = str(binding.get("HostIp") or "127.0.0.1")
+                if host_ip in ("0.0.0.0", "::", ""):
+                    host_ip = "127.0.0.1"
+                add_endpoint(endpoints, seen, host_ip, host_port, "published")
+
+        for network_info in (network.get("Networks") or {}).values():
+            ip = str((network_info or {}).get("IPAddress") or "").strip()
+            if not ip:
+                continue
+            for internal_port in sorted(internal_ports):
+                add_endpoint(endpoints, seen, ip, internal_port, "container-ip")
+
+        add_endpoint(endpoints, seen, "127.0.0.1", service_port, "localhost-fallback")
+        targets.append({
+            "containerId": str(item.get("Id") or "")[:12],
+            "containerName": name or str(item.get("Id") or "")[:12],
+            "image": image,
+            "servicePort": service_port,
+            "endpoints": endpoints,
+        })
+
+    return targets
+
+
+def probe_docker_target(target, timeout=0.7):
+    result = {
+        "containerId": target.get("containerId"),
+        "containerName": target.get("containerName"),
+        "image": target.get("image"),
+        "port": target.get("servicePort") or 8000,
+        "metricsAvailable": False,
+        "discovery": "docker",
+        "running": 0,
+        "waiting": 0,
+        "kvCacheUsagePercent": None,
+        "preemptions": 0,
+        "models": [],
+    }
+    for endpoint in target.get("endpoints") or []:
+        metrics = http_vllm_metrics(endpoint.get("host"), endpoint.get("port"), timeout)
+        if metrics is None:
+            continue
+        result.update(metrics)
+        result.update({
+            "port": int(endpoint.get("port") or target.get("servicePort") or 8000),
+            "endpoint": "%s:%d" % (endpoint.get("host"), int(endpoint.get("port"))),
+            "endpointKind": endpoint.get("kind"),
+            "metricsAvailable": True,
+        })
+        break
+    return result
+
+
+def scrape_docker_targets(targets, timeout=0.7):
+    if not targets:
+        return []
+    results = []
+    with ThreadPoolExecutor(max_workers=min(8, len(targets))) as pool:
+        futures = [pool.submit(probe_docker_target, target, timeout) for target in targets]
+        for future in as_completed(futures):
+            try:
+                results.append(future.result())
+            except Exception:
+                pass
+    return sorted(results, key=lambda item: (item.get("containerName") or "", item.get("containerId") or ""))
+
+
+def vllm_status():
+    global VLLM_DISCOVERY_AT, VLLM_TARGETS, VLLM_DISCOVERY_MODE
+    current = time.monotonic()
+    full_discovery = current - VLLM_DISCOVERY_AT >= VLLM_DISCOVERY_INTERVAL
+
+    if full_discovery:
+        docker_targets = docker_vllm_targets()
+        if docker_targets:
+            VLLM_TARGETS = docker_targets
+            VLLM_DISCOVERY_MODE = "docker"
+            instances = scrape_docker_targets(VLLM_TARGETS, 0.7)
+        else:
+            candidates = listening_targets()
+            ordered = sorted(
+                candidates.items(),
+                key=lambda item: (0 if 7000 <= item[0] <= 9999 else 1, item[0]),
+            )[:VLLM_MAX_DISCOVERY_PORTS]
+            VLLM_TARGETS = [
+                {"port": port, "hosts": hosts}
+                for port, hosts in ordered
+            ]
+            VLLM_DISCOVERY_MODE = "socket"
+            instances = scrape_socket_targets(
+                {target["port"]: target["hosts"] for target in VLLM_TARGETS},
+                0.35,
+            )
+            VLLM_TARGETS = [
+                {"port": instance.get("port"), "hosts": [str(instance.get("endpoint") or "127.0.0.1").rsplit(":", 1)[0]]}
+                for instance in instances
+                if instance.get("port")
+            ]
+        VLLM_DISCOVERY_AT = current
+    elif VLLM_DISCOVERY_MODE == "docker":
+        instances = scrape_docker_targets(VLLM_TARGETS, 0.7)
+    elif VLLM_DISCOVERY_MODE == "socket":
+        instances = scrape_socket_targets(
+            {target["port"]: target.get("hosts") or ["127.0.0.1"] for target in VLLM_TARGETS},
+            0.7,
+        )
+    else:
+        instances = []
+
+    available = [instance for instance in instances if instance.get("metricsAvailable") is not False]
+    running = sum(float(instance.get("running") or 0) for instance in available)
+    waiting = sum(float(instance.get("waiting") or 0) for instance in available)
+    preemptions = sum(float(instance.get("preemptions") or 0) for instance in available)
+    kv_values = [
+        float(instance["kvCacheUsagePercent"])
+        for instance in available
+        if instance.get("kvCacheUsagePercent") is not None
+    ]
+    return {
+        "instances": instances,
+        "summary": {
+            "instanceCount": len(instances),
+            "metricsInstanceCount": len(available),
+            "running": round(running, 2),
+            "waiting": round(waiting, 2),
+            "kvCacheUsagePercent": round(max(kv_values), 1) if kv_values else None,
+            "preemptions": round(preemptions, 2),
+        },
+        "discovery": VLLM_DISCOVERY_MODE,
+        "discoveryIntervalSeconds": int(VLLM_DISCOVERY_INTERVAL),
+    }
+
+
+def status():
+    uptime = 0
+    try: uptime = float(open("/proc/uptime").read().split()[0])
+    except Exception: pass
+    os_name = cmd(["sh", "-c", ". /etc/os-release 2>/dev/null; printf '%s' \"$PRETTY_NAME\""]) or platform.platform()
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        gpu_future = pool.submit(gpu_status)
+        vllm_future = pool.submit(vllm_status)
+        gpus = gpu_future.result()
+        vllm = vllm_future.result()
+    return {"ok": True, "agentVersion": AGENT_VERSION, "hostname": platform.node(), "os": os_name, "kernel": platform.release(),
+        "uptimeSeconds": round(uptime), "cpu": cpu_status(), "memory": memory_status(), "disks": disk_status(),
+        "network": network_status(), "gpus": gpus, "vllm": vllm,
+        "updatedAt": datetime.now(timezone.utc).isoformat()}
+
+
+class Handler(BaseHTTPRequestHandler):
+    def send_json(self, code, payload):
+        body = json.dumps(payload, ensure_ascii=False).encode()
+        self.send_response(code); self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Cache-Control", "no-store"); self.send_header("Content-Length", str(len(body)))
+        self.end_headers(); self.wfile.write(body)
+    def authorized(self):
+        return (not TOKEN) or self.headers.get("Authorization", "") == "Bearer " + TOKEN
+    def do_GET(self):
+        if self.path == "/health": return self.send_json(200, {"ok": True, "agentVersion": AGENT_VERSION})
+        if self.path != "/status": return self.send_json(404, {"ok": False, "error": "not_found"})
+        if not self.authorized(): return self.send_json(401, {"ok": False, "error": "unauthorized"})
+        try: self.send_json(200, status())
+        except Exception as error: self.send_json(500, {"ok": False, "error": str(error)})
+    def log_message(self, fmt, *args): pass
+
+
+if __name__ == "__main__":
+    ThreadingHTTPServer(("0.0.0.0", PORT), Handler).serve_forever()
+`}
+PY_AGENT
+chmod 700 ${e(`${c}/agent.py`)}
+cat > /etc/systemd/system/bluerouter-resource-agent.service <<'SERVICE'
+[Unit]
+Description=BlueRouter Linux Resource Monitor Agent
+After=network.target
+
+[Service]
+Type=simple
+Environment="AGENT_PORT=${Number(a.agentPort)}"
+Environment="AGENT_TOKEN=${a.agentToken}"
+ExecStart=/usr/bin/python3 ${c}/agent.py
+Restart=always
+RestartSec=3
+NoNewPrivileges=true
+
+[Install]
+WantedBy=multi-user.target
+SERVICE
+systemctl daemon-reload
+systemctl enable bluerouter-resource-agent
+systemctl restart bluerouter-resource-agent
+if command -v ufw >/dev/null 2>&1 && ufw status 2>/dev/null | grep -q "Status: active"; then
+  ufw allow ${Number(a.agentPort)}/tcp >/dev/null || true
+fi
+if command -v firewall-cmd >/dev/null 2>&1 && firewall-cmd --state >/dev/null 2>&1; then
+  firewall-cmd --permanent --add-port=${Number(a.agentPort)}/tcp >/dev/null || true
+  firewall-cmd --reload >/dev/null || true
+fi
+systemctl is-active bluerouter-resource-agent
+python3 - <<'PY_VERIFY'
+import os
+import sys
+import time
+from urllib.request import Request, urlopen
+
+port = os.environ.get("AGENT_PORT", "${Number(a.agentPort)}")
+token = os.environ.get("AGENT_TOKEN", "${a.agentToken}")
+url = "http://127.0.0.1:%s/status" % port
+for _ in range(20):
+    try:
+        req = Request(url, headers={"Authorization": "Bearer " + token})
+        with urlopen(req, timeout=3) as res:
+            if res.status == 200:
+                payload = res.read().decode("utf-8", errors="ignore")
+                if '"agentVersion": "2.1.0"' in payload:
+                    print("Agent local token + Docker-aware vLLM monitor check: ok")
+                    sys.exit(0)
+    except Exception:
+        time.sleep(0.5)
+print("Agent local token + Docker-aware vLLM monitor check: failed", file=sys.stderr)
+sys.exit(1)
+PY_VERIFY
+echo "BlueRouter Resource Agent v2.1.0 installed on port ${Number(a.agentPort)}"
+`),l=h?`${j}
+${k}`:k,m=["-p",String(a.sshPort||22),"-o","StrictHostKeyChecking=accept-new","-o","ConnectTimeout=12",d,h?"sudo -S -p '' bash -s":"bash -s"];return i?f("sshpass",["-e","ssh","-o","PreferredAuthentications=password,keyboard-interactive","-o","PubkeyAuthentication=no","-o","NumberOfPasswordPrompts=1",...m],{input:l,env:{SSHPASS:i}}):f("ssh",m,{input:l})}async function h(a){let b=await fetch(`http://${a.host}:${a.agentPort}/status`,{headers:{Authorization:`Bearer ${a.agentToken}`},cache:"no-store",signal:AbortSignal.timeout(7e3)});if(!b.ok){let a=await b.text().catch(()=>"");if(401===b.status)throw Error("Agent returned HTTP 401: token dashboard kh\xf4ng khớp với token agent. H\xe3y c\xe0i lại agent từ n\xfat sửa server.");throw Error(`Agent returned HTTP ${b.status}${a?`: ${a.slice(0,200)}`:""}`)}return b.json()}},62763:(a,b,c)=>{c.d(b,{Jc:()=>r,NY:()=>w,Q1:()=>s,WR:()=>v,X_:()=>u,gX:()=>t});var d=c(77598),e=c.n(d),f=c(51455),g=c.n(f),h=c(76760),i=c.n(h),j=c(49120);let k=i().join(j.DATA_DIR,"cluster-config.json"),l=new Set(["standalone","master","slave"]),m="__blueRouterClusterConfigMutation",n={version:1,nodeId:"",role:"standalone",enabled:!1,masterUrl:"",syncToken:"",intervalMinutes:5,lastAttemptAt:null,lastSyncAt:null,lastSnapshotHash:"",lastError:"",lastResult:null,commandAck:null};function o(a={}){let b=l.has(a.role)?a.role:"standalone";return{...n,...a,version:1,nodeId:String(a.nodeId||"").trim()||e().randomUUID(),role:b,enabled:!0===a.enabled,masterUrl:function(a){let b=String(a||"").trim().replace(/\/+$/,"");if(!b)return"";let c=new URL(b);if(!["http:","https:"].includes(c.protocol))throw Error("Master URL must use http:// or https://");if(c.username||c.password)throw Error("Master URL must not contain credentials");return c.toString().replace(/\/+$/,"")}(a.masterUrl),syncToken:String(a.syncToken||"").trim(),intervalMinutes:Math.min(1440,Math.max(1,Number(a.intervalMinutes)||5))}}async function p(a){await g().mkdir(j.DATA_DIR,{recursive:!0});let b=`${k}.${process.pid}.${e().randomUUID()}.tmp`;try{await g().writeFile(b,JSON.stringify(a,null,2),{mode:384}),await g().rename(b,k)}catch(a){throw await g().unlink(b).catch(()=>{}),a}}function q(a){let b=(globalThis[m]||Promise.resolve()).then(a,a);return globalThis[m]=b.catch(()=>{}),b}async function r({includeSecrets:a=!1}={}){let b={};try{b=JSON.parse(await g().readFile(k,"utf8"))}catch(a){a?.code!=="ENOENT"&&console.warn("[cluster] failed to read config:",a?.message||a)}let c=o(b);if(b.nodeId||await p(c),a)return c;let{syncToken:d,...e}=c;return{...e,hasSyncToken:!!c.syncToken}}async function s(a={}){if(!a||"object"!=typeof a||Array.isArray(a))throw Error("Invalid cluster config payload");return q(async()=>{let b=await r({includeSecrets:!0}),c={};for(let b of["role","enabled","masterUrl","syncToken","intervalMinutes"])Object.prototype.hasOwnProperty.call(a,b)&&(c[b]=a[b]);let d=o({...b,...c});if("master"!==d.role||d.syncToken||(d.syncToken=e().randomBytes(32).toString("base64url")),d.enabled&&"slave"===d.role){if(!d.masterUrl)throw Error("Master URL is required for Standby mode");if(!d.syncToken)throw Error("Sync token is required for Standby mode")}return await p(d),d})}async function t(){return q(async()=>{let a={...await r({includeSecrets:!0}),syncToken:e().randomBytes(32).toString("base64url")};return await p(a),a})}async function u(a={}){return q(async()=>{let b=await r({includeSecrets:!0}),c=o({...b,...a,nodeId:b.nodeId,role:b.role,enabled:b.enabled,masterUrl:b.masterUrl,syncToken:b.syncToken,intervalMinutes:b.intervalMinutes});return await p(c),c})}async function v(){return"slave"===(await r({includeSecrets:!0})).role}function w(a,b){let c=Buffer.from(String(a||"")),d=Buffer.from(String(b||""));return c.length>0&&c.length===d.length&&e().timingSafeEqual(c,d)}}};

package/app/.next-cli-build/server/middleware-build-manifest.js

@@ -1 +1 @@
-globalThis.__BUILD_MANIFEST={polyfillFiles:["static/chunks/polyfills-42372ed130431b0a.js"],devFiles:[],lowPriorityFiles:["static/hU0bJzcql1Pc4g3hzZRSk/_buildManifest.js","static/hU0bJzcql1Pc4g3hzZRSk/_ssgManifest.js"],rootMainFiles:["static/chunks/webpack-7f2a8541ddb15fce.js","static/chunks/4bd1b696-8a4ab4fdf0ae305a.js","static/chunks/3794-d7cddff008311ab3.js","static/chunks/main-app-eacc433ef218cf40.js"],rootMainFilesTree:{},pages:{"/_app":[]}};
+globalThis.__BUILD_MANIFEST={polyfillFiles:["static/chunks/polyfills-42372ed130431b0a.js"],devFiles:[],lowPriorityFiles:["static/-Ekus-uCsaI18fBUeojkR/_buildManifest.js","static/-Ekus-uCsaI18fBUeojkR/_ssgManifest.js"],rootMainFiles:["static/chunks/webpack-7f2a8541ddb15fce.js","static/chunks/4bd1b696-8a4ab4fdf0ae305a.js","static/chunks/3794-d7cddff008311ab3.js","static/chunks/main-app-eacc433ef218cf40.js"],rootMainFilesTree:{},pages:{"/_app":[]}};