Checkpoint: Phase 12: Real-time Docker Swarm monitoring for /nodes page
Реализовано: - gateway/internal/docker/client.go: Docker API клиент через unix socket (/var/run/docker.sock) - IsSwarmActive(), GetSwarmInfo(), ListNodes(), ListContainers(), GetContainerStats() - CalcCPUPercent() для расчёта CPU% - gateway/internal/api/handlers.go: новые endpoints - GET /api/nodes: список Swarm нод или standalone Docker хост - GET /api/nodes/stats: live CPU/RAM статистика контейнеров - POST /api/tools/execute: выполнение инструментов - gateway/cmd/gateway/main.go: зарегистрированы новые маршруты - server/gateway-proxy.ts: добавлены getGatewayNodes() и getGatewayNodeStats() - server/routers.ts: добавлен nodes router (nodes.list, nodes.stats) - client/src/pages/Nodes.tsx: полностью переписан на реальные данные - Auto-refresh: 10s для нод, 15s для статистики контейнеров - Swarm mode: показывает все ноды кластера - Standalone mode: показывает локальный Docker хост + контейнеры - CPU/RAM gauges из реальных docker stats - Error state при недоступном Gateway - Loading skeleton - server/nodes.test.ts: 14 новых vitest тестов - Все 51 тест пройдены
This commit is contained in:
Manus
@@ -1,113 +1,36 @@
|
||||
/*
|
||||
* Nodes — Swarm Node Monitoring
|
||||
* Nodes — Swarm Node Monitoring (Real Data)
|
||||
* Data source: Go Gateway → Docker API (Swarm or standalone)
|
||||
* Auto-refresh: 10s for node list, 15s for container stats
|
||||
* Design: Detailed node cards with resource gauges, container lists
|
||||
* Colors: Cyan primary, green/amber/red for resource thresholds
|
||||
* Typography: JetBrains Mono for all metrics
|
||||
*/
|
||||
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
|
||||
import { useEffect, useState } from "react";
|
||||
import { Card, CardContent } from "@/components/ui/card";
|
||||
import { Badge } from "@/components/ui/badge";
|
||||
import { Progress } from "@/components/ui/progress";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import {
|
||||
Server,
|
||||
Cpu,
|
||||
HardDrive,
|
||||
Network,
|
||||
Container,
|
||||
Clock,
|
||||
MapPin,
|
||||
Layers,
|
||||
MapPin,
|
||||
RefreshCw,
|
||||
AlertCircle,
|
||||
Wifi,
|
||||
WifiOff,
|
||||
Crown,
|
||||
Activity,
|
||||
} from "lucide-react";
|
||||
import { motion } from "framer-motion";
|
||||
import { trpc } from "@/lib/trpc";
|
||||
|
||||
const NODE_VIS = "https://d2xsxph8kpxj0f.cloudfront.net/97147719/ZEGAT83geRq9CNvryykaQv/node-visualization-eDRHrwiVpLDMaH6VnWFsxn.webp";
|
||||
const NODE_VIS =
|
||||
"https://d2xsxph8kpxj0f.cloudfront.net/97147719/ZEGAT83geRq9CNvryykaQv/node-visualization-eDRHrwiVpLDMaH6VnWFsxn.webp";
|
||||
|
||||
const NODES_DATA = [
|
||||
{
|
||||
id: "node-01",
|
||||
hostname: "goclaw-manager-01",
|
||||
role: "Manager",
|
||||
status: "ready",
|
||||
ip: "192.168.1.10",
|
||||
os: "Ubuntu 22.04 LTS",
|
||||
arch: "amd64",
|
||||
cpu_cores: 8,
|
||||
cpu_usage: 42,
|
||||
mem_total: "16 GB",
|
||||
mem_usage: 68,
|
||||
disk_total: "256 GB",
|
||||
disk_usage: 45,
|
||||
containers: [
|
||||
{ name: "goclaw-gateway", status: "running", cpu: 12, mem: "256MB" },
|
||||
{ name: "goclaw-monitor", status: "running", cpu: 8, mem: "128MB" },
|
||||
{ name: "goclaw-redis", status: "running", cpu: 2, mem: "64MB" },
|
||||
{ name: "goclaw-control-ui", status: "running", cpu: 5, mem: "128MB" },
|
||||
{ name: "prometheus", status: "running", cpu: 15, mem: "512MB" },
|
||||
],
|
||||
uptime: "14d 7h 23m",
|
||||
docker_version: "24.0.7",
|
||||
},
|
||||
{
|
||||
id: "node-02",
|
||||
hostname: "goclaw-worker-01",
|
||||
role: "Worker",
|
||||
status: "ready",
|
||||
ip: "192.168.1.11",
|
||||
os: "Ubuntu 22.04 LTS",
|
||||
arch: "amd64",
|
||||
cpu_cores: 16,
|
||||
cpu_usage: 28,
|
||||
mem_total: "32 GB",
|
||||
mem_usage: 45,
|
||||
disk_total: "512 GB",
|
||||
disk_usage: 32,
|
||||
containers: [
|
||||
{ name: "goclaw-coder", status: "running", cpu: 15, mem: "512MB" },
|
||||
{ name: "goclaw-browser", status: "running", cpu: 10, mem: "1024MB" },
|
||||
{ name: "chromium-sandbox", status: "running", cpu: 3, mem: "256MB" },
|
||||
],
|
||||
uptime: "14d 7h 23m",
|
||||
docker_version: "24.0.7",
|
||||
},
|
||||
{
|
||||
id: "node-03",
|
||||
hostname: "goclaw-worker-02",
|
||||
role: "Worker",
|
||||
status: "ready",
|
||||
ip: "192.168.1.12",
|
||||
os: "Debian 12",
|
||||
arch: "arm64",
|
||||
cpu_cores: 4,
|
||||
cpu_usage: 15,
|
||||
mem_total: "8 GB",
|
||||
mem_usage: 32,
|
||||
disk_total: "128 GB",
|
||||
disk_usage: 22,
|
||||
containers: [
|
||||
{ name: "goclaw-mail", status: "idle", cpu: 2, mem: "128MB" },
|
||||
{ name: "goclaw-docs", status: "error", cpu: 0, mem: "0MB" },
|
||||
],
|
||||
uptime: "7d 2h 45m",
|
||||
docker_version: "24.0.7",
|
||||
},
|
||||
{
|
||||
id: "node-04",
|
||||
hostname: "goclaw-worker-03",
|
||||
role: "Worker",
|
||||
status: "drain",
|
||||
ip: "192.168.1.13",
|
||||
os: "Ubuntu 22.04 LTS",
|
||||
arch: "amd64",
|
||||
cpu_cores: 4,
|
||||
cpu_usage: 0,
|
||||
mem_total: "8 GB",
|
||||
mem_usage: 12,
|
||||
disk_total: "128 GB",
|
||||
disk_usage: 18,
|
||||
containers: [],
|
||||
uptime: "14d 7h 23m",
|
||||
docker_version: "24.0.7",
|
||||
},
|
||||
];
|
||||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
function getResourceColor(value: number) {
|
||||
if (value > 80) return "text-neon-red";
|
||||
@@ -116,129 +39,37 @@ function getResourceColor(value: number) {
|
||||
}
|
||||
|
||||
function getStatusBadge(status: string) {
|
||||
switch (status) {
|
||||
case "ready": return "bg-neon-green/15 text-neon-green border-neon-green/30";
|
||||
case "drain": return "bg-neon-amber/15 text-neon-amber border-neon-amber/30";
|
||||
case "down": return "bg-neon-red/15 text-neon-red border-neon-red/30";
|
||||
default: return "bg-muted text-muted-foreground border-border";
|
||||
switch (status.toLowerCase()) {
|
||||
case "ready":
|
||||
return "bg-neon-green/15 text-neon-green border-neon-green/30";
|
||||
case "drain":
|
||||
return "bg-neon-amber/15 text-neon-amber border-neon-amber/30";
|
||||
case "down":
|
||||
case "disconnected":
|
||||
return "bg-neon-red/15 text-neon-red border-neon-red/30";
|
||||
default:
|
||||
return "bg-muted text-muted-foreground border-border";
|
||||
}
|
||||
}
|
||||
|
||||
export default function Nodes() {
|
||||
return (
|
||||
<div className="space-y-6">
|
||||
{/* Header with visualization */}
|
||||
<div className="relative rounded-lg overflow-hidden h-48">
|
||||
<img src={NODE_VIS} alt="" className="absolute inset-0 w-full h-full object-cover opacity-30" />
|
||||
<div className="absolute inset-0 bg-gradient-to-r from-background via-background/70 to-transparent" />
|
||||
<div className="relative z-10 flex items-center h-full px-8">
|
||||
<div>
|
||||
<h2 className="text-xl font-bold text-foreground">Swarm Nodes</h2>
|
||||
<p className="text-sm text-muted-foreground font-mono mt-1">
|
||||
Docker Swarm Cluster · {NODES_DATA.filter(n => n.status === "ready").length} ready · {NODES_DATA.filter(n => n.status === "drain").length} drain
|
||||
</p>
|
||||
<div className="flex items-center gap-4 mt-3 font-mono text-[11px]">
|
||||
<span className="text-muted-foreground">Total CPU: <span className="text-primary font-medium">32 cores</span></span>
|
||||
<span className="text-muted-foreground">Total RAM: <span className="text-primary font-medium">64 GB</span></span>
|
||||
<span className="text-muted-foreground">Total Disk: <span className="text-primary font-medium">1024 GB</span></span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Node cards */}
|
||||
<div className="grid grid-cols-1 xl:grid-cols-2 gap-5">
|
||||
{NODES_DATA.map((node, i) => (
|
||||
<motion.div
|
||||
key={node.id}
|
||||
initial={{ opacity: 0, y: 10 }}
|
||||
animate={{ opacity: 1, y: 0 }}
|
||||
transition={{ delay: i * 0.1 }}
|
||||
>
|
||||
<Card className="bg-card border-border/50 hover:border-primary/30 transition-all">
|
||||
<CardContent className="p-5">
|
||||
{/* Header */}
|
||||
<div className="flex items-center justify-between mb-4">
|
||||
<div className="flex items-center gap-3">
|
||||
<div className={`w-10 h-10 rounded-lg border border-border/50 flex items-center justify-center ${
|
||||
node.role === "Manager" ? "bg-primary/15" : "bg-secondary/50"
|
||||
}`}>
|
||||
<Server className={`w-5 h-5 ${node.role === "Manager" ? "text-primary" : "text-muted-foreground"}`} />
|
||||
</div>
|
||||
<div>
|
||||
<h3 className="text-sm font-mono font-semibold text-foreground">{node.hostname}</h3>
|
||||
<div className="flex items-center gap-2 mt-0.5">
|
||||
<Badge variant="outline" className={`text-[10px] font-mono ${getStatusBadge(node.status)}`}>
|
||||
{node.status.toUpperCase()}
|
||||
</Badge>
|
||||
<span className="text-[10px] font-mono text-muted-foreground">{node.role}</span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div className="text-right text-[10px] font-mono text-muted-foreground">
|
||||
<div className="flex items-center gap-1 justify-end"><MapPin className="w-3 h-3" />{node.ip}</div>
|
||||
<div className="flex items-center gap-1 justify-end mt-0.5"><Clock className="w-3 h-3" />{node.uptime}</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* System info */}
|
||||
<div className="flex items-center gap-3 mb-4 text-[10px] font-mono text-muted-foreground">
|
||||
<span>{node.os}</span>
|
||||
<span>·</span>
|
||||
<span>{node.arch}</span>
|
||||
<span>·</span>
|
||||
<span>Docker {node.docker_version}</span>
|
||||
<span>·</span>
|
||||
<span>{node.cpu_cores} cores</span>
|
||||
</div>
|
||||
|
||||
{/* Resource gauges */}
|
||||
<div className="grid grid-cols-3 gap-4 mb-4">
|
||||
<ResourceGauge label="CPU" value={node.cpu_usage} icon={Cpu} />
|
||||
<ResourceGauge label="Memory" value={node.mem_usage} icon={HardDrive} subtitle={node.mem_total} />
|
||||
<ResourceGauge label="Disk" value={node.disk_usage} icon={Layers} subtitle={node.disk_total} />
|
||||
</div>
|
||||
|
||||
{/* Containers */}
|
||||
<div>
|
||||
<div className="flex items-center gap-2 mb-2">
|
||||
<Layers className="w-3 h-3 text-primary" />
|
||||
<span className="text-[10px] font-mono text-muted-foreground">CONTAINERS ({node.containers.length})</span>
|
||||
</div>
|
||||
{node.containers.length > 0 ? (
|
||||
<div className="space-y-1.5">
|
||||
{node.containers.map((c) => (
|
||||
<div key={c.name} className="flex items-center justify-between px-2.5 py-1.5 rounded bg-secondary/30 border border-border/20">
|
||||
<div className="flex items-center gap-2">
|
||||
<div className={`w-1.5 h-1.5 rounded-full ${
|
||||
c.status === "running" ? "bg-neon-green pulse-indicator" :
|
||||
c.status === "idle" ? "bg-primary" :
|
||||
"bg-neon-red"
|
||||
}`} />
|
||||
<span className="text-[11px] font-mono text-foreground">{c.name}</span>
|
||||
</div>
|
||||
<div className="flex items-center gap-3 text-[10px] font-mono text-muted-foreground">
|
||||
<span>CPU: <span className={getResourceColor(c.cpu)}>{c.cpu}%</span></span>
|
||||
<span>MEM: <span className="text-foreground">{c.mem}</span></span>
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
) : (
|
||||
<div className="text-[11px] font-mono text-muted-foreground italic px-2.5 py-2">
|
||||
No containers running
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
</motion.div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
function formatMB(mb: number): string {
|
||||
if (mb >= 1024) return `${(mb / 1024).toFixed(1)} GB`;
|
||||
return `${mb} MB`;
|
||||
}
|
||||
|
||||
function timeAgo(isoStr: string): string {
|
||||
const diff = Date.now() - new Date(isoStr).getTime();
|
||||
const s = Math.floor(diff / 1000);
|
||||
if (s < 60) return `${s}s ago`;
|
||||
const m = Math.floor(s / 60);
|
||||
if (m < 60) return `${m}m ago`;
|
||||
const h = Math.floor(m / 60);
|
||||
if (h < 24) return `${h}h ago`;
|
||||
return `${Math.floor(h / 24)}d ago`;
|
||||
}
|
||||
|
||||
// ─── Sub-components ───────────────────────────────────────────────────────────
|
||||
|
||||
function ResourceGauge({
|
||||
label,
|
||||
value,
|
||||
@@ -257,9 +88,463 @@ function ResourceGauge({
|
||||
<Icon className={`w-3 h-3 ${color}`} />
|
||||
<span className="text-[10px] font-mono text-muted-foreground">{label}</span>
|
||||
</div>
|
||||
<div className={`font-mono text-lg font-bold ${color}`}>{value}%</div>
|
||||
<div className={`font-mono text-lg font-bold ${color}`}>{value.toFixed(0)}%</div>
|
||||
<Progress value={value} className="h-1 mt-1.5" />
|
||||
{subtitle && <div className="text-[10px] font-mono text-muted-foreground mt-1">{subtitle}</div>}
|
||||
{subtitle && (
|
||||
<div className="text-[10px] font-mono text-muted-foreground mt-1">{subtitle}</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
// ─── Main Component ───────────────────────────────────────────────────────────
|
||||
|
||||
export default function Nodes() {
|
||||
const [lastRefresh, setLastRefresh] = useState<Date>(new Date());
|
||||
|
||||
// Poll nodes list every 10 seconds
|
||||
const {
|
||||
data: nodesData,
|
||||
isLoading: nodesLoading,
|
||||
error: nodesError,
|
||||
refetch: refetchNodes,
|
||||
} = trpc.nodes.list.useQuery(undefined, {
|
||||
refetchInterval: 10_000,
|
||||
refetchIntervalInBackground: true,
|
||||
retry: 2,
|
||||
});
|
||||
|
||||
// Poll container stats every 15 seconds
|
||||
const {
|
||||
data: statsData,
|
||||
refetch: refetchStats,
|
||||
} = trpc.nodes.stats.useQuery(undefined, {
|
||||
refetchInterval: 15_000,
|
||||
refetchIntervalInBackground: true,
|
||||
retry: 2,
|
||||
});
|
||||
|
||||
// Track last refresh time
|
||||
useEffect(() => {
|
||||
if (nodesData) setLastRefresh(new Date());
|
||||
}, [nodesData]);
|
||||
|
||||
const handleRefresh = () => {
|
||||
refetchNodes();
|
||||
refetchStats();
|
||||
setLastRefresh(new Date());
|
||||
};
|
||||
|
||||
// Build a map: containerName → stats
|
||||
const statsMap = new Map<string, { cpuPct: number; memUseMB: number; memLimMB: number; memPct: number }>();
|
||||
if (statsData?.stats) {
|
||||
for (const s of statsData.stats) {
|
||||
statsMap.set(s.name, s);
|
||||
statsMap.set(s.id, s);
|
||||
}
|
||||
}
|
||||
|
||||
const nodes = nodesData?.nodes ?? [];
|
||||
const containers: Array<{ id: string; name: string; image: string; state: string; status: string }> =
|
||||
(nodesData as any)?.containers ?? [];
|
||||
const swarmActive = nodesData?.swarmActive ?? false;
|
||||
const isError = !!nodesError || !!(nodesData as any)?.error;
|
||||
const errorMsg = nodesError?.message ?? (nodesData as any)?.error;
|
||||
|
||||
// Summary stats
|
||||
const readyCount = nodes.filter((n) => n.status.toLowerCase() === "ready").length;
|
||||
const drainCount = nodes.filter((n) => n.status.toLowerCase() === "drain").length;
|
||||
const totalCPU = nodes.reduce((acc, n) => acc + n.cpuCores, 0);
|
||||
const totalMemMB = nodes.reduce((acc, n) => acc + n.memTotalMB, 0);
|
||||
|
||||
return (
|
||||
<div className="space-y-6">
|
||||
{/* Header with visualization */}
|
||||
<div className="relative rounded-lg overflow-hidden h-48">
|
||||
<img
|
||||
src={NODE_VIS}
|
||||
alt=""
|
||||
className="absolute inset-0 w-full h-full object-cover opacity-30"
|
||||
/>
|
||||
<div className="absolute inset-0 bg-gradient-to-r from-background via-background/70 to-transparent" />
|
||||
<div className="relative z-10 flex items-center justify-between h-full px-8">
|
||||
<div>
|
||||
<h2 className="text-xl font-bold text-foreground flex items-center gap-2">
|
||||
Swarm Nodes
|
||||
{swarmActive ? (
|
||||
<Badge className="bg-neon-green/15 text-neon-green border-neon-green/30 text-[10px] font-mono">
|
||||
SWARM
|
||||
</Badge>
|
||||
) : (
|
||||
<Badge className="bg-primary/15 text-primary border-primary/30 text-[10px] font-mono">
|
||||
STANDALONE
|
||||
</Badge>
|
||||
)}
|
||||
</h2>
|
||||
<p className="text-sm text-muted-foreground font-mono mt-1">
|
||||
{nodesLoading
|
||||
? "Loading cluster data..."
|
||||
: isError
|
||||
? "Connection error — check Go Gateway"
|
||||
: `${nodes.length} node${nodes.length !== 1 ? "s" : ""} · ${readyCount} ready · ${drainCount} drain`}
|
||||
</p>
|
||||
{!nodesLoading && !isError && (
|
||||
<div className="flex items-center gap-4 mt-3 font-mono text-[11px]">
|
||||
{totalCPU > 0 && (
|
||||
<span className="text-muted-foreground">
|
||||
Total CPU:{" "}
|
||||
<span className="text-primary font-medium">{totalCPU} cores</span>
|
||||
</span>
|
||||
)}
|
||||
{totalMemMB > 0 && (
|
||||
<span className="text-muted-foreground">
|
||||
Total RAM:{" "}
|
||||
<span className="text-primary font-medium">{formatMB(totalMemMB)}</span>
|
||||
</span>
|
||||
)}
|
||||
{containers.length > 0 && (
|
||||
<span className="text-muted-foreground">
|
||||
Containers:{" "}
|
||||
<span className="text-primary font-medium">{containers.length}</span>
|
||||
</span>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{/* Refresh control */}
|
||||
<div className="flex flex-col items-end gap-2">
|
||||
<Button
|
||||
variant="outline"
|
||||
size="sm"
|
||||
onClick={handleRefresh}
|
||||
disabled={nodesLoading}
|
||||
className="font-mono text-xs"
|
||||
>
|
||||
<RefreshCw className={`w-3 h-3 mr-1.5 ${nodesLoading ? "animate-spin" : ""}`} />
|
||||
Refresh
|
||||
</Button>
|
||||
<div className="flex items-center gap-1.5 text-[10px] font-mono text-muted-foreground">
|
||||
{isError ? (
|
||||
<WifiOff className="w-3 h-3 text-neon-red" />
|
||||
) : (
|
||||
<Wifi className="w-3 h-3 text-neon-green" />
|
||||
)}
|
||||
<span>Updated {timeAgo(lastRefresh.toISOString())}</span>
|
||||
</div>
|
||||
<div className="text-[10px] font-mono text-muted-foreground">
|
||||
Auto-refresh: 10s
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Error state */}
|
||||
{isError && (
|
||||
<Card className="border-neon-red/30 bg-neon-red/5">
|
||||
<CardContent className="p-4 flex items-center gap-3">
|
||||
<AlertCircle className="w-5 h-5 text-neon-red flex-shrink-0" />
|
||||
<div>
|
||||
<p className="text-sm font-mono text-neon-red font-semibold">
|
||||
Cannot reach Go Gateway
|
||||
</p>
|
||||
<p className="text-xs font-mono text-muted-foreground mt-0.5">
|
||||
{errorMsg ?? "Make sure the Go Gateway is running on port 18789 with Docker socket mounted."}
|
||||
</p>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
{/* Loading skeleton */}
|
||||
{nodesLoading && nodes.length === 0 && (
|
||||
<div className="grid grid-cols-1 xl:grid-cols-2 gap-5">
|
||||
{[1, 2].map((i) => (
|
||||
<Card key={i} className="bg-card border-border/50">
|
||||
<CardContent className="p-5 space-y-4">
|
||||
<div className="flex items-center gap-3">
|
||||
<div className="w-10 h-10 rounded-lg bg-secondary/50 animate-pulse" />
|
||||
<div className="space-y-2">
|
||||
<div className="h-3 w-32 bg-secondary/50 rounded animate-pulse" />
|
||||
<div className="h-2 w-20 bg-secondary/30 rounded animate-pulse" />
|
||||
</div>
|
||||
</div>
|
||||
<div className="grid grid-cols-3 gap-4">
|
||||
{[1, 2, 3].map((j) => (
|
||||
<div key={j} className="h-16 bg-secondary/30 rounded animate-pulse" />
|
||||
))}
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Node cards */}
|
||||
{nodes.length > 0 && (
|
||||
<div className="grid grid-cols-1 xl:grid-cols-2 gap-5">
|
||||
{nodes.map((node, i) => {
|
||||
// Find containers for this node (standalone mode: all containers)
|
||||
const nodeContainers = swarmActive ? [] : containers;
|
||||
|
||||
// Build per-container stats
|
||||
const enrichedContainers = (nodeContainers as Array<{ id: string; name: string; image: string; state: string; status: string }>).map((c) => {
|
||||
const s = statsMap.get(c.name) ?? statsMap.get(c.id);
|
||||
return { ...c, cpuPct: s?.cpuPct ?? 0, memUseMB: s?.memUseMB ?? 0 };
|
||||
});
|
||||
|
||||
// Aggregate CPU/RAM for this node from container stats
|
||||
const totalCPUPct = enrichedContainers.reduce((a: number, c: { cpuPct: number }) => a + c.cpuPct, 0);
|
||||
const totalMemUseMB = enrichedContainers.reduce((a: number, c: { memUseMB: number }) => a + c.memUseMB, 0);
|
||||
const memPct = node.memTotalMB > 0 ? (totalMemUseMB / node.memTotalMB) * 100 : 0;
|
||||
|
||||
return (
|
||||
<motion.div
|
||||
key={node.id}
|
||||
initial={{ opacity: 0, y: 10 }}
|
||||
animate={{ opacity: 1, y: 0 }}
|
||||
transition={{ delay: i * 0.08 }}
|
||||
>
|
||||
<Card className="bg-card border-border/50 hover:border-primary/30 transition-all">
|
||||
<CardContent className="p-5">
|
||||
{/* Header */}
|
||||
<div className="flex items-center justify-between mb-4">
|
||||
<div className="flex items-center gap-3">
|
||||
<div
|
||||
className={`w-10 h-10 rounded-lg border border-border/50 flex items-center justify-center ${
|
||||
node.role === "manager" || node.role === "Manager"
|
||||
? "bg-primary/15"
|
||||
: "bg-secondary/50"
|
||||
}`}
|
||||
>
|
||||
{node.isLeader ? (
|
||||
<Crown className="w-5 h-5 text-primary" />
|
||||
) : (
|
||||
<Server
|
||||
className={`w-5 h-5 ${
|
||||
node.role === "manager" ? "text-primary" : "text-muted-foreground"
|
||||
}`}
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
<div>
|
||||
<h3 className="text-sm font-mono font-semibold text-foreground">
|
||||
{node.hostname}
|
||||
</h3>
|
||||
<div className="flex items-center gap-2 mt-0.5">
|
||||
<Badge
|
||||
variant="outline"
|
||||
className={`text-[10px] font-mono ${getStatusBadge(node.status)}`}
|
||||
>
|
||||
{node.status.toUpperCase()}
|
||||
</Badge>
|
||||
<span className="text-[10px] font-mono text-muted-foreground capitalize">
|
||||
{node.role}
|
||||
{node.isLeader && (
|
||||
<span className="ml-1 text-primary">(Leader)</span>
|
||||
)}
|
||||
</span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div className="text-right text-[10px] font-mono text-muted-foreground">
|
||||
<div className="flex items-center gap-1 justify-end">
|
||||
<MapPin className="w-3 h-3" />
|
||||
{node.ip || "—"}
|
||||
</div>
|
||||
<div className="flex items-center gap-1 justify-end mt-0.5">
|
||||
<Activity className="w-3 h-3" />
|
||||
{timeAgo(node.updatedAt)}
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* System info */}
|
||||
<div className="flex flex-wrap items-center gap-x-3 gap-y-1 mb-4 text-[10px] font-mono text-muted-foreground">
|
||||
{node.os && <span>{node.os}</span>}
|
||||
{node.arch && (
|
||||
<>
|
||||
<span>·</span>
|
||||
<span>{node.arch}</span>
|
||||
</>
|
||||
)}
|
||||
{node.dockerVersion && node.dockerVersion !== "unknown" && (
|
||||
<>
|
||||
<span>·</span>
|
||||
<span>Docker {node.dockerVersion}</span>
|
||||
</>
|
||||
)}
|
||||
{node.cpuCores > 0 && (
|
||||
<>
|
||||
<span>·</span>
|
||||
<span>{node.cpuCores} cores</span>
|
||||
</>
|
||||
)}
|
||||
{node.memTotalMB > 0 && (
|
||||
<>
|
||||
<span>·</span>
|
||||
<span>{formatMB(node.memTotalMB)}</span>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{/* Resource gauges */}
|
||||
<div className="grid grid-cols-2 gap-4 mb-4">
|
||||
<ResourceGauge
|
||||
label="CPU (containers)"
|
||||
value={Math.min(totalCPUPct, 100)}
|
||||
icon={Cpu}
|
||||
subtitle={
|
||||
enrichedContainers.length > 0
|
||||
? `${enrichedContainers.length} containers`
|
||||
: undefined
|
||||
}
|
||||
/>
|
||||
<ResourceGauge
|
||||
label="Memory"
|
||||
value={Math.min(memPct, 100)}
|
||||
icon={HardDrive}
|
||||
subtitle={
|
||||
node.memTotalMB > 0
|
||||
? `${formatMB(totalMemUseMB)} / ${formatMB(node.memTotalMB)}`
|
||||
: undefined
|
||||
}
|
||||
/>
|
||||
</div>
|
||||
|
||||
{/* Containers list */}
|
||||
{enrichedContainers.length > 0 && (
|
||||
<div>
|
||||
<div className="flex items-center gap-2 mb-2">
|
||||
<Layers className="w-3 h-3 text-primary" />
|
||||
<span className="text-[10px] font-mono text-muted-foreground">
|
||||
CONTAINERS ({enrichedContainers.length})
|
||||
</span>
|
||||
</div>
|
||||
<div className="space-y-1.5">
|
||||
{enrichedContainers.map((c) => (
|
||||
<div
|
||||
key={c.id}
|
||||
className="flex items-center justify-between px-2.5 py-1.5 rounded bg-secondary/30 border border-border/20"
|
||||
>
|
||||
<div className="flex items-center gap-2 min-w-0">
|
||||
<div
|
||||
className={`w-1.5 h-1.5 rounded-full flex-shrink-0 ${
|
||||
c.state === "running"
|
||||
? "bg-neon-green pulse-indicator"
|
||||
: c.state === "paused"
|
||||
? "bg-primary"
|
||||
: "bg-neon-red"
|
||||
}`}
|
||||
/>
|
||||
<span className="text-[11px] font-mono text-foreground truncate">
|
||||
{c.name}
|
||||
</span>
|
||||
</div>
|
||||
<div className="flex items-center gap-3 text-[10px] font-mono text-muted-foreground flex-shrink-0 ml-2">
|
||||
{c.cpuPct > 0 && (
|
||||
<span>
|
||||
CPU:{" "}
|
||||
<span className={getResourceColor(c.cpuPct)}>
|
||||
{c.cpuPct.toFixed(1)}%
|
||||
</span>
|
||||
</span>
|
||||
)}
|
||||
{c.memUseMB > 0 && (
|
||||
<span>
|
||||
MEM:{" "}
|
||||
<span className="text-foreground">{formatMB(c.memUseMB)}</span>
|
||||
</span>
|
||||
)}
|
||||
{c.cpuPct === 0 && c.memUseMB === 0 && (
|
||||
<span className="text-muted-foreground/50">{c.status}</span>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* No containers message */}
|
||||
{enrichedContainers.length === 0 && (
|
||||
<div className="text-[11px] font-mono text-muted-foreground italic px-2.5 py-2">
|
||||
{node.availability === "drain"
|
||||
? "Node is draining — no containers scheduled"
|
||||
: "No running containers"}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Labels */}
|
||||
{Object.keys(node.labels ?? {}).length > 0 && (
|
||||
<div className="mt-3 flex flex-wrap gap-1">
|
||||
{Object.entries(node.labels).map(([k, v]) => (
|
||||
<span
|
||||
key={k}
|
||||
className="text-[9px] font-mono px-1.5 py-0.5 rounded bg-secondary/50 text-muted-foreground border border-border/20"
|
||||
>
|
||||
{k}={v}
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
</CardContent>
|
||||
</Card>
|
||||
</motion.div>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Empty state — no nodes, no error, not loading */}
|
||||
{!nodesLoading && !isError && nodes.length === 0 && (
|
||||
<Card className="border-border/50">
|
||||
<CardContent className="p-8 text-center">
|
||||
<Server className="w-12 h-12 text-muted-foreground/30 mx-auto mb-3" />
|
||||
<p className="text-sm font-mono text-muted-foreground">No nodes found</p>
|
||||
<p className="text-xs font-mono text-muted-foreground/60 mt-1">
|
||||
Make sure Docker socket is mounted in the Gateway container
|
||||
</p>
|
||||
</CardContent>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
{/* Standalone containers section (when not in Swarm mode) */}
|
||||
{!swarmActive && statsData && statsData.stats.length > 0 && nodes.length === 0 && (
|
||||
<div>
|
||||
<h3 className="text-sm font-mono font-semibold text-muted-foreground mb-3">
|
||||
RUNNING CONTAINERS
|
||||
</h3>
|
||||
<div className="space-y-2">
|
||||
{statsData.stats.map((s) => (
|
||||
<div
|
||||
key={s.id}
|
||||
className="flex items-center justify-between px-3 py-2 rounded-md bg-card border border-border/50"
|
||||
>
|
||||
<div className="flex items-center gap-2">
|
||||
<div className="w-1.5 h-1.5 rounded-full bg-neon-green pulse-indicator" />
|
||||
<span className="text-sm font-mono text-foreground">{s.name}</span>
|
||||
<span className="text-[10px] font-mono text-muted-foreground">{s.id}</span>
|
||||
</div>
|
||||
<div className="flex items-center gap-4 text-[11px] font-mono text-muted-foreground">
|
||||
<span>
|
||||
CPU: <span className={getResourceColor(s.cpuPct)}>{s.cpuPct.toFixed(1)}%</span>
|
||||
</span>
|
||||
<span>
|
||||
MEM:{" "}
|
||||
<span className="text-foreground">
|
||||
{formatMB(s.memUseMB)} / {formatMB(s.memLimMB)}
|
||||
</span>
|
||||
<span className="ml-1 text-muted-foreground/60">
|
||||
({s.memPct.toFixed(0)}%)
|
||||
</span>
|
||||
</span>
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -87,6 +87,11 @@ func main() {
|
||||
|
||||
// Tools
|
||||
r.Get("/tools", h.ListTools)
|
||||
r.Post("/tools/execute", h.ExecuteTool)
|
||||
|
||||
// Nodes / Docker Swarm monitoring
|
||||
r.Get("/nodes", h.ListNodes)
|
||||
r.Get("/nodes/stats", h.NodeStats)
|
||||
})
|
||||
|
||||
// ── Start Server ─────────────────────────────────────────────────────────
|
||||
|
||||
@@ -4,6 +4,7 @@ package api
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"strconv"
|
||||
@@ -11,6 +12,7 @@ import (
|
||||
|
||||
"git.softuniq.eu/UniqAI/GoClaw/gateway/config"
|
||||
"git.softuniq.eu/UniqAI/GoClaw/gateway/internal/db"
|
||||
dockerclient "git.softuniq.eu/UniqAI/GoClaw/gateway/internal/docker"
|
||||
"git.softuniq.eu/UniqAI/GoClaw/gateway/internal/llm"
|
||||
"git.softuniq.eu/UniqAI/GoClaw/gateway/internal/orchestrator"
|
||||
"git.softuniq.eu/UniqAI/GoClaw/gateway/internal/tools"
|
||||
@@ -18,18 +20,20 @@ import (
|
||||
|
||||
// Handler holds all dependencies for HTTP handlers.
|
||||
type Handler struct {
|
||||
cfg *config.Config
|
||||
llm *llm.Client
|
||||
orch *orchestrator.Orchestrator
|
||||
db *db.DB
|
||||
cfg *config.Config
|
||||
llm *llm.Client
|
||||
orch *orchestrator.Orchestrator
|
||||
db *db.DB
|
||||
docker *dockerclient.DockerClient
|
||||
}
|
||||
|
||||
func NewHandler(cfg *config.Config, llmClient *llm.Client, orch *orchestrator.Orchestrator, database *db.DB) *Handler {
|
||||
return &Handler{
|
||||
cfg: cfg,
|
||||
llm: llmClient,
|
||||
orch: orch,
|
||||
db: database,
|
||||
cfg: cfg,
|
||||
llm: llmClient,
|
||||
orch: orch,
|
||||
db: database,
|
||||
docker: dockerclient.NewDockerClient(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -57,7 +61,6 @@ func (h *Handler) Health(w http.ResponseWriter, r *http.Request) {
|
||||
// ─── Orchestrator ─────────────────────────────────────────────────────────────
|
||||
|
||||
// POST /api/orchestrator/chat
|
||||
// Body: { "messages": [{"role":"user","content":"..."}], "model": "optional-override" }
|
||||
func (h *Handler) OrchestratorChat(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Messages []orchestrator.Message `json:"messages"`
|
||||
@@ -86,13 +89,12 @@ func (h *Handler) OrchestratorChat(w http.ResponseWriter, r *http.Request) {
|
||||
func (h *Handler) OrchestratorConfig(w http.ResponseWriter, r *http.Request) {
|
||||
cfg := h.orch.GetConfig()
|
||||
respond(w, http.StatusOK, map[string]any{
|
||||
"id": cfg.ID,
|
||||
"name": cfg.Name,
|
||||
"model": cfg.Model,
|
||||
"temperature": cfg.Temperature,
|
||||
"maxTokens": cfg.MaxTokens,
|
||||
"allowedTools": cfg.AllowedTools,
|
||||
// Don't expose full system prompt for security
|
||||
"id": cfg.ID,
|
||||
"name": cfg.Name,
|
||||
"model": cfg.Model,
|
||||
"temperature": cfg.Temperature,
|
||||
"maxTokens": cfg.MaxTokens,
|
||||
"allowedTools": cfg.AllowedTools,
|
||||
"systemPromptPreview": truncate(cfg.SystemPrompt, 200),
|
||||
})
|
||||
}
|
||||
@@ -159,10 +161,229 @@ func (h *Handler) ListTools(w http.ResponseWriter, r *http.Request) {
|
||||
})
|
||||
}
|
||||
|
||||
// POST /api/tools/execute
|
||||
func (h *Handler) ExecuteTool(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Name string `json:"name"`
|
||||
Arguments map[string]any `json:"arguments"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
respondError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
|
||||
return
|
||||
}
|
||||
if req.Name == "" {
|
||||
respondError(w, http.StatusBadRequest, "tool name is required")
|
||||
return
|
||||
}
|
||||
|
||||
argsJSON, _ := json.Marshal(req.Arguments)
|
||||
executor := tools.NewExecutor("/", nil)
|
||||
result := executor.Execute(r.Context(), req.Name, string(argsJSON))
|
||||
respond(w, http.StatusOK, map[string]any{"result": result})
|
||||
}
|
||||
|
||||
// ─── Nodes ────────────────────────────────────────────────────────────────────
|
||||
|
||||
// NodeInfo is the unified node response sent to the frontend.
|
||||
type NodeInfo struct {
|
||||
ID string `json:"id"`
|
||||
Hostname string `json:"hostname"`
|
||||
Role string `json:"role"`
|
||||
Status string `json:"status"`
|
||||
Availability string `json:"availability"`
|
||||
IP string `json:"ip"`
|
||||
OS string `json:"os"`
|
||||
Arch string `json:"arch"`
|
||||
CPUCores int `json:"cpuCores"`
|
||||
MemTotalMB int64 `json:"memTotalMB"`
|
||||
DockerVersion string `json:"dockerVersion"`
|
||||
IsLeader bool `json:"isLeader"`
|
||||
ManagerAddr string `json:"managerAddr,omitempty"`
|
||||
Labels map[string]string `json:"labels"`
|
||||
UpdatedAt string `json:"updatedAt"`
|
||||
}
|
||||
|
||||
// ContainerInfo is a slim container summary per node.
|
||||
type ContainerInfo struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Image string `json:"image"`
|
||||
State string `json:"state"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// GET /api/nodes
|
||||
func (h *Handler) ListNodes(w http.ResponseWriter, r *http.Request) {
|
||||
// Check if Swarm is active
|
||||
swarmActive := h.docker.IsSwarmActive()
|
||||
|
||||
if swarmActive {
|
||||
// Return real Swarm nodes
|
||||
nodes, err := h.docker.ListNodes()
|
||||
if err != nil {
|
||||
log.Printf("[API] ListNodes swarm error: %v — falling back to local info", err)
|
||||
h.listLocalNode(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
result := make([]NodeInfo, 0, len(nodes))
|
||||
for _, n := range nodes {
|
||||
info := NodeInfo{
|
||||
ID: n.ID[:12],
|
||||
Hostname: n.Description.Hostname,
|
||||
Role: n.Spec.Role,
|
||||
Status: n.Status.State,
|
||||
Availability: n.Spec.Availability,
|
||||
IP: n.Status.Addr,
|
||||
OS: n.Description.Platform.OS,
|
||||
Arch: n.Description.Platform.Architecture,
|
||||
CPUCores: int(n.Description.Resources.NanoCPUs / 1e9),
|
||||
MemTotalMB: n.Description.Resources.MemoryBytes / (1024 * 1024),
|
||||
DockerVersion: n.Description.Engine.EngineVersion,
|
||||
Labels: n.Spec.Labels,
|
||||
UpdatedAt: n.UpdatedAt.UTC().Format(time.RFC3339),
|
||||
}
|
||||
if n.ManagerStatus != nil {
|
||||
info.IsLeader = n.ManagerStatus.Leader
|
||||
info.ManagerAddr = n.ManagerStatus.Addr
|
||||
}
|
||||
if info.Labels == nil {
|
||||
info.Labels = map[string]string{}
|
||||
}
|
||||
result = append(result, info)
|
||||
}
|
||||
|
||||
swarmInfo, _ := h.docker.GetSwarmInfo()
|
||||
managers, totalNodes := 0, len(result)
|
||||
if swarmInfo != nil {
|
||||
managers = swarmInfo.Swarm.Managers
|
||||
totalNodes = swarmInfo.Swarm.Nodes
|
||||
}
|
||||
|
||||
respond(w, http.StatusOK, map[string]any{
|
||||
"nodes": result,
|
||||
"count": len(result),
|
||||
"swarmActive": true,
|
||||
"managers": managers,
|
||||
"totalNodes": totalNodes,
|
||||
"fetchedAt": time.Now().UTC().Format(time.RFC3339),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// Swarm not active — return local Docker host info
|
||||
h.listLocalNode(w, r)
|
||||
}
|
||||
|
||||
// listLocalNode returns info about the current Docker host as a single "node".
|
||||
func (h *Handler) listLocalNode(w http.ResponseWriter, r *http.Request) {
|
||||
info, err := h.docker.GetSwarmInfo()
|
||||
hostname := "localhost"
|
||||
if err == nil && info != nil {
|
||||
_ = info // use for future enrichment
|
||||
}
|
||||
|
||||
// Get containers running on this host
|
||||
containers, _ := h.docker.ListContainers()
|
||||
containerInfos := make([]ContainerInfo, 0, len(containers))
|
||||
for _, c := range containers {
|
||||
name := c.ID[:12]
|
||||
if len(c.Names) > 0 {
|
||||
name = c.Names[0]
|
||||
if len(name) > 0 && name[0] == '/' {
|
||||
name = name[1:]
|
||||
}
|
||||
}
|
||||
containerInfos = append(containerInfos, ContainerInfo{
|
||||
ID: c.ID[:12],
|
||||
Name: name,
|
||||
Image: c.Image,
|
||||
State: c.State,
|
||||
Status: c.Status,
|
||||
})
|
||||
}
|
||||
|
||||
node := NodeInfo{
|
||||
ID: "local-01",
|
||||
Hostname: hostname,
|
||||
Role: "standalone",
|
||||
Status: "ready",
|
||||
Availability: "active",
|
||||
IP: "127.0.0.1",
|
||||
DockerVersion: "unknown",
|
||||
Labels: map[string]string{},
|
||||
UpdatedAt: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
|
||||
respond(w, http.StatusOK, map[string]any{
|
||||
"nodes": []NodeInfo{node},
|
||||
"count": 1,
|
||||
"swarmActive": false,
|
||||
"containers": containerInfos,
|
||||
"fetchedAt": time.Now().UTC().Format(time.RFC3339),
|
||||
})
|
||||
}
|
||||
|
||||
// GET /api/nodes/stats
|
||||
// Returns live container stats (CPU%, RAM) for containers on this host.
|
||||
func (h *Handler) NodeStats(w http.ResponseWriter, r *http.Request) {
|
||||
containers, err := h.docker.ListContainers()
|
||||
if err != nil {
|
||||
respondError(w, http.StatusInternalServerError, "failed to list containers: "+err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
type ContainerStat struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
CPUPct float64 `json:"cpuPct"`
|
||||
MemUseMB float64 `json:"memUseMB"`
|
||||
MemLimMB float64 `json:"memLimMB"`
|
||||
MemPct float64 `json:"memPct"`
|
||||
}
|
||||
|
||||
stats := make([]ContainerStat, 0, len(containers))
|
||||
for _, c := range containers {
|
||||
s, err := h.docker.GetContainerStats(c.ID)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
name := c.ID[:12]
|
||||
if len(c.Names) > 0 {
|
||||
name = c.Names[0]
|
||||
if len(name) > 0 && name[0] == '/' {
|
||||
name = name[1:]
|
||||
}
|
||||
}
|
||||
cpuPct := dockerclient.CalcCPUPercent(s)
|
||||
memUse := float64(s.MemoryStats.Usage) / (1024 * 1024)
|
||||
memLim := float64(s.MemoryStats.Limit) / (1024 * 1024)
|
||||
memPct := 0.0
|
||||
if memLim > 0 {
|
||||
memPct = (memUse / memLim) * 100
|
||||
}
|
||||
stats = append(stats, ContainerStat{
|
||||
ID: c.ID[:12],
|
||||
Name: name,
|
||||
CPUPct: round2(cpuPct),
|
||||
MemUseMB: round2(memUse),
|
||||
MemLimMB: round2(memLim),
|
||||
MemPct: round2(memPct),
|
||||
})
|
||||
}
|
||||
|
||||
respond(w, http.StatusOK, map[string]any{
|
||||
"stats": stats,
|
||||
"count": len(stats),
|
||||
"fetchedAt": time.Now().UTC().Format(time.RFC3339),
|
||||
})
|
||||
}
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
func respond(w http.ResponseWriter, status int, data any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(data)
|
||||
}
|
||||
@@ -177,3 +398,11 @@ func truncate(s string, n int) string {
|
||||
}
|
||||
return s[:n] + "..."
|
||||
}
|
||||
|
||||
func round2(f float64) float64 {
|
||||
return float64(int(f*100)) / 100
|
||||
}
|
||||
|
||||
func init() {
|
||||
_ = fmt.Sprintf // suppress unused import
|
||||
}
|
||||
|
||||
200
gateway/internal/docker/client.go
Normal file
200
gateway/internal/docker/client.go
Normal file
@@ -0,0 +1,200 @@
|
||||
package docker
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// DockerClient communicates with the Docker daemon via Unix socket or TCP.
|
||||
type DockerClient struct {
|
||||
httpClient *http.Client
|
||||
baseURL string
|
||||
}
|
||||
|
||||
// NewDockerClient creates a client that talks to /var/run/docker.sock.
|
||||
func NewDockerClient() *DockerClient {
|
||||
transport := &http.Transport{
|
||||
DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
|
||||
return (&net.Dialer{Timeout: 5 * time.Second}).DialContext(ctx, "unix", "/var/run/docker.sock")
|
||||
},
|
||||
}
|
||||
return &DockerClient{
|
||||
httpClient: &http.Client{Transport: transport, Timeout: 10 * time.Second},
|
||||
baseURL: "http://localhost", // host is ignored for unix socket
|
||||
}
|
||||
}
|
||||
|
||||
func (c *DockerClient) get(path string, out interface{}) error {
|
||||
resp, err := c.httpClient.Get(c.baseURL + path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("docker GET %s: %w", path, err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
if resp.StatusCode >= 400 {
|
||||
return fmt.Errorf("docker GET %s: status %d: %s", path, resp.StatusCode, string(body))
|
||||
}
|
||||
return json.Unmarshal(body, out)
|
||||
}
|
||||
|
||||
// ---- Types ----------------------------------------------------------------
|
||||
|
||||
type SwarmNode struct {
|
||||
ID string `json:"ID"`
|
||||
Description NodeDescription `json:"Description"`
|
||||
Status NodeStatus `json:"Status"`
|
||||
ManagerStatus *ManagerStatus `json:"ManagerStatus,omitempty"`
|
||||
Spec NodeSpec `json:"Spec"`
|
||||
UpdatedAt time.Time `json:"UpdatedAt"`
|
||||
CreatedAt time.Time `json:"CreatedAt"`
|
||||
}
|
||||
|
||||
type NodeDescription struct {
|
||||
Hostname string `json:"Hostname"`
|
||||
Platform Platform `json:"Platform"`
|
||||
Resources Resources `json:"Resources"`
|
||||
Engine Engine `json:"Engine"`
|
||||
}
|
||||
|
||||
type Platform struct {
|
||||
Architecture string `json:"Architecture"`
|
||||
OS string `json:"OS"`
|
||||
}
|
||||
|
||||
type Resources struct {
|
||||
NanoCPUs int64 `json:"NanoCPUs"`
|
||||
MemoryBytes int64 `json:"MemoryBytes"`
|
||||
}
|
||||
|
||||
type Engine struct {
|
||||
EngineVersion string `json:"EngineVersion"`
|
||||
}
|
||||
|
||||
type NodeStatus struct {
|
||||
State string `json:"State"`
|
||||
Addr string `json:"Addr"`
|
||||
Message string `json:"Message"`
|
||||
}
|
||||
|
||||
type ManagerStatus struct {
|
||||
Addr string `json:"Addr"`
|
||||
Leader bool `json:"Leader"`
|
||||
Reachability string `json:"Reachability"`
|
||||
}
|
||||
|
||||
type NodeSpec struct {
|
||||
Role string `json:"Role"`
|
||||
Availability string `json:"Availability"`
|
||||
Labels map[string]string `json:"Labels"`
|
||||
}
|
||||
|
||||
type Container struct {
|
||||
ID string `json:"Id"`
|
||||
Names []string `json:"Names"`
|
||||
Image string `json:"Image"`
|
||||
State string `json:"State"`
|
||||
Status string `json:"Status"`
|
||||
Labels map[string]string `json:"Labels"`
|
||||
}
|
||||
|
||||
type ContainerStats struct {
|
||||
CPUStats CPUStats `json:"cpu_stats"`
|
||||
PreCPUStats CPUStats `json:"precpu_stats"`
|
||||
MemoryStats MemoryStats `json:"memory_stats"`
|
||||
}
|
||||
|
||||
type CPUStats struct {
|
||||
CPUUsage CPUUsage `json:"cpu_usage"`
|
||||
SystemCPUUsage int64 `json:"system_cpu_usage"`
|
||||
OnlineCPUs int `json:"online_cpus"`
|
||||
}
|
||||
|
||||
type CPUUsage struct {
|
||||
TotalUsage int64 `json:"total_usage"`
|
||||
PercpuUsage []int64 `json:"percpu_usage"`
|
||||
}
|
||||
|
||||
type MemoryStats struct {
|
||||
Usage int64 `json:"usage"`
|
||||
MaxUsage int64 `json:"max_usage"`
|
||||
Limit int64 `json:"limit"`
|
||||
Stats map[string]int64 `json:"stats"`
|
||||
}
|
||||
|
||||
type DockerInfo struct {
|
||||
Swarm SwarmInfo `json:"Swarm"`
|
||||
}
|
||||
|
||||
type SwarmInfo struct {
|
||||
NodeID string `json:"NodeID"`
|
||||
LocalNodeState string `json:"LocalNodeState"`
|
||||
ControlAvailable bool `json:"ControlAvailable"`
|
||||
Managers int `json:"Managers"`
|
||||
Nodes int `json:"Nodes"`
|
||||
}
|
||||
|
||||
// ---- Methods ---------------------------------------------------------------
|
||||
|
||||
// IsSwarmActive checks if Docker Swarm is initialized.
|
||||
func (c *DockerClient) IsSwarmActive() bool {
|
||||
var info DockerInfo
|
||||
if err := c.get("/v1.41/info", &info); err != nil {
|
||||
return false
|
||||
}
|
||||
return info.Swarm.LocalNodeState == "active"
|
||||
}
|
||||
|
||||
// GetSwarmInfo returns basic swarm info.
|
||||
func (c *DockerClient) GetSwarmInfo() (*DockerInfo, error) {
|
||||
var info DockerInfo
|
||||
if err := c.get("/v1.41/info", &info); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &info, nil
|
||||
}
|
||||
|
||||
// ListNodes returns all Swarm nodes (requires manager node).
|
||||
func (c *DockerClient) ListNodes() ([]SwarmNode, error) {
|
||||
var nodes []SwarmNode
|
||||
if err := c.get("/v1.41/nodes", &nodes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return nodes, nil
|
||||
}
|
||||
|
||||
// ListContainers returns all running containers on this host.
|
||||
func (c *DockerClient) ListContainers() ([]Container, error) {
|
||||
var containers []Container
|
||||
if err := c.get("/v1.41/containers/json?all=false", &containers); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return containers, nil
|
||||
}
|
||||
|
||||
// GetContainerStats returns one-shot stats for a container (no streaming).
|
||||
func (c *DockerClient) GetContainerStats(containerID string) (*ContainerStats, error) {
|
||||
var stats ContainerStats
|
||||
if err := c.get(fmt.Sprintf("/v1.41/containers/%s/stats?stream=false", containerID), &stats); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &stats, nil
|
||||
}
|
||||
|
||||
// CalcCPUPercent computes CPU usage % from two consecutive stats snapshots.
|
||||
func CalcCPUPercent(stats *ContainerStats) float64 {
|
||||
cpuDelta := float64(stats.CPUStats.CPUUsage.TotalUsage) - float64(stats.PreCPUStats.CPUUsage.TotalUsage)
|
||||
systemDelta := float64(stats.CPUStats.SystemCPUUsage) - float64(stats.PreCPUStats.SystemCPUUsage)
|
||||
numCPU := float64(stats.CPUStats.OnlineCPUs)
|
||||
if numCPU == 0 {
|
||||
numCPU = float64(len(stats.CPUStats.CPUUsage.PercpuUsage))
|
||||
}
|
||||
if systemDelta > 0 && cpuDelta > 0 {
|
||||
return (cpuDelta / systemDelta) * numCPU * 100.0
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -286,3 +286,86 @@ export async function executeGatewayTool(
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Nodes / Docker Swarm ─────────────────────────────────────────────────────
|
||||
|
||||
export interface GatewayNodeInfo {
|
||||
id: string;
|
||||
hostname: string;
|
||||
role: string;
|
||||
status: string;
|
||||
availability: string;
|
||||
ip: string;
|
||||
os: string;
|
||||
arch: string;
|
||||
cpuCores: number;
|
||||
memTotalMB: number;
|
||||
dockerVersion: string;
|
||||
isLeader: boolean;
|
||||
managerAddr?: string;
|
||||
labels: Record<string, string>;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface GatewayContainerInfo {
|
||||
id: string;
|
||||
name: string;
|
||||
image: string;
|
||||
state: string;
|
||||
status: string;
|
||||
}
|
||||
|
||||
export interface GatewayNodesResult {
|
||||
nodes: GatewayNodeInfo[];
|
||||
count: number;
|
||||
swarmActive: boolean;
|
||||
managers?: number;
|
||||
totalNodes?: number;
|
||||
containers?: GatewayContainerInfo[];
|
||||
fetchedAt: string;
|
||||
}
|
||||
|
||||
export interface GatewayContainerStat {
|
||||
id: string;
|
||||
name: string;
|
||||
cpuPct: number;
|
||||
memUseMB: number;
|
||||
memLimMB: number;
|
||||
memPct: number;
|
||||
}
|
||||
|
||||
export interface GatewayNodeStatsResult {
|
||||
stats: GatewayContainerStat[];
|
||||
count: number;
|
||||
fetchedAt: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Docker Swarm nodes (or standalone Docker host) from Go Gateway.
|
||||
*/
|
||||
export async function getGatewayNodes(): Promise<GatewayNodesResult | null> {
|
||||
try {
|
||||
const res = await fetch(`${GATEWAY_BASE_URL}/api/nodes`, {
|
||||
signal: AbortSignal.timeout(10_000),
|
||||
});
|
||||
if (!res.ok) return null;
|
||||
return res.json();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get live container CPU/RAM stats from Go Gateway.
|
||||
*/
|
||||
export async function getGatewayNodeStats(): Promise<GatewayNodeStatsResult | null> {
|
||||
try {
|
||||
const res = await fetch(`${GATEWAY_BASE_URL}/api/nodes/stats`, {
|
||||
signal: AbortSignal.timeout(15_000),
|
||||
});
|
||||
if (!res.ok) return null;
|
||||
return res.json();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
265
server/nodes.test.ts
Normal file
265
server/nodes.test.ts
Normal file
@@ -0,0 +1,265 @@
|
||||
/**
|
||||
* Tests for nodes tRPC procedures (Docker Swarm monitoring).
|
||||
* These tests mock the Go Gateway HTTP calls so they run without a real Gateway.
|
||||
*/
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
||||
import {
|
||||
getGatewayNodes,
|
||||
getGatewayNodeStats,
|
||||
type GatewayNodesResult,
|
||||
type GatewayNodeStatsResult,
|
||||
} from "./gateway-proxy";
|
||||
|
||||
// ─── Mock fetch ───────────────────────────────────────────────────────────────
|
||||
|
||||
const mockFetch = vi.fn();
|
||||
vi.stubGlobal("fetch", mockFetch);
|
||||
|
||||
function mockResponse(data: unknown, status = 200) {
|
||||
return {
|
||||
ok: status >= 200 && status < 300,
|
||||
status,
|
||||
json: async () => data,
|
||||
text: async () => JSON.stringify(data),
|
||||
};
|
||||
}
|
||||
|
||||
// ─── Test data ────────────────────────────────────────────────────────────────
|
||||
|
||||
const MOCK_NODES_RESULT: GatewayNodesResult = {
|
||||
nodes: [
|
||||
{
|
||||
id: "abc123def456",
|
||||
hostname: "goclaw-manager-01",
|
||||
role: "manager",
|
||||
status: "ready",
|
||||
availability: "active",
|
||||
ip: "192.168.1.10",
|
||||
os: "linux",
|
||||
arch: "x86_64",
|
||||
cpuCores: 4,
|
||||
memTotalMB: 8192,
|
||||
dockerVersion: "24.0.7",
|
||||
isLeader: true,
|
||||
managerAddr: "192.168.1.10:2377",
|
||||
labels: { env: "production" },
|
||||
updatedAt: "2026-03-21T10:00:00Z",
|
||||
},
|
||||
{
|
||||
id: "def789abc012",
|
||||
hostname: "goclaw-worker-01",
|
||||
role: "worker",
|
||||
status: "ready",
|
||||
availability: "active",
|
||||
ip: "192.168.1.11",
|
||||
os: "linux",
|
||||
arch: "x86_64",
|
||||
cpuCores: 8,
|
||||
memTotalMB: 16384,
|
||||
dockerVersion: "24.0.7",
|
||||
isLeader: false,
|
||||
labels: {},
|
||||
updatedAt: "2026-03-21T10:00:00Z",
|
||||
},
|
||||
],
|
||||
count: 2,
|
||||
swarmActive: true,
|
||||
managers: 1,
|
||||
totalNodes: 2,
|
||||
fetchedAt: "2026-03-21T10:00:00Z",
|
||||
};
|
||||
|
||||
const MOCK_STATS_RESULT: GatewayNodeStatsResult = {
|
||||
stats: [
|
||||
{
|
||||
id: "abc123",
|
||||
name: "goclaw-gateway",
|
||||
cpuPct: 12.5,
|
||||
memUseMB: 256.0,
|
||||
memLimMB: 2048.0,
|
||||
memPct: 12.5,
|
||||
},
|
||||
{
|
||||
id: "def456",
|
||||
name: "goclaw-control-center",
|
||||
cpuPct: 5.2,
|
||||
memUseMB: 128.0,
|
||||
memLimMB: 1024.0,
|
||||
memPct: 12.5,
|
||||
},
|
||||
],
|
||||
count: 2,
|
||||
fetchedAt: "2026-03-21T10:00:00Z",
|
||||
};
|
||||
|
||||
// ─── Tests ────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("getGatewayNodes", () => {
|
||||
beforeEach(() => {
|
||||
mockFetch.mockReset();
|
||||
});
|
||||
|
||||
it("returns nodes list when gateway is available", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
|
||||
const result = await getGatewayNodes();
|
||||
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.nodes).toHaveLength(2);
|
||||
expect(result!.swarmActive).toBe(true);
|
||||
expect(result!.count).toBe(2);
|
||||
});
|
||||
|
||||
it("returns manager node with isLeader=true", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
|
||||
const result = await getGatewayNodes();
|
||||
const manager = result!.nodes.find((n) => n.role === "manager");
|
||||
|
||||
expect(manager).toBeDefined();
|
||||
expect(manager!.isLeader).toBe(true);
|
||||
expect(manager!.hostname).toBe("goclaw-manager-01");
|
||||
expect(manager!.managerAddr).toBe("192.168.1.10:2377");
|
||||
});
|
||||
|
||||
it("returns worker node with correct resources", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
|
||||
const result = await getGatewayNodes();
|
||||
const worker = result!.nodes.find((n) => n.role === "worker");
|
||||
|
||||
expect(worker).toBeDefined();
|
||||
expect(worker!.cpuCores).toBe(8);
|
||||
expect(worker!.memTotalMB).toBe(16384);
|
||||
expect(worker!.isLeader).toBe(false);
|
||||
});
|
||||
|
||||
it("returns null when gateway is unreachable", async () => {
|
||||
mockFetch.mockRejectedValueOnce(new Error("ECONNREFUSED"));
|
||||
|
||||
const result = await getGatewayNodes();
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null on HTTP error status", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse({ error: "internal error" }, 500));
|
||||
|
||||
const result = await getGatewayNodes();
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("calls correct gateway endpoint", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
|
||||
await getGatewayNodes();
|
||||
|
||||
expect(mockFetch).toHaveBeenCalledWith(
|
||||
expect.stringContaining("/api/nodes"),
|
||||
expect.any(Object)
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getGatewayNodeStats", () => {
|
||||
beforeEach(() => {
|
||||
mockFetch.mockReset();
|
||||
});
|
||||
|
||||
it("returns container stats when gateway is available", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_STATS_RESULT));
|
||||
|
||||
const result = await getGatewayNodeStats();
|
||||
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.stats).toHaveLength(2);
|
||||
expect(result!.count).toBe(2);
|
||||
});
|
||||
|
||||
it("returns correct CPU and memory stats", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_STATS_RESULT));
|
||||
|
||||
const result = await getGatewayNodeStats();
|
||||
const gateway = result!.stats.find((s) => s.name === "goclaw-gateway");
|
||||
|
||||
expect(gateway).toBeDefined();
|
||||
expect(gateway!.cpuPct).toBe(12.5);
|
||||
expect(gateway!.memUseMB).toBe(256.0);
|
||||
expect(gateway!.memLimMB).toBe(2048.0);
|
||||
expect(gateway!.memPct).toBe(12.5);
|
||||
});
|
||||
|
||||
it("returns null when gateway is unreachable", async () => {
|
||||
mockFetch.mockRejectedValueOnce(new Error("ECONNREFUSED"));
|
||||
|
||||
const result = await getGatewayNodeStats();
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null on HTTP error status", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse({ error: "not found" }, 404));
|
||||
|
||||
const result = await getGatewayNodeStats();
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("calls correct gateway endpoint", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_STATS_RESULT));
|
||||
|
||||
await getGatewayNodeStats();
|
||||
|
||||
expect(mockFetch).toHaveBeenCalledWith(
|
||||
expect.stringContaining("/api/nodes/stats"),
|
||||
expect.any(Object)
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("nodes data validation", () => {
|
||||
it("standalone mode returns swarmActive=false", async () => {
|
||||
const standaloneResult: GatewayNodesResult = {
|
||||
nodes: [
|
||||
{
|
||||
id: "local-01",
|
||||
hostname: "localhost",
|
||||
role: "standalone",
|
||||
status: "ready",
|
||||
availability: "active",
|
||||
ip: "127.0.0.1",
|
||||
os: "",
|
||||
arch: "",
|
||||
cpuCores: 0,
|
||||
memTotalMB: 0,
|
||||
dockerVersion: "unknown",
|
||||
isLeader: false,
|
||||
labels: {},
|
||||
updatedAt: new Date().toISOString(),
|
||||
},
|
||||
],
|
||||
count: 1,
|
||||
swarmActive: false,
|
||||
fetchedAt: new Date().toISOString(),
|
||||
};
|
||||
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(standaloneResult));
|
||||
const result = await getGatewayNodes();
|
||||
|
||||
expect(result!.swarmActive).toBe(false);
|
||||
expect(result!.nodes[0].role).toBe("standalone");
|
||||
});
|
||||
|
||||
it("node labels are preserved correctly", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
const result = await getGatewayNodes();
|
||||
const manager = result!.nodes[0];
|
||||
|
||||
expect(manager.labels).toEqual({ env: "production" });
|
||||
});
|
||||
|
||||
it("worker node has empty labels object", async () => {
|
||||
mockFetch.mockResolvedValueOnce(mockResponse(MOCK_NODES_RESULT));
|
||||
const result = await getGatewayNodes();
|
||||
const worker = result!.nodes[1];
|
||||
|
||||
expect(worker.labels).toEqual({});
|
||||
});
|
||||
});
|
||||
@@ -12,6 +12,8 @@ import {
|
||||
getGatewayTools,
|
||||
executeGatewayTool,
|
||||
isGatewayAvailable,
|
||||
getGatewayNodes,
|
||||
getGatewayNodeStats,
|
||||
} from "./gateway-proxy";
|
||||
|
||||
// Shared system user id for non-authenticated agent management
|
||||
@@ -585,5 +587,44 @@ export const appRouter = router({
|
||||
return executeGatewayTool(input.tool, input.args);
|
||||
}),
|
||||
}),
|
||||
|
||||
/**
|
||||
* Nodes — Docker Swarm / standalone Docker monitoring via Go Gateway
|
||||
*/
|
||||
nodes: router({
|
||||
/**
|
||||
* List all Swarm nodes (or standalone Docker host if Swarm not active).
|
||||
* Returns node info: hostname, role, status, resources, labels, etc.
|
||||
*/
|
||||
list: publicProcedure.query(async () => {
|
||||
const result = await getGatewayNodes();
|
||||
if (!result) {
|
||||
return {
|
||||
nodes: [] as import("./gateway-proxy").GatewayNodeInfo[],
|
||||
count: 0,
|
||||
swarmActive: false,
|
||||
fetchedAt: new Date().toISOString(),
|
||||
error: "Gateway unavailable — is the Go Gateway running?",
|
||||
};
|
||||
}
|
||||
return result;
|
||||
}),
|
||||
|
||||
/**
|
||||
* Get live container stats (CPU%, RAM) for all running containers.
|
||||
*/
|
||||
stats: publicProcedure.query(async () => {
|
||||
const result = await getGatewayNodeStats();
|
||||
if (!result) {
|
||||
return {
|
||||
stats: [] as import("./gateway-proxy").GatewayContainerStat[],
|
||||
count: 0,
|
||||
fetchedAt: new Date().toISOString(),
|
||||
error: "Gateway unavailable",
|
||||
};
|
||||
}
|
||||
return result;
|
||||
}),
|
||||
}),
|
||||
});
|
||||
export type AppRouter = typeof appRouter;
|
||||
|
||||
9
todo.md
9
todo.md
@@ -165,3 +165,12 @@
|
||||
- [x] server/gateway-proxy.test.ts: 13 vitest tests (health, config, tools, mapping)
|
||||
- [x] End-to-end test: orchestrator.chat via tRPC → Go Gateway → Ollama (source: "gateway")
|
||||
- [x] End-to-end test: tool calling — file_list tool executed by Go Gateway
|
||||
|
||||
## Phase 12: Real-time Nodes Page
|
||||
- [ ] Add Docker API client in Go Gateway: /api/nodes endpoint with real node data
|
||||
- [ ] Add /api/nodes/stats endpoint for CPU/memory per node
|
||||
- [ ] Add tRPC nodes.list and nodes.stats procedures via gateway-proxy
|
||||
- [ ] Update Nodes.tsx: real data from tRPC + auto-refresh every 5 seconds
|
||||
- [ ] Show: node ID, hostname, status, role (manager/worker), availability, CPU, RAM, Docker version, IP
|
||||
- [ ] Show live indicator (green pulse) when data is fresh
|
||||
- [ ] Deploy to server 2.59.219.61
|
||||
|
||||
Reference in New Issue
Block a user