@jheavenknows/bluerouter 1.0.81 → 1.0.82

package/app/.next-cli-build/server/app/api/ollama-nodes/[id]/install/route.js

@@ -1,816 +0,0 @@
-(()=>{var a={};a.id=9902,a.ids=[9902],a.modules={261:a=>{"use strict";a.exports=require("next/dist/shared/lib/router/utils/app-paths")},3295:a=>{"use strict";a.exports=require("next/dist/server/app-render/after-task-async-storage.external.js")},10846:a=>{"use strict";a.exports=require("next/dist/compiled/next-server/app-page.runtime.prod.js")},21820:a=>{"use strict";a.exports=require("os")},29294:a=>{"use strict";a.exports=require("next/dist/server/app-render/work-async-storage.external.js")},33873:a=>{"use strict";a.exports=require("path")},44870:a=>{"use strict";a.exports=require("next/dist/compiled/next-server/app-route.runtime.prod.js")},55511:a=>{"use strict";a.exports=require("crypto")},63033:a=>{"use strict";a.exports=require("next/dist/server/app-render/work-unit-async-storage.external.js")},78335:()=>{},79646:a=>{"use strict";a.exports=require("child_process")},79748:a=>{"use strict";a.exports=require("fs/promises")},86439:a=>{"use strict";a.exports=require("next/dist/shared/lib/no-fallback-error.external")},86762:(a,b,c)=>{"use strict";c.r(b),c.d(b,{handler:()=>J,patchFetch:()=>I,routeModule:()=>E,serverHooks:()=>H,workAsyncStorage:()=>F,workUnitAsyncStorage:()=>G});var d={};c.r(d),c.d(d,{POST:()=>D,dynamic:()=>C,runtime:()=>B});var e=c(19225),f=c(84006),g=c(8317),h=c(99373),i=c(34775),j=c(24235),k=c(261),l=c(54365),m=c(90771),n=c(73461),o=c(67798),p=c(92280),q=c(62018),r=c(45696),s=c(47929),t=c(86439),u=c(37527),v=c(23211),w=c(6774),x=c(79646);function y(a){return`'${String(a??"").replace(/'/g,"'\"'\"'")}'`}function z(a,b,{input:c="",timeoutMs:d=12e4}={}){return new Promise(e=>{let f=(0,x.spawn)(a,b,{stdio:["pipe","pipe","pipe"]}),g="",h="",i=!1,j=setTimeout(()=>{i||f.kill("SIGKILL")},d);f.stdout.on("data",a=>{g+=a.toString()}),f.stderr.on("data",a=>{h+=a.toString()}),f.on("close",a=>{i=!0,clearTimeout(j),e({ok:0===a,code:a,stdout:g,stderr:h})}),c&&f.stdin.write(c),f.stdin.end()})}async function A(a,b={}){let c=a.sshUser||"root",d=Number(a.sshPort||22),e=`${c}@${a.host}`,f=function(a,b={}){let c="/opt/bluerouter-ollama-agent",d=(a.ollamaPorts||[11434]).join(","),e=String.raw`#!/usr/bin/env python3
-import json
-import os
-import re
-import socket
-import subprocess
-import urllib.request
-from datetime import datetime, timezone
-from http.server import BaseHTTPRequestHandler, HTTPServer
-
-PORT = int(os.environ.get("AGENT_PORT", "19999"))
-OLLAMA_HOST = os.environ.get("OLLAMA_HOST", "127.0.0.1")
-OLLAMA_PORTS = [p.strip() for p in os.environ.get("OLLAMA_PORTS", "11434").split(",") if p.strip()]
-AGENT_TOKEN = os.environ.get("AGENT_TOKEN", "")
-
-
-def run_cmd(cmd, timeout=4):
-    try:
-        return subprocess.check_output(cmd, stderr=subprocess.STDOUT, timeout=timeout, text=True).strip()
-    except Exception:
-        return None
-
-
-def run_json(cmd, timeout=6):
-    out = run_cmd(cmd, timeout=timeout)
-    if not out:
-        return None
-    try:
-        return json.loads(out)
-    except Exception:
-        return None
-
-
-def http_json(url, timeout=3):
-    try:
-        with urllib.request.urlopen(url, timeout=timeout) as r:
-            return json.loads(r.read().decode("utf-8"))
-    except Exception:
-        return None
-
-
-def read_file(path):
-    try:
-        with open(path, "rb") as f:
-            return f.read()
-    except Exception:
-        return b""
-
-
-def read_text(path):
-    try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()
-    except Exception:
-        return ""
-
-
-def read_cmdline(pid):
-    raw = read_file(f"/proc/{pid}/cmdline")
-    if not raw:
-        return ""
-    return raw.replace(b"\x00", b" ").decode("utf-8", errors="ignore").strip()
-
-
-def read_environ(pid):
-    raw = read_file(f"/proc/{pid}/environ")
-    env = {}
-    if not raw:
-        return env
-    for item in raw.split(b"\x00"):
-        if not item or b"=" not in item:
-            continue
-        k, v = item.split(b"=", 1)
-        env[k.decode("utf-8", errors="ignore")] = v.decode("utf-8", errors="ignore")
-    return env
-
-
-def parse_systemd_environment(text):
-    # systemctl show -p Environment usually returns: Environment=A=1 B=two C=/x/y
-    env = {}
-    if not text:
-        return env
-    if text.startswith("Environment="):
-        text = text[len("Environment="):]
-    for part in re.findall(r'(?:[^\s"\']+|"[^"]*"|\'[^\']*\')+', text):
-        item = part.strip().strip('"').strip("'")
-        if "=" not in item:
-            continue
-        k, v = item.split("=", 1)
-        if k:
-            env[k] = v
-    return env
-
-
-def get_service_from_cgroup(pid):
-    text = read_text(f"/proc/{pid}/cgroup")
-    m = re.search(r'/system\.slice/([^/]+\.service)', text)
-    if m:
-        return m.group(1)
-    # user services may appear under user.slice/user-1000.slice/.../app.slice/name.service
-    m = re.search(r'/([^/]+\.service)(?:$|/)', text)
-    if m:
-        return m.group(1)
-    return None
-
-
-def get_systemd_env(service):
-    if not service:
-        return {}
-    out = run_cmd(["systemctl", "show", service, "-p", "Environment"], timeout=3)
-    return parse_systemd_environment(out or "")
-
-
-def get_gpu_status():
-    out = run_cmd([
-        "nvidia-smi",
-        "--query-gpu=index,uuid,name,memory.total,memory.used,memory.free,utilization.gpu,temperature.gpu",
-        "--format=csv,noheader,nounits"
-    ])
-    if not out:
-        return []
-    gpus = []
-    for line in out.splitlines():
-        parts = [x.strip() for x in line.split(",")]
-        if len(parts) < 8:
-            continue
-        try:
-            idx, uuid, name, total, used, free, util, temp = parts[:8]
-            total = int(float(total)); used = int(float(used)); free = int(float(free))
-            gpus.append({
-                "index": int(float(idx)),
-                "uuid": uuid,
-                "name": name,
-                "vramTotalMb": total,
-                "vramUsedMb": used,
-                "vramFreeMb": free,
-                "vramUsedPercent": round((used / total) * 100, 2) if total else None,
-                "gpuUsagePercent": int(float(util)),
-                "temperatureC": int(float(temp))
-            })
-        except Exception:
-            pass
-    return gpus
-
-
-def get_ram_status():
-    out = run_cmd(["free", "-m"])
-    if not out:
-        return None
-    for line in out.splitlines():
-        if line.lower().startswith("mem:"):
-            p = line.split()
-            total = int(p[1]); used = int(p[2]); free = int(p[3])
-            avail = int(p[6]) if len(p) > 6 else free
-            return {
-                "totalMb": total,
-                "usedMb": used,
-                "freeMb": free,
-                "availableMb": avail,
-                "usedPercent": round((used / total) * 100, 2) if total else None
-            }
-    return None
-
-
-def get_cpu_status():
-    load = os.getloadavg()
-    cores = os.cpu_count() or 1
-    return {
-        "cores": cores,
-        "load1": load[0],
-        "load5": load[1],
-        "load15": load[2],
-        "load1PercentOfCores": round((load[0] / cores) * 100, 2)
-    }
-
-
-def get_gpu_processes(gpus):
-    uuid_to_index = {g.get("uuid"): g.get("index") for g in gpus if g.get("uuid")}
-    out = run_cmd([
-        "nvidia-smi",
-        "--query-compute-apps=gpu_uuid,pid,process_name,used_memory",
-        "--format=csv,noheader,nounits"
-    ])
-    processes = []
-    if out:
-        for line in out.splitlines():
-            parts = [x.strip() for x in line.split(",")]
-            if len(parts) < 4:
-                continue
-            gpu_uuid, pid, process_name, used_memory = parts[:4]
-            try:
-                pid_n = int(float(pid))
-                used_n = int(float(str(used_memory).replace("MiB", "").strip()))
-            except Exception:
-                continue
-            processes.append({
-                "gpuUuid": gpu_uuid,
-                "gpuIndex": uuid_to_index.get(gpu_uuid),
-                "pid": pid_n,
-                "processName": process_name,
-                "usedMemoryMb": used_n
-            })
-    return processes
-
-
-def compact_model(item):
-    if not isinstance(item, dict):
-        return None
-    return {
-        "name": item.get("name") or item.get("model"),
-        "model": item.get("model") or item.get("name"),
-        "digest": item.get("digest"),
-        "size": item.get("size"),
-        "size_vram": item.get("size_vram"),
-        "expires_at": item.get("expires_at"),
-        "context_length": item.get("context_length"),
-        "details": item.get("details") or {}
-    }
-
-
-def find_listener_pid_by_ss(port):
-    candidates = []
-    commands = [
-        ["ss", "-H", "-ltnp", "sport", "=", f":{port}"],
-        ["ss", "-H", "-ltnp"],
-    ]
-    for cmd in commands:
-        out = run_cmd(cmd, timeout=3)
-        if not out:
-            continue
-        for line in out.splitlines():
-            if f":{port}" not in line:
-                continue
-            for pid in re.findall(r'pid=([0-9]+)', line):
-                candidates.append({"pid": int(pid), "source": "ss", "line": line})
-    return candidates
-
-
-def find_listener_pid_by_lsof(port):
-    candidates = []
-    out = run_cmd(["lsof", "-nP", f"-iTCP:{port}", "-sTCP:LISTEN"], timeout=4)
-    if not out:
-        return candidates
-    for line in out.splitlines()[1:]:
-        parts = line.split()
-        if len(parts) >= 2 and parts[1].isdigit():
-            candidates.append({"pid": int(parts[1]), "source": "lsof", "line": line})
-    return candidates
-
-
-def find_listener_pid_by_fuser(port):
-    candidates = []
-    out = run_cmd(["fuser", "-n", "tcp", str(port)], timeout=4)
-    if not out:
-        return candidates
-    for pid in re.findall(r'\b[0-9]+\b', out):
-        candidates.append({"pid": int(pid), "source": "fuser", "line": out})
-    return candidates
-
-
-def tcp_port_hex(port):
-    return f"{int(port):04X}"
-
-
-def listener_inodes_for_port(port):
-    inodes = set()
-    want = tcp_port_hex(port)
-    for path in ["/proc/net/tcp", "/proc/net/tcp6"]:
-        text = read_text(path)
-        for line in text.splitlines()[1:]:
-            cols = line.split()
-            if len(cols) < 10:
-                continue
-            local = cols[1]
-            state = cols[3]
-            inode = cols[9]
-            if state != "0A":
-                continue
-            if local.split(":")[-1].upper() == want:
-                inodes.add(inode)
-    return inodes
-
-
-def find_listener_pid_by_proc(port):
-    candidates = []
-    inodes = listener_inodes_for_port(port)
-    if not inodes:
-        return candidates
-    proc_root = "/proc"
-    for pid in os.listdir(proc_root):
-        if not pid.isdigit():
-            continue
-        fd_dir = os.path.join(proc_root, pid, "fd")
-        try:
-            fds = os.listdir(fd_dir)
-        except Exception:
-            continue
-        for fd in fds:
-            try:
-                target = os.readlink(os.path.join(fd_dir, fd))
-            except Exception:
-                continue
-            m = re.match(r'socket:\[([0-9]+)\]', target)
-            if m and m.group(1) in inodes:
-                candidates.append({"pid": int(pid), "source": "proc-net", "line": f"inode={m.group(1)} fd={fd}"})
-                break
-    return candidates
-
-
-def find_listener_pid(port):
-    all_candidates = []
-    for fn in [find_listener_pid_by_ss, find_listener_pid_by_lsof, find_listener_pid_by_fuser, find_listener_pid_by_proc]:
-        try:
-            all_candidates.extend(fn(port))
-        except Exception:
-            pass
-    seen = set()
-    unique = []
-    for c in all_candidates:
-        pid = c.get("pid")
-        if not pid or pid in seen:
-            continue
-        seen.add(pid)
-        unique.append(c)
-    if not unique:
-        return None, None, []
-    chosen = unique[0]
-    return chosen.get("pid"), chosen.get("source"), unique
-
-
-def process_tree_pids(root_pid):
-    try:
-        root_pid = int(root_pid)
-    except Exception:
-        return []
-    out = run_cmd(["ps", "-eo", "pid=,ppid=,cmd="], timeout=4)
-    children = {}
-    if out:
-        for line in out.splitlines():
-            parts = line.strip().split(None, 2)
-            if len(parts) < 2:
-                continue
-            try:
-                pid = int(parts[0]); ppid = int(parts[1])
-            except Exception:
-                continue
-            children.setdefault(ppid, []).append(pid)
-    result = []
-    stack = [root_pid]
-    seen = set()
-    while stack:
-        pid = stack.pop()
-        if pid in seen:
-            continue
-        seen.add(pid)
-        result.append(pid)
-        stack.extend(children.get(pid, []))
-    return result
-
-
-def docker_ps_rows():
-    out = run_cmd(["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Ports}}"], timeout=5)
-    rows = []
-    if not out:
-        return rows
-    for line in out.splitlines():
-        parts = line.split("\t")
-        if len(parts) >= 3:
-            rows.append({"id": parts[0], "name": parts[1], "ports": parts[2]})
-    return rows
-
-
-def docker_inspect(cid):
-    data = run_json(["docker", "inspect", cid], timeout=6)
-    if isinstance(data, list) and data:
-        return data[0]
-    return None
-
-
-def find_docker_container_for_port(port, docker_proxy_info=None):
-    # Prefer Docker's authoritative NetworkSettings.Ports mapping.
-    for row in docker_ps_rows():
-        info = docker_inspect(row["id"])
-        if not info:
-            continue
-        ports = (((info.get("NetworkSettings") or {}).get("Ports")) or {})
-        for container_port, host_bindings in ports.items():
-            if not str(container_port).startswith(str(port)) and not str(container_port).startswith(str((docker_proxy_info or {}).get("containerPort", ""))):
-                pass
-            for binding in host_bindings or []:
-                if str(binding.get("HostPort")) == str(port):
-                    return row, info
-        # Fallback: match container IP parsed from docker-proxy command.
-        container_ip = (docker_proxy_info or {}).get("containerIp")
-        if container_ip:
-            networks = ((info.get("NetworkSettings") or {}).get("Networks")) or {}
-            for net in networks.values():
-                if net.get("IPAddress") == container_ip:
-                    return row, info
-        # Fallback: match docker ps formatted Ports text.
-        if f":{port}->" in row.get("ports", "") or f"0.0.0.0:{port}" in row.get("ports", "") or f"[::]:{port}" in row.get("ports", ""):
-            return row, info
-    return None, None
-
-
-def parse_docker_proxy_cmd(cmdline):
-    if "docker-proxy" not in (cmdline or ""):
-        return None
-    tokens = cmdline.split()
-    out = {"kind": "docker-proxy"}
-    for i, token in enumerate(tokens):
-        if token in ["-host-port", "--host-port"] and i + 1 < len(tokens):
-            out["hostPort"] = tokens[i + 1]
-        elif token in ["-container-port", "--container-port"] and i + 1 < len(tokens):
-            out["containerPort"] = tokens[i + 1]
-        elif token in ["-container-ip", "--container-ip"] and i + 1 < len(tokens):
-            out["containerIp"] = tokens[i + 1]
-    return out
-
-
-def docker_env_and_meta(port, pid, cmdline):
-    proxy = parse_docker_proxy_cmd(cmdline)
-    if not proxy:
-        return None
-    row, info = find_docker_container_for_port(port, proxy)
-    if not info:
-        return {
-            "runtimeType": "docker-proxy",
-            "dockerProxy": proxy,
-            "containerFound": False,
-            "env": {},
-            "source": "docker-proxy-no-container"
-        }
-    env_list = ((info.get("Config") or {}).get("Env")) or []
-    env = {}
-    for item in env_list:
-        if "=" in item:
-            k, v = item.split("=", 1)
-            env[k] = v
-    host_config = info.get("HostConfig") or {}
-    state = info.get("State") or {}
-    labels = (info.get("Config") or {}).get("Labels") or {}
-    networks = ((info.get("NetworkSettings") or {}).get("Networks")) or {}
-    ips = []
-    for net_name, net in networks.items():
-        if net.get("IPAddress"):
-            ips.append({"network": net_name, "ip": net.get("IPAddress")})
-    return {
-        "runtimeType": "docker",
-        "dockerProxy": proxy,
-        "containerFound": True,
-        "containerId": (info.get("Id") or row.get("id"))[:12],
-        "containerName": (info.get("Name") or row.get("name") or "").lstrip("/"),
-        "containerImage": (info.get("Config") or {}).get("Image"),
-        "containerPid": state.get("Pid"),
-        "containerIps": ips,
-        "dockerPorts": row.get("ports"),
-        "dockerNetworkMode": host_config.get("NetworkMode"),
-        "dockerDeviceRequests": host_config.get("DeviceRequests") or [],
-        "dockerLabels": labels,
-        "env": env,
-        "source": "docker-inspect"
-    }
-
-
-def parse_visible_devices(value, gpus, source):
-    if value is None:
-        return None
-    raw = str(value).strip()
-    lower = raw.lower()
-    if raw == "":
-        return None
-    if lower in ["none", "void", "no", "false", "-1"]:
-        return {"indices": [], "mode": "disabled", "source": source, "raw": raw}
-    if lower == "all":
-        return {"indices": [g["index"] for g in gpus], "mode": "all-visible", "source": source, "raw": raw}
-    uuid_to_index = {str(g.get("uuid")): g.get("index") for g in gpus if g.get("uuid")}
-    indices = []
-    unknown = []
-    for item in re.split(r'[,;\s]+', raw):
-        if not item:
-            continue
-        if item.isdigit():
-            indices.append(int(item))
-        elif item in uuid_to_index:
-            indices.append(uuid_to_index[item])
-        elif item.startswith("GPU-") and item in uuid_to_index:
-            indices.append(uuid_to_index[item])
-        elif item.startswith("MIG-"):
-            unknown.append(item)
-        else:
-            unknown.append(item)
-    return {
-        "indices": sorted(list(set(indices))),
-        "mode": "specific" if indices else "unknown",
-        "source": source,
-        "raw": raw,
-        "unknownDevices": unknown
-    }
-
-
-def parse_device_requests(device_requests, gpus):
-    if not device_requests:
-        return None
-    ids = []
-    all_gpu = False
-    for req in device_requests:
-        count = req.get("Count")
-        caps = req.get("Capabilities") or []
-        driver = req.get("Driver")
-        req_ids = req.get("DeviceIDs") or []
-        if driver == "nvidia" or any("gpu" in str(x).lower() for cap in caps for x in cap):
-            if count == -1 and not req_ids:
-                all_gpu = True
-            ids.extend(req_ids)
-    if all_gpu:
-        return {"indices": [g["index"] for g in gpus], "mode": "all-visible", "source": "docker-device-requests:all", "raw": "all"}
-    if ids:
-        return parse_visible_devices(",".join(ids), gpus, "docker-device-requests")
-    return None
-
-
-def configured_gpu_from_env(runtime_type, env, gpus, docker_meta=None):
-    # Prefer NVIDIA_VISIBLE_DEVICES in Docker, CUDA_VISIBLE_DEVICES for direct/systemd.
-    candidates = []
-    if runtime_type == "docker":
-        candidates = [
-            ("NVIDIA_VISIBLE_DEVICES", env.get("NVIDIA_VISIBLE_DEVICES")),
-            ("CUDA_VISIBLE_DEVICES", env.get("CUDA_VISIBLE_DEVICES")),
-        ]
-        req = parse_device_requests((docker_meta or {}).get("dockerDeviceRequests"), gpus)
-        if req:
-            return req
-    else:
-        candidates = [
-            ("CUDA_VISIBLE_DEVICES", env.get("CUDA_VISIBLE_DEVICES")),
-            ("NVIDIA_VISIBLE_DEVICES", env.get("NVIDIA_VISIBLE_DEVICES")),
-            ("HIP_VISIBLE_DEVICES", env.get("HIP_VISIBLE_DEVICES")),
-            ("ROCR_VISIBLE_DEVICES", env.get("ROCR_VISIBLE_DEVICES")),
-        ]
-    for key, value in candidates:
-        parsed = parse_visible_devices(value, gpus, f"{runtime_type}-env:{key}")
-        if parsed:
-            return parsed
-    if runtime_type in ["systemd", "direct"]:
-        return {"indices": [g["index"] for g in gpus], "mode": "all-visible", "source": "all-visible-no-env", "raw": None}
-    if runtime_type == "docker":
-        # For Docker, lack of NVIDIA_VISIBLE_DEVICES is less conclusive.
-        return {"indices": [], "mode": "unknown", "source": "docker-no-visible-devices-env", "raw": None}
-    return {"indices": [], "mode": "unknown", "source": "no-gpu-config", "raw": None}
-
-
-def process_metadata(port, pid, gpus):
-    if not pid:
-        return {"runtimeType": "unknown", "env": {}, "configured": configured_gpu_from_env("unknown", {}, gpus)}
-    cmdline = read_cmdline(pid)
-    service = get_service_from_cgroup(pid)
-    runtime_type = "systemd" if service else "direct"
-    docker_meta = docker_env_and_meta(port, pid, cmdline)
-    if docker_meta:
-        runtime_type = docker_meta.get("runtimeType") or "docker"
-        env = docker_meta.get("env") or {}
-        configured = configured_gpu_from_env("docker", env, gpus, docker_meta)
-        return {
-            "runtimeType": runtime_type,
-            "processCmdline": cmdline,
-            "serviceName": service,
-            "env": env,
-            "configured": configured,
-            **{k: v for k, v in docker_meta.items() if k not in ["env"]}
-        }
-    env = {}
-    env.update(get_systemd_env(service))
-    env.update(read_environ(pid))
-    configured = configured_gpu_from_env("systemd" if service else "direct", env, gpus)
-    return {
-        "runtimeType": runtime_type,
-        "processCmdline": cmdline,
-        "serviceName": service,
-        "env": {k: v for k, v in env.items() if re.search(r'OLLAMA|CUDA|NVIDIA|HIP|ROCR|GPU', k, re.I)},
-        "configured": configured,
-    }
-
-
-def gpu_processes_for_pids(gpu_processes, pids):
-    pid_set = set(int(x) for x in pids if x)
-    return [p for p in gpu_processes if int(p.get("pid") or -1) in pid_set]
-
-
-def infer_gpu_from_ps(ps_models, gpus, configured):
-    size_bytes = sum(int(m.get("size_vram") or 0) for m in ps_models or [])
-    size_mb = int(size_bytes / (1024 * 1024)) if size_bytes else 0
-    if size_mb <= 0:
-        return [], 0, None
-    configured_indices = configured.get("indices") or [] if configured else []
-    if configured_indices:
-        return configured_indices, size_mb, "ollama-ps-configured-gpu-inferred"
-    if len(gpus) == 1:
-        return [gpus[0]["index"]], size_mb, "ollama-ps-single-gpu-inferred"
-    # Conservative multi-GPU inference: only infer if one GPU's used memory is close enough.
-    candidates = []
-    for gpu in gpus:
-        used = int(gpu.get("vramUsedMb") or 0)
-        if used >= max(512, int(size_mb * 0.45)):
-            candidates.append(gpu)
-    if len(candidates) == 1:
-        return [candidates[0]["index"]], size_mb, "ollama-ps-single-used-gpu-inferred"
-    return [], 0, None
-
-
-def get_ollama_instance(port, gpus, gpu_processes):
-    base = f"http://{OLLAMA_HOST}:{port}"
-    tags = http_json(f"{base}/api/tags")
-    ps = http_json(f"{base}/api/ps")
-
-    model_details = []
-    models = []
-    if tags and isinstance(tags.get("models"), list):
-        for m in tags["models"]:
-            cm = compact_model(m)
-            if cm and cm.get("name"):
-                model_details.append(cm)
-                models.append(cm["name"])
-
-    ps_models = []
-    loaded_models = []
-    if ps and isinstance(ps.get("models"), list):
-        for m in ps["models"]:
-            cm = compact_model(m)
-            if cm and cm.get("name"):
-                ps_models.append(cm)
-                loaded_models.append(cm["name"])
-
-    pid, pid_source, pid_candidates = find_listener_pid(port)
-    meta = process_metadata(port, pid, gpus)
-    pid_tree = process_tree_pids(pid) if pid else []
-    # Docker containers may expose a container init PID whose children hold GPU handles.
-    container_pid = meta.get("containerPid")
-    if container_pid:
-        pid_tree = sorted(list(set(pid_tree + process_tree_pids(container_pid))))
-    matched_gpu_processes = gpu_processes_for_pids(gpu_processes, pid_tree)
-    runtime_indices = sorted(list(set([p.get("gpuIndex") for p in matched_gpu_processes if p.get("gpuIndex") is not None])))
-    runtime_used = sum(int(p.get("usedMemoryMb") or 0) for p in matched_gpu_processes)
-    runtime_source = "port-pid-nvidia-smi" if runtime_indices else None
-    ps_indices, ps_used, ps_source = infer_gpu_from_ps(ps_models, gpus, meta.get("configured") or {})
-
-    configured = meta.get("configured") or {}
-    effective_indices = []
-    effective_source = None
-    if configured.get("indices"):
-        effective_indices = configured.get("indices")
-        effective_source = configured.get("source")
-    elif runtime_indices:
-        effective_indices = runtime_indices
-        effective_source = runtime_source
-    elif ps_indices:
-        effective_indices = ps_indices
-        effective_source = ps_source
-
-    detected_indices = runtime_indices or ps_indices
-    detected_used = runtime_used if runtime_indices else ps_used
-    detected_source = runtime_source or ps_source or ("port-pid-no-gpu" if pid else None)
-
-    return {
-        "id": f"ollama-{port}",
-        "port": int(port),
-        "baseUrl": base,
-        "alive": tags is not None,
-        "models": models,
-        "modelDetails": model_details,
-        "loadedModels": loaded_models,
-        "psModels": ps_models,
-        "loadedDigests": sorted(list(set([m.get("digest") for m in ps_models if m.get("digest")]))),
-        "pid": pid,
-        "pidDetectionSource": pid_source,
-        "pidCandidates": pid_candidates,
-        "pidTree": pid_tree,
-        "runtimeType": meta.get("runtimeType"),
-        "serviceName": meta.get("serviceName"),
-        "processCmdline": meta.get("processCmdline"),
-        "processEnv": meta.get("env"),
-        "containerId": meta.get("containerId"),
-        "containerName": meta.get("containerName"),
-        "containerImage": meta.get("containerImage"),
-        "containerPid": meta.get("containerPid"),
-        "containerIps": meta.get("containerIps"),
-        "dockerNetworkMode": meta.get("dockerNetworkMode"),
-        "dockerPorts": meta.get("dockerPorts"),
-        "dockerDeviceRequests": meta.get("dockerDeviceRequests"),
-        "dockerLabels": meta.get("dockerLabels"),
-        "dockerProxy": meta.get("dockerProxy"),
-        "configuredGpuIndices": configured.get("indices") or [],
-        "configuredGpuMode": configured.get("mode"),
-        "configuredGpuSource": configured.get("source"),
-        "configuredGpuRaw": configured.get("raw"),
-        "configuredGpuUnknownDevices": configured.get("unknownDevices") or [],
-        "runtimeGpuIndices": runtime_indices,
-        "runtimeGpuVramUsedMb": runtime_used,
-        "runtimeGpuProcesses": matched_gpu_processes,
-        "detectedGpuIndices": detected_indices,
-        "detectedGpuVramUsedMb": detected_used,
-        "detectedGpuProcesses": matched_gpu_processes,
-        "detectedGpuBindingSource": detected_source,
-        "effectiveGpuIndices": effective_indices,
-        "effectiveGpuSource": effective_source,
-    }
-
-
-def build_status():
-    hostname = run_cmd(["hostname"]) or "unknown"
-    gpus = get_gpu_status()
-    gpu_processes = get_gpu_processes(gpus)
-    ram = get_ram_status()
-    cpu = get_cpu_status()
-    instances = [get_ollama_instance(p, gpus, gpu_processes) for p in OLLAMA_PORTS]
-    tags = ["ollama", "lan"]
-    if gpus:
-        tags += ["gpu", "nvidia"]
-        for gpu in gpus:
-            tags.append(f"gpu:{gpu.get('index')}:{str(gpu.get('name','')).lower().replace(' ','-')}")
-    else:
-        tags.append("cpu")
-    for inst in instances:
-        for model in inst.get("models", []):
-            tags.append(f"model_support:{model}")
-    best_gpu = max(gpus, key=lambda x: x.get("vramFreeMb", 0)) if gpus else None
-    return {
-        "ok": True,
-        "hostname": hostname,
-        "provider": "ollama",
-        "instances": instances,
-        "hardware": {"cpu": cpu, "ram": ram, "gpus": gpus, "gpuProcesses": gpu_processes},
-        "score": {
-            "gpuFreeVramMb": best_gpu.get("vramFreeMb") if best_gpu else 0,
-            "gpuUsagePercent": best_gpu.get("gpuUsagePercent") if best_gpu else None,
-            "ramAvailableMb": ram.get("availableMb") if ram else None
-        },
-        "tags": sorted(set(tags)),
-        "updatedAt": datetime.now(timezone.utc).isoformat()
-    }
-
-
-class Handler(BaseHTTPRequestHandler):
-    def _send(self, code, payload):
-        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-        self.send_response(code)
-        self.send_header("Content-Type", "application/json; charset=utf-8")
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-
-    def _authorized(self):
-        return (not AGENT_TOKEN) or self.headers.get("Authorization", "") == f"Bearer {AGENT_TOKEN}"
-
-    def do_GET(self):
-        if self.path not in ["/status", "/health"]:
-            self._send(404, {"ok": False, "error": "not_found"})
-            return
-        if not self._authorized():
-            self._send(401, {"ok": False, "error": "unauthorized"})
-            return
-        if self.path == "/health":
-            self._send(200, {"ok": True})
-            return
-        try:
-            self._send(200, build_status())
-        except Exception as e:
-            self._send(500, {"ok": False, "error": str(e)})
-
-    def log_message(self, fmt, *args):
-        return
-
-
-if __name__ == "__main__":
-    print(f"BlueRouter Ollama Agent listening on 0.0.0.0:{PORT}; ports={OLLAMA_PORTS}")
-    HTTPServer(("0.0.0.0", PORT), Handler).serve_forever()
-`,f=String(b.ufwAllowFrom??a.ufwAllowFrom??"").trim(),g=Number(a.agentPort||19999),h=String(b.ollamaHost||"127.0.0.1"),i=String(a.agentToken||"");return`#!/usr/bin/env bash
-set -euo pipefail
-AGENT_DIR=${y(c)}
-mkdir -p "$AGENT_DIR"
-cat > "$AGENT_DIR/agent.py" <<'PY_AGENT'
-${e}
-PY_AGENT
-chmod +x "$AGENT_DIR/agent.py"
-cat > /etc/systemd/system/bluerouter-ollama-agent.service <<'SERVICE'
-[Unit]
-Description=BlueRouter Ollama Hardware Status Agent
-After=network.target docker.service ollama.service
-
-[Service]
-Type=simple
-WorkingDirectory=${c}
-Environment="AGENT_PORT=${g}"
-Environment="OLLAMA_HOST=${h}"
-Environment="OLLAMA_PORTS=${d}"
-Environment="AGENT_TOKEN=${i}"
-ExecStart=/usr/bin/python3 ${c}/agent.py
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=multi-user.target
-SERVICE
-systemctl daemon-reload
-systemctl enable bluerouter-ollama-agent
-systemctl restart bluerouter-ollama-agent
-if command -v ufw >/dev/null 2>&1 && [ -n ${y(f)} ]; then
-  ufw allow from ${y(f)} to any port ${g} proto tcp || true
-fi
-systemctl status bluerouter-ollama-agent --no-pager || true
-echo "Installed BlueRouter Ollama Agent"
-echo "Agent port: ${g}"
-echo "Ollama host: ${h}"
-echo "Ollama ports: ${d}"
-`}(a,b),g=!0===a.useSudo&&"root"!==c,h=b.sudoPassword||b.sshPassword||"",i=g?`${h}
-${f}`:f,j=["-p",String(d),"-o","StrictHostKeyChecking=no",e,g?"sudo -S -p '' bash -s":"bash -s"];return b.sshPassword?z("sshpass",["-p",b.sshPassword,"ssh",...j],{input:i}):z("ssh",j,{input:i})}let B="nodejs",C="force-dynamic";async function D(a,b){let{id:c}=await b.params,d=await (0,w.Vs)(c);if(!d)return v.NextResponse.json({error:"not_found"},{status:404});let e=await a.json().catch(()=>({}));try{let a=await A(d,{sshPassword:e.sshPassword||"",sudoPassword:e.sudoPassword||"",ufwAllowFrom:e.ufwAllowFrom,ollamaHost:e.ollamaHost||"127.0.0.1"});if(await (0,w.YT)(d.id,{lastInstallAt:new Date().toISOString(),lastInstallOk:a.ok,lastInstallLog:[a.stdout,a.stderr].filter(Boolean).join("\n").slice(-12e3)}),!a.ok)return v.NextResponse.json({ok:!1,error:"Remote install failed",result:a},{status:500});return v.NextResponse.json({ok:!0,result:a})}catch(a){return v.NextResponse.json({ok:!1,error:a.message||"Remote install failed"},{status:500})}}let E=new e.AppRouteRouteModule({definition:{kind:f.RouteKind.APP_ROUTE,page:"/api/ollama-nodes/[id]/install/route",pathname:"/api/ollama-nodes/[id]/install",filename:"route",bundlePath:"app/api/ollama-nodes/[id]/install/route"},distDir:".next-cli-build",relativeProjectDir:"",resolvedPagePath:"D:\\bluerouter\\src\\app\\api\\ollama-nodes\\[id]\\install\\route.js",nextConfigOutput:"standalone",userland:d,...{}}),{workAsyncStorage:F,workUnitAsyncStorage:G,serverHooks:H}=E;function I(){return(0,g.patchFetch)({workAsyncStorage:F,workUnitAsyncStorage:G})}async function J(a,b,c){c.requestMeta&&(0,h.setRequestMeta)(a,c.requestMeta),E.isDev&&(0,h.addRequestMeta)(a,"devRequestTimingInternalsEnd",process.hrtime.bigint());let d="/api/ollama-nodes/[id]/install/route";"/index"===d&&(d="/");let e=await E.prepare(a,b,{srcPage:d,multiZoneDraftMode:!1});if(!e)return b.statusCode=400,b.end("Bad Request"),null==c.waitUntil||c.waitUntil.call(c,Promise.resolve()),null;let{buildId:g,deploymentId:v,params:w,nextConfig:x,parsedUrl:y,isDraftMode:z,prerenderManifest:A,routerServerContext:B,isOnDemandRevalidate:C,revalidateOnlyGenerated:D,resolvedPathname:F,clientReferenceManifest:G,serverActionsManifest:H}=e,I=(0,k.normalizeAppPath)(d),J=!!(A.dynamicRoutes[I]||A.routes[F]),K=async()=>((null==B?void 0:B.render404)?await B.render404(a,b,y,!1):b.end("This page could not be found"),null);if(J&&!z){let a=!!A.routes[F],b=A.dynamicRoutes[I];if(b&&!1===b.fallback&&!a){if(x.adapterPath)return await K();throw new t.NoFallbackError}}let L=null;!J||E.isDev||z||(L="/index"===(L=F)?"/":L);let M=!0===E.isDev||!J,N=J&&!M;H&&G&&(0,j.setManifestsSingleton)({page:d,clientReferenceManifest:G,serverActionsManifest:H});let O=a.method||"GET",P=(0,i.getTracer)(),Q=P.getActiveScopeSpan(),R=!!(null==B?void 0:B.isWrappedByNextServer),S=!!(0,h.getRequestMeta)(a,"minimalMode"),T=(0,h.getRequestMeta)(a,"incrementalCache")||await E.getIncrementalCache(a,x,A,S);null==T||T.resetRequestCache(),globalThis.__incrementalCache=T;let U={params:w,previewProps:A.preview,renderOpts:{experimental:{authInterrupts:!!x.experimental.authInterrupts},cacheComponents:!!x.cacheComponents,supportsDynamicResponse:M,incrementalCache:T,cacheLifeProfiles:x.cacheLife,waitUntil:c.waitUntil,onClose:a=>{b.on("close",a)},onAfterTaskError:void 0,onInstrumentationRequestError:(b,c,d,e)=>E.onRequestError(a,b,d,e,B)},sharedContext:{buildId:g,deploymentId:v}},V=new l.NodeNextRequest(a),W=new l.NodeNextResponse(b),X=m.NextRequestAdapter.fromNodeNextRequest(V,(0,m.signalFromNodeResponse)(b));try{let e,g=async a=>E.handle(X,U).finally(()=>{if(!a)return;a.setAttributes({"http.status_code":b.statusCode,"next.rsc":!1});let c=P.getRootSpanAttributes();if(!c)return;if(c.get("next.span_type")!==n.BaseServerSpan.handleRequest)return void console.warn(`Unexpected root span type '${c.get("next.span_type")}'. Please report this Next.js issue https://github.com/vercel/next.js`);let f=c.get("next.route");if(f){let b=`${O} ${f}`;a.setAttributes({"next.route":f,"http.route":f,"next.span_name":b}),a.updateName(b),e&&e!==a&&(e.setAttribute("http.route",f),e.updateName(b))}else a.updateName(`${O} ${d}`)}),h=async e=>{var h,i;let j=async({previousCacheEntry:f})=>{try{if(!S&&C&&D&&!f)return b.statusCode=404,b.setHeader("x-nextjs-cache","REVALIDATED"),b.end("This page could not be found"),null;let d=await g(e);a.fetchMetrics=U.renderOpts.fetchMetrics;let h=U.renderOpts.pendingWaitUntil;h&&c.waitUntil&&(c.waitUntil(h),h=void 0);let i=U.renderOpts.collectedTags;if(!J)return await (0,p.I)(V,W,d,U.renderOpts.pendingWaitUntil),null;{let a=await d.blob(),b=(0,q.toNodeOutgoingHttpHeaders)(d.headers);i&&(b[s.NEXT_CACHE_TAGS_HEADER]=i),!b["content-type"]&&a.type&&(b["content-type"]=a.type);let c=void 0!==U.renderOpts.collectedRevalidate&&!(U.renderOpts.collectedRevalidate>=s.INFINITE_CACHE)&&U.renderOpts.collectedRevalidate,e=void 0===U.renderOpts.collectedExpire||U.renderOpts.collectedExpire>=s.INFINITE_CACHE?void 0:U.renderOpts.collectedExpire;return{value:{kind:u.CachedRouteKind.APP_ROUTE,status:d.status,body:Buffer.from(await a.arrayBuffer()),headers:b},cacheControl:{revalidate:c,expire:e}}}}catch(b){throw(null==f?void 0:f.isStale)&&await E.onRequestError(a,b,{routerKind:"App Router",routePath:d,routeType:"route",revalidateReason:(0,o.c)({isStaticGeneration:N,isOnDemandRevalidate:C})},!1,B),b}},k=await E.handleResponse({req:a,nextConfig:x,cacheKey:L,routeKind:f.RouteKind.APP_ROUTE,isFallback:!1,prerenderManifest:A,isRoutePPREnabled:!1,isOnDemandRevalidate:C,revalidateOnlyGenerated:D,responseGenerator:j,waitUntil:c.waitUntil,isMinimalMode:S});if(!J)return null;if((null==k||null==(h=k.value)?void 0:h.kind)!==u.CachedRouteKind.APP_ROUTE)throw Object.defineProperty(Error(`Invariant: app-route received invalid cache entry ${null==k||null==(i=k.value)?void 0:i.kind}`),"__NEXT_ERROR_CODE",{value:"E701",enumerable:!1,configurable:!0});S||b.setHeader("x-nextjs-cache",C?"REVALIDATED":k.isMiss?"MISS":k.isStale?"STALE":"HIT"),z&&b.setHeader("Cache-Control","private, no-cache, no-store, max-age=0, must-revalidate");let l=(0,q.fromNodeOutgoingHttpHeaders)(k.value.headers);return S&&J||l.delete(s.NEXT_CACHE_TAGS_HEADER),!k.cacheControl||b.getHeader("Cache-Control")||l.get("Cache-Control")||l.set("Cache-Control",(0,r.getCacheControlHeader)(k.cacheControl)),await (0,p.I)(V,W,new Response(k.value.body,{headers:l,status:k.value.status||200})),null};R&&Q?await h(Q):(e=P.getActiveScopeSpan(),await P.withPropagatedContext(a.headers,()=>P.trace(n.BaseServerSpan.handleRequest,{spanName:`${O} ${d}`,kind:i.SpanKind.SERVER,attributes:{"http.method":O,"http.target":a.url}},h),void 0,!R))}catch(b){if(b instanceof t.NoFallbackError||await E.onRequestError(a,b,{routerKind:"App Router",routePath:I,routeType:"route",revalidateReason:(0,o.c)({isStaticGeneration:N,isOnDemandRevalidate:C})},!1,B),J)throw b;return await (0,p.I)(V,W,new Response(null,{status:500})),null}}},96487:()=>{}};var b=require("../../../../../webpack-runtime.js");b.C(a);var c=b.X(0,[4741,1813,6774],()=>b(b.s=86762));module.exports=c})();