blokctl 0.2.0

package/dist/commands/monitor/monitor-component.js

@@ -0,0 +1,271 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import chalk from "chalk";
+import { Box, Text, render, useInput } from "ink";
+import { useEffect, useState } from "react";
+const PROM_URL = "http://localhost:9090/api/v1/query";
+const fmt = (val, decimals = 1) => {
+    let valNew = (val ?? 0).toFixed(decimals);
+    if (valNew.toString() === "NaN") {
+        valNew = "0";
+    }
+    return valNew;
+};
+const queryPrometheus = async (query, host, token) => {
+    const REMOTE_PROM_URL = host ? `${host}/api/v1/query` : undefined;
+    try {
+        const res = token
+            ? await fetch(`${REMOTE_PROM_URL || PROM_URL}?query=${encodeURIComponent(query)}`, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    Accept: "application/json",
+                    "Accept-Encoding": "identity",
+                },
+            })
+            : await fetch(`${REMOTE_PROM_URL || PROM_URL}?query=${encodeURIComponent(query)}`);
+        if (!res.ok) {
+            return [];
+        }
+        const data = await res.json();
+        return data.data.result || [];
+    }
+    catch {
+        return [];
+    }
+};
+const fetchSystemMetrics = async (host, token) => {
+    const [uptimeRaw, totalReqs, totalErrs, avgResp, memUsage, cpuUsage] = await Promise.all([
+        queryPrometheus("process_uptime_seconds", host, token),
+        queryPrometheus("sum(increase(workflow_total[5m]))", host, token),
+        queryPrometheus("sum(increase(workflow_errors_total[5m]))", host, token),
+        queryPrometheus("avg(increase(workflow_time[5m]))", host, token),
+        queryPrometheus("process_resident_memory_bytes / 1024 / 1024", host, token),
+        queryPrometheus("rate(process_cpu_seconds_total[1m]) * 100", host, token),
+    ]);
+    const totalRequests = +(totalReqs[0]?.value?.[1] ?? "0");
+    const totalErrors = +(totalErrs[0]?.value?.[1] ?? "0");
+    return {
+        uptime: +(uptimeRaw[0]?.value?.[1] ?? "0"),
+        totalRequests: Math.round(totalRequests),
+        totalErrors: Math.round(totalErrors),
+        avgResponseMs: +(avgResp[0]?.value?.[1] ?? "0"),
+        memoryUsageMb: +(memUsage[0]?.value?.[1] ?? "0"),
+        cpuUsagePct: +(cpuUsage[0]?.value?.[1] ?? "0"),
+        activeWorkflows: 0,
+        errorRate: totalRequests > 0 ? (totalErrors / totalRequests) * 100 : 0,
+    };
+};
+const fetchTriggerStatus = async (host, token) => {
+    const [triggerReqs, triggerErrs, triggerLatency] = await Promise.all([
+        queryPrometheus("sum(increase(workflow_total[5m])) by (workflow_name)", host, token),
+        queryPrometheus("sum(increase(workflow_errors_total[5m])) by (workflow_name)", host, token),
+        queryPrometheus("avg(increase(workflow_time[5m])) by (workflow_name)", host, token),
+    ]);
+    const triggers = {};
+    for (const entry of triggerReqs) {
+        const name = entry.metric.workflow_name || "unknown";
+        if (!triggers[name]) {
+            triggers[name] = { name, type: "http", status: "healthy", requests: 0, errors: 0, avgLatencyMs: 0 };
+        }
+        triggers[name].requests = Math.round(+(entry.value?.[1] ?? "0"));
+    }
+    for (const entry of triggerErrs) {
+        const name = entry.metric.workflow_name || "unknown";
+        if (triggers[name]) {
+            triggers[name].errors = Math.round(+(entry.value?.[1] ?? "0"));
+            if (triggers[name].errors > 0) {
+                const errorRate = triggers[name].requests > 0 ? triggers[name].errors / triggers[name].requests : 1;
+                triggers[name].status = errorRate > 0.5 ? "unhealthy" : "degraded";
+            }
+        }
+    }
+    for (const entry of triggerLatency) {
+        const name = entry.metric.workflow_name || "unknown";
+        if (triggers[name]) {
+            triggers[name].avgLatencyMs = +(entry.value?.[1] ?? "0");
+        }
+    }
+    return Object.values(triggers);
+};
+const fetchPrometheusMetrics = async (host, token) => {
+    const [wfReqs, wfTime, wfErrors, wfCPU, wfMem] = await Promise.all([
+        queryPrometheus("(sum(increase(workflow_total[1m])) by (workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(workflow_time[1m])) by (workflow_path)", host, token),
+        queryPrometheus("(sum(increase(workflow_errors_total[1m])) by (workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(workflow_cpu[1m])) by (workflow_path)", host, token),
+        queryPrometheus("sum(increase(workflow_memory[1m])) by (workflow_path)", host, token),
+    ]);
+    const wfMap = {};
+    const mapWorkflow = (list, key, convert) => {
+        for (const entry of list) {
+            const name = entry.metric.workflow_path;
+            if (!name)
+                continue;
+            if (!wfMap[name]) {
+                wfMap[name] = {
+                    workflow: name,
+                    totalTimeMs: 0,
+                    totalMemoryMb: 0,
+                    totalCpuPct: 0,
+                    errors: 0,
+                    requests: 0,
+                    nodes: [],
+                };
+            }
+            wfMap[name][key] = convert(entry.value?.[1] ?? "0");
+        }
+    };
+    mapWorkflow(wfTime, "totalTimeMs", (v) => +v);
+    mapWorkflow(wfMem, "totalMemoryMb", (v) => +v);
+    mapWorkflow(wfCPU, "totalCpuPct", (v) => +v);
+    mapWorkflow(wfErrors, "errors", (v) => Math.round(+v));
+    mapWorkflow(wfReqs, "requests", (v) => Math.round(+v));
+    const nodeMetricsRaw = await Promise.all([
+        queryPrometheus("(sum(increase(node_total[1m])) by (node_name, workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(node_time[1m])) by (node_name, workflow_path)", host, token),
+        queryPrometheus("(sum(increase(node_errors_total[1m])) by (node_name, workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(node_cpu[1m])) by (node_name, workflow_path)", host, token),
+        queryPrometheus("sum(increase(node_memory[1m])) by (node_name, workflow_path)", host, token),
+    ]);
+    const nodeMap = {};
+    const setNodeMetric = (list, key, convert) => {
+        for (const entry of list) {
+            const wf = entry.metric.workflow_path;
+            const node = entry.metric.node_name;
+            if (!wf || !node)
+                continue;
+            if (!nodeMap[wf])
+                nodeMap[wf] = {};
+            if (!nodeMap[wf][node])
+                nodeMap[wf][node] = { name: node };
+            const raw = Number.parseFloat(entry.value?.[1] ?? "0");
+            nodeMap[wf][node][key] = convert(raw.toString());
+        }
+    };
+    setNodeMetric(nodeMetricsRaw[0], "requests", (v) => +v);
+    setNodeMetric(nodeMetricsRaw[1], "timeMs", (v) => +v);
+    setNodeMetric(nodeMetricsRaw[4], "memoryMb", (v) => +v);
+    setNodeMetric(nodeMetricsRaw[3], "cpuPct", (v) => +v);
+    setNodeMetric(nodeMetricsRaw[2], "errors", (v) => Math.round(+v));
+    for (const wf of Object.keys(nodeMap)) {
+        const wfObj = wfMap[wf];
+        if (!wfObj)
+            continue;
+        const nodes = Object.values(nodeMap[wf]);
+        wfObj.nodes = nodes;
+    }
+    return Object.values(wfMap);
+};
+const formatUptime = (seconds) => {
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    return `${hours}h ${mins}m`;
+};
+const statusIndicator = (status) => {
+    switch (status) {
+        case "healthy":
+        case "active":
+            return chalk.green("UP");
+        case "degraded":
+            return chalk.yellow("WARN");
+        case "unhealthy":
+        case "error":
+            return chalk.red("DOWN");
+        default:
+            return chalk.gray("--");
+    }
+};
+const SystemPanel = ({ system }) => (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, children: chalk.cyan(" System Overview ") }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Uptime" }), _jsx(Text, { bold: true, children: formatUptime(system.uptime) })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Requests (5m)" }), _jsx(Text, { bold: true, children: fmt(system.totalRequests, 0) })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Error Rate" }), _jsxs(Text, { bold: true, color: system.errorRate > 5 ? "red" : system.errorRate > 1 ? "yellow" : "green", children: [fmt(system.errorRate), "%"] })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Avg Response" }), _jsxs(Text, { bold: true, children: [fmt(system.avgResponseMs, 0), "ms"] })] })] }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Memory" }), _jsxs(Text, { bold: true, children: [fmt(system.memoryUsageMb), "MB"] })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "CPU" }), _jsxs(Text, { bold: true, children: [fmt(system.cpuUsagePct), "%"] })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Errors (5m)" }), _jsx(Text, { bold: true, color: system.totalErrors > 0 ? "red" : "green", children: fmt(system.totalErrors, 0) })] }), _jsxs(Box, { flexDirection: "column", width: "25%", children: [_jsx(Text, { dimColor: true, children: "Workflows" }), _jsx(Text, { bold: true, children: system.activeWorkflows })] })] })] }));
+const TriggersPanel = ({ triggers }) => (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsx(Text, { bold: true, children: chalk.magenta(" Trigger Status ") }), triggers.length === 0 ? (_jsx(Text, { dimColor: true, children: " No trigger data available" })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: chalk.gray("  ┌────────────────────────┬──────────┬──────────┬──────────┬────────────┬────────┐") }), _jsx(Text, { children: chalk.gray("  │ Trigger                │ Type     │ Status   │ Requests │ Latency    │ Errors │") }), _jsx(Text, { children: chalk.gray("  ├────────────────────────┼──────────┼──────────┼──────────┼────────────┼────────┤") }), triggers.map((t) => (_jsx(Text, { children: `  │ ${t.name.slice(0, 22).padEnd(22)} │ ${t.type.padEnd(8)} │ ${statusIndicator(t.status).padEnd(17)} │ ${fmt(t.requests, 0).padStart(8)} │ ${fmt(t.avgLatencyMs, 0).padStart(8)}ms │ ${t.errors > 0 ? chalk.red(t.errors.toString().padStart(6)) : chalk.green("     0")} │` }, t.name))), _jsx(Text, { children: chalk.gray("  └────────────────────────┴──────────┴──────────┴──────────┴────────────┴────────┘") })] }))] }));
+const RuntimesPanel = ({ runtimes }) => {
+    const displayRuntimes = runtimes.length > 0
+        ? runtimes
+        : [
+            { kind: "nodejs", status: "active", executions: 0, avgDurationMs: 0, errors: 0 },
+            { kind: "python3", status: "inactive", executions: 0, avgDurationMs: 0, errors: 0 },
+            { kind: "docker", status: "inactive", executions: 0, avgDurationMs: 0, errors: 0 },
+        ];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { bold: true, children: chalk.yellow(" Runtime Adapters ") }), _jsx(Box, { flexDirection: "row", marginTop: 1, children: displayRuntimes.map((rt) => (_jsxs(Box, { flexDirection: "column", marginRight: 3, children: [_jsx(Text, { bold: true, children: rt.kind.toUpperCase() }), _jsx(Text, { children: statusIndicator(rt.status) }), _jsxs(Text, { dimColor: true, children: ["Exec: ", fmt(rt.executions, 0)] }), _jsxs(Text, { dimColor: true, children: ["Avg: ", fmt(rt.avgDurationMs, 0), "ms"] }), _jsxs(Text, { dimColor: true, children: ["Err: ", rt.errors > 0 ? chalk.red(rt.errors.toString()) : "0"] })] }, rt.kind))) })] }));
+};
+const WorkflowsPanel = ({ workflows, sortBy }) => {
+    const sorted = [...workflows].sort((a, b) => {
+        if (sortBy === "time")
+            return b.totalTimeMs - a.totalTimeMs;
+        if (sortBy === "memory")
+            return b.totalMemoryMb - a.totalMemoryMb;
+        if (sortBy === "cpu")
+            return b.totalCpuPct - a.totalCpuPct;
+        if (sortBy === "errors")
+            return b.errors - a.errors;
+        if (sortBy === "requests")
+            return b.requests - a.requests;
+        return 0;
+    });
+    return (_jsx(Box, { flexDirection: "column", children: sorted.length === 0 ? (_jsx(Text, { dimColor: true, children: " No workflow metrics available. Execute a workflow to see data." })) : (sorted.map((wf) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: `Workflow: ${wf.workflow} | Time: ${fmt(wf.totalTimeMs, 0)}ms | RAM: ${fmt(wf.totalMemoryMb)}MB | CPU: ${fmt(wf.totalCpuPct)}% | Reqs: ${fmt(wf.requests, 0)} | Errs: ${fmt(wf.errors, 0)}` }), _jsx(Box, { flexDirection: "column", paddingLeft: 2, children: wf.nodes.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: chalk.gray("  ┌──────────────────────┬───────────┬───────────┬──────────┬────────┬─────────┐") }), _jsx(Text, { children: chalk.gray("  │ Node                 │ Requests  │ Time(ms)  │ Mem(MB)  │ CPU(%) │ Errors  │") }), _jsx(Text, { children: chalk.gray("  ├──────────────────────┼───────────┼───────────┼──────────┼────────┼─────────┤") }), wf.nodes.map((node) => (_jsx(Text, { children: `  │ ${node.name.slice(0, 20).padEnd(20)} │ ${fmt(node.requests, 0).padStart(9)} | ${fmt(node.timeMs, 0).padStart(9)} │ ${fmt(node.memoryMb).padStart(8)} │ ${fmt(node.cpuPct).padStart(6)} │ ${(node.errors ?? 0) > 0
+                                    ? chalk.red((node.errors ?? 0).toString().padStart(7))
+                                    : chalk.green("      0")} │` }, node.name))), _jsx(Text, { children: chalk.gray("  └──────────────────────┴───────────┴───────────┴──────────┴────────┴─────────┘") })] })) : (_jsx(Text, { dimColor: true, children: " (No node-level data)" })) })] }, wf.workflow)))) }));
+};
+const Monitor = ({ host, token }) => {
+    const [workflows, setWorkflows] = useState([]);
+    const [system, setSystem] = useState({
+        uptime: 0,
+        totalRequests: 0,
+        totalErrors: 0,
+        avgResponseMs: 0,
+        memoryUsageMb: 0,
+        cpuUsagePct: 0,
+        activeWorkflows: 0,
+        errorRate: 0,
+    });
+    const [triggers, setTriggers] = useState([]);
+    const [runtimes] = useState([]);
+    const [lastUpdate, setLastUpdate] = useState(new Date());
+    const [sortBy, setSortBy] = useState("time");
+    const [view, setView] = useState("workflows");
+    useEffect(() => {
+        const fetchAll = async () => {
+            const [wfResult, sysResult, trigResult] = await Promise.all([
+                fetchPrometheusMetrics(host, token),
+                fetchSystemMetrics(host, token),
+                fetchTriggerStatus(host, token),
+            ]);
+            sysResult.activeWorkflows = wfResult.length;
+            setWorkflows(wfResult);
+            setSystem(sysResult);
+            setTriggers(trigResult);
+            setLastUpdate(new Date());
+        };
+        fetchAll();
+        const interval = setInterval(fetchAll, 3000);
+        return () => clearInterval(interval);
+    }, [host, token]);
+    useInput((input) => {
+        if (input === "w")
+            setSortBy("time");
+        else if (input === "m")
+            setSortBy("memory");
+        else if (input === "c")
+            setSortBy("cpu");
+        else if (input === "e")
+            setSortBy("errors");
+        else if (input === "r")
+            setSortBy("requests");
+        else if (input === "1")
+            setView("workflows");
+        else if (input === "2")
+            setView("system");
+        else if (input === "3")
+            setView("triggers");
+        else if (input === "4")
+            setView("runtimes");
+        else if (input === "q")
+            process.exit(0);
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, children: [chalk.cyan("Blok Monitor"), chalk.gray(` — ${lastUpdate.toLocaleTimeString()}`), chalk.gray(` | Uptime: ${formatUptime(system.uptime)}`), chalk.gray(` | ${system.totalRequests} reqs`), system.totalErrors > 0 ? chalk.red(` | ${system.totalErrors} errs`) : ""] }), _jsx(Text, { dimColor: true, children: `[1] Workflows${view === "workflows" ? "*" : ""}  [2] System${view === "system" ? "*" : ""}  [3] Triggers${view === "triggers" ? "*" : ""}  [4] Runtimes${view === "runtimes" ? "*" : ""}  | Sort: [w]Time [m]Mem [c]CPU [r]Req [e]Err  [q]Quit` }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [chalk.green(`Reqs: ${fmt(system.totalRequests, 0)}`), "  ", chalk.yellow(`Avg: ${fmt(system.avgResponseMs, 0)}ms`), "  ", system.totalErrors > 0 ? chalk.red(`Errors: ${fmt(system.totalErrors, 0)}`) : chalk.green("Errors: 0"), "  ", chalk.blue(`Mem: ${fmt(system.memoryUsageMb)}MB`), "  ", chalk.magenta(`CPU: ${fmt(system.cpuUsagePct)}%`)] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [view === "workflows" && _jsx(WorkflowsPanel, { workflows: workflows, sortBy: sortBy }), view === "system" && _jsx(SystemPanel, { system: system }), view === "triggers" && _jsx(TriggersPanel, { triggers: triggers }), view === "runtimes" && _jsx(RuntimesPanel, { runtimes: runtimes })] })] }));
+};
+export const runMonitor = (host, token) => {
+    render(_jsx(Monitor, { host: host, token: token }));
+};