peerllm-host-cli 0.3.0 → 0.5.0

package/dist/cli/commands/dashboard.js

@@ -1,14 +1,18 @@
 import { cpus, totalmem, freemem } from "node:os";
+import { readdirSync, existsSync } from "node:fs";
 import { Command } from "commander";
+import { graphics, fsSize } from "systeminformation";
 import { resolvePaths } from "../../core/paths.js";
 import { METHOD } from "../../shared/protocol.js";
 import { renderBanner, renderBrand } from "../banner.js";
 import { EXIT } from "../exit-codes.js";
 import { printError } from "../format.js";
 import { DaemonUnreachableError, IpcClient } from "../ipc-client.js";
-import { ANSI, bar, enterTui, moveTo, padRight, paint, sparkline, truncate, write, } from "../tui.js";
+import { ANSI, bar, centerInWidth, enterTui, moveTo, padRight, padVisible, paint, sparkline, truncate, truncateVisible, visibleLength, write, } from "../tui.js";
 const MAX_CPU_SAMPLES = 60;
 const MAX_LOG_LINES = 6;
+const GPU_REFRESH_EVERY = 5; // ticks between systeminformation GPU polls
+const DISK_REFRESH_EVERY = 10; // ticks between disk + local-model-list polls
 function readCpuSnapshot() {
     let idle = 0;
     let total = 0;
@@ -43,121 +47,288 @@ function formatUptime(seconds) {
     const d = Math.floor(h / 24);
     return `${d}d ${h % 24}h`;
 }
-function row(label, value, labelWidth = 14) {
+function formatMoney(amount) {
+    return amount.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+function row(label, value, labelWidth = 16) {
+    // padRight on plain label is safe — no ANSI codes in `label`.
     return paint("dim", padRight(label, labelWidth)) + value;
 }
-function panelTitle(title) {
-    return paint(["cyan", "bold"], `┌─ ${title} `) + paint("dim", "─".repeat(Math.max(0, 50 - title.length)));
+const FRAME_MIN = 60;
+const FRAME_MAX = 100;
+const FRAME_PAD = 4; // "│ " + " │"
+function frameWidth(cols) {
+    return Math.max(FRAME_MIN, Math.min(FRAME_MAX, cols - 2));
 }
-function panelDivider(width) {
-    return paint("dim", "─".repeat(width));
+/** Render a fully-bordered panel: `┌─ Title (suffix) ─┐ … │ row │ … └────┘`. */
+function renderPanel(title, suffix, lines, width) {
+    const inner = Math.max(2, width - 2); // visible chars between corners
+    const header = renderPanelHeader(title, suffix, inner);
+    const body = lines
+        .map((line) => {
+        const trimmed = truncateVisible(line, inner - 2);
+        return (paint("cyan", "│ ") +
+            padVisible(trimmed, inner - 2) +
+            paint("cyan", " │"));
+    })
+        .join("\n");
+    const footer = paint("cyan", "└" + "─".repeat(inner) + "┘");
+    return `${header}\n${body}\n${footer}`;
 }
-function render(state, cols) {
-    // Clear + go home, then redraw.
-    write(ANSI.home + ANSI.clear);
-    write(renderBanner() + "\n");
-    write("  " +
-        renderBrand() +
-        paint("dim", "  ·  ") +
-        paint("dim", "decentralized AI host  ·  ") +
-        paint(state.lastUpdated ? "gray" : "dim", state.lastUpdated ? `last update ${state.lastUpdated.toLocaleTimeString()}` : "loading…") +
-        "\n\n");
-    if (state.lastError) {
-        write("  " + paint("yellow", `⚠ ${state.lastError}`) + "\n\n");
+function renderPanelHeader(title, suffix, inner) {
+    // Target visible width: inner + 2 (matches footer "└" + inner dashes + "┘").
+    // Visible parts: "┌─ " (3) + title + " " (in segment) + optional "suffix " + dashes + "┐" (1)
+    const titleSegment = `${title} ` + (suffix ? `${suffix} ` : "");
+    const dashCount = Math.max(0, inner - 2 - visibleLength(titleSegment));
+    const left = paint("cyan", "┌─ ") + paint(["cyan", "bold"], `${title} `);
+    const suffixPart = suffix ? paint("yellow", `${suffix} `) : "";
+    return left + suffixPart + paint("cyan", "─".repeat(dashCount) + "┐");
+}
+function na(note) {
+    return paint("dim", `(${note})`);
+}
+function renderHeader(state, width) {
+    const version = state.status?.daemon.version ?? "";
+    const lastUpdate = state.lastUpdated
+        ? paint("gray", `last update ${state.lastUpdated.toLocaleTimeString()}`)
+        : paint("dim", "loading…");
+    const out = [];
+    // Center each row of the ASCII banner independently.
+    for (const row of renderBanner().split("\n")) {
+        out.push(centerInWidth(row, width));
     }
-    // Daemon + Orchestrator panel
-    write(panelTitle("Daemon") + "\n");
-    if (state.status) {
-        const s = state.status;
-        write("  " +
-            row("pid", String(s.daemon.pid)) +
+    out.push("");
+    out.push(centerInWidth(renderBrand() + paint("dim", "  ·  decentralized AI host  ·  ") + lastUpdate, width));
+    out.push(centerInWidth(paint("dim", "© 2026 Hassan Habib."), width));
+    out.push(centerInWidth(paint("dim", "Operated by BestBytes AI, LLC."), width));
+    out.push(centerInWidth(paint(["cyan", "bold"], "Terms & Conditions") +
+        paint("dim", "  ·  ") +
+        paint("bold", version ? `v${version}` : "v—"), width));
+    return out.join("\n");
+}
+function buildDaemonPanel(state) {
+    if (!state.status)
+        return [paint("dim", "(awaiting status…)")];
+    const s = state.status;
+    const upgradeAvailable = s.daemon.latestCliVersion !== undefined &&
+        s.daemon.latestCliVersion !== s.daemon.version;
+    const versionCell = upgradeAvailable
+        ? paint("bold", s.daemon.version) +
+            paint("yellow", `  → ${s.daemon.latestCliVersion} on npm`)
+        : paint("bold", s.daemon.version);
+    const lines = [];
+    lines.push(row("pid", String(s.daemon.pid)) +
+        paint("dim", "    ") +
+        row("uptime", paint(["green"], formatUptime(s.daemon.uptimeSeconds)), 10) +
+        paint("dim", "    ") +
+        row("version", versionCell, 10));
+    lines.push(row("orchestrator", statusBadge(s.orchestrator.status)));
+    const authStr = s.auth.loggedIn
+        ? paint("green", "logged in") +
+            (s.auth.userId ? paint("dim", ` (user ${s.auth.userId.slice(0, 8)}…)`) : "")
+        : paint("yellow", "logged out");
+    lines.push(row("auth", authStr));
+    lines.push(row("agreement", s.auth.agreementAccepted ? paint("green", "accepted") : paint("yellow", "not accepted")));
+    return lines;
+}
+function buildHostPanel(state) {
+    if (!state.status)
+        return [paint("dim", "(awaiting status…)")];
+    const s = state.status;
+    const lines = [];
+    lines.push(row("name", s.config.hostName ?? paint("dim", "(unset)")));
+    lines.push(row("host id", paint("gray", s.config.hostId ? `${s.config.hostId.slice(0, 8)}…` : "(unset)")));
+    if (s.host) {
+        lines.push(row("status", s.host.isApproved
+            ? paint("green", "approved")
+            : paint("yellow", "pending approval")));
+        lines.push(row("uptime", paint("green", s.host.currentUptime)) +
             paint("dim", "    ") +
-            row("uptime", paint(["green"], formatUptime(s.daemon.uptimeSeconds)), 8) +
+            row("total up", paint("gray", s.host.totalUptime), 12));
+        lines.push(row("conversations", paint("cyan", s.host.conversations.toLocaleString())) +
             paint("dim", "    ") +
-            row("version", paint("bold", s.daemon.version), 9) +
-            "\n");
-        write("  " + row("orchestrator", statusBadge(s.orchestrator.status)) + "\n");
-        const authStr = s.auth.loggedIn
-            ? paint("green", "logged in") +
-                (s.auth.userId ? paint("dim", ` (user ${s.auth.userId.slice(0, 8)}…)`) : "")
-            : paint("yellow", "logged out");
-        write("  " + row("auth", authStr) + "\n");
-        const agreementStr = s.auth.agreementAccepted
-            ? paint("green", "accepted")
-            : paint("yellow", "not accepted");
-        write("  " + row("agreement", agreementStr) + "\n");
-    }
-    else {
-        write("  " + paint("dim", "(awaiting status…)") + "\n");
-    }
-    write("\n");
-    // Host panel
-    write(panelTitle("Host") + "\n");
-    if (state.status) {
-        const s = state.status;
-        const hostName = s.config.hostName ?? paint("dim", "(unset)");
-        const hostId = s.config.hostId ? `${s.config.hostId.slice(0, 8)}…` : paint("dim", "(unset)");
-        write("  " + row("name", hostName) + "\n");
-        write("  " + row("host id", paint("gray", hostId)) + "\n");
+            row("avg resp", `${s.host.averageResponseMs.toFixed(0)} ms`, 12));
     }
     else {
-        write("  " + paint("dim", "(awaiting status…)") + "\n");
+        lines.push(row("status", na("backend stats loading…")));
     }
-    write("\n");
-    // Model panel
-    write(panelTitle("Model") + "\n");
+    return lines;
+}
+function buildModelPanel(state) {
     if (state.models?.loaded) {
         const m = state.models.loaded;
-        write("  " + row("loaded", paint(["bold", "green"], m.modelName)) + "\n");
-        write("  " +
+        return [
+            row("loaded", paint(["bold", "green"], m.modelName)),
             row("gpu layers", String(m.gpuLayers)) +
-            paint("dim", "    ") +
-            row("active conv.", paint("cyan", String(m.activeContexts)), 14) +
-            "\n");
+                paint("dim", "    ") +
+                row("active conv.", paint("cyan", String(m.activeContexts)), 16),
+        ];
     }
-    else {
-        write("  " +
-            paint("dim", "(no model loaded — ") +
+    return [
+        paint("dim", "(no model loaded — ") +
             paint(["bold", "cyan"], "peerllm-host models download") +
-            paint("dim", " to fetch one)") +
-            "\n");
+            paint("dim", " to fetch one)"),
+    ];
+}
+function buildResourcesPanel(state, innerWidth) {
+    // Reserve space inside the frame: label (16) + padding (4) + percent/label tail (~14).
+    const barWidth = Math.max(20, Math.min(50, innerWidth - 36));
+    const lines = [];
+    lines.push(row("CPU", bar(state.cpuFraction, barWidth, "cyan")) +
+        paint("dim", `  ${(state.cpuFraction * 100).toFixed(0)}%`));
+    lines.push(row("RAM", bar(state.ramFraction, barWidth, "magenta")) +
+        paint("dim", `  ${(state.ramFraction * 100).toFixed(0)}%`));
+    if (state.gpu === undefined) {
+        lines.push(row("GPU", paint("dim", "detecting…")));
     }
-    write("\n");
-    // Resources panel
-    const barWidth = Math.max(20, Math.min(40, cols - 40));
-    write(panelTitle("Resources") + "\n");
-    write("  " +
-        row("CPU", bar(state.cpuFraction, barWidth, "cyan")) +
-        paint("dim", `  ${(state.cpuFraction * 100).toFixed(0)}%`) +
-        "\n");
-    write("  " +
-        row("RAM", bar(state.ramFraction, barWidth, "magenta")) +
-        paint("dim", `  ${(state.ramFraction * 100).toFixed(0)}%`) +
-        "\n");
-    // Sparkline: CPU% over the last MAX_CPU_SAMPLES ticks
-    const sparkWidth = Math.min(MAX_CPU_SAMPLES, Math.max(20, cols - 20));
-    const padded = padSparkline(state.cpuSamples, sparkWidth);
-    write("  " + row("trend (60s)", sparkline(padded, "cyan")) + "\n");
-    write("\n");
-    // Logs panel (tails recent log lines if any have arrived from the daemon)
-    write(panelTitle("Recent activity") + "\n");
-    if (state.logs.length === 0) {
-        write("  " + paint("dim", "(no recent events — host idle)") + "\n");
+    else if (state.gpu === null) {
+        lines.push(row("GPU", na("no GPU detected")));
     }
     else {
-        for (const l of state.logs.slice(-MAX_LOG_LINES)) {
-            write("  " + formatLog(l, cols - 4) + "\n");
+        const g = state.gpu;
+        const hasUtil = !Number.isNaN(g.utilizationFraction) && g.utilizationFraction >= 0;
+        const gpuLabel = truncate(g.name, 22);
+        if (hasUtil) {
+            lines.push(row("GPU", bar(g.utilizationFraction, barWidth, "yellow")) +
+                paint("dim", `  ${(g.utilizationFraction * 100).toFixed(0)}%  ${gpuLabel}`));
+        }
+        else {
+            lines.push(row("GPU", paint("dim", gpuLabel) + paint("gray", "  (utilization unavailable)")));
+        }
+        if (g.vramTotalMB > 0) {
+            const vramFrac = Math.max(0, Math.min(1, g.vramUsedMB / g.vramTotalMB));
+            lines.push(row("VRAM", bar(vramFrac, barWidth, "yellow")) +
+                paint("dim", `  ${(g.vramUsedMB / 1024).toFixed(1)} / ${(g.vramTotalMB / 1024).toFixed(1)} GB`));
         }
     }
-    write("\n");
-    // Help bar
-    write(panelDivider(Math.min(cols, 60)) + "\n");
-    write("  " +
-        keyHint("q", "quit") +
+    if (state.diskFraction !== undefined && state.diskTotalGB && state.diskTotalGB > 0) {
+        lines.push(row("Disk", bar(state.diskFraction, barWidth, "green")) +
+            paint("dim", `  ${(state.diskUsedGB ?? 0).toFixed(1)} / ${state.diskTotalGB.toFixed(1)} GB`));
+    }
+    else {
+        lines.push(row("Disk", na("disk info unavailable")));
+    }
+    const sparkWidth = Math.min(MAX_CPU_SAMPLES, Math.max(20, innerWidth - 22));
+    lines.push(row("trend (60s)", sparkline(padSparkline(state.cpuSamples, sparkWidth), "cyan")));
+    return lines;
+}
+function buildNetworkPanel(state) {
+    if (state.status?.network) {
+        const n = state.status.network;
+        return [
+            row("hosts", `${n.activeHosts.toLocaleString()} active`) +
+                paint("dim", "    ") +
+                row("approved", paint("cyan", n.approvedHosts.toLocaleString()), 11) +
+                paint("dim", "    ") +
+                row("total", paint("cyan", n.totalHosts.toLocaleString()), 8),
+            row("tokens served", n.totalServedTokens.toLocaleString()),
+            row("uptime", `${n.networkUptimePct.toFixed(1)}%`),
+        ];
+    }
+    if (state.status)
+        return [na("backend unreachable — retrying")];
+    return [na("connecting to daemon…")];
+}
+function buildTokensPanel(state) {
+    const t = state.status?.tokens;
+    if (!t)
+        return [na("awaiting daemon stats…")];
+    const fmtFlow = (label, f) => {
+        const rate = paint("cyan", `${f.tokensPerSecond.toFixed(1)} tok/s`);
+        const session = paint("dim", `session ${f.totalServed.toLocaleString()}`);
+        const lifetime = f.lifetime !== undefined
+            ? paint("dim", `  ·  lifetime ${f.lifetime.toLocaleString()}`)
+            : "";
+        return row(label, `${rate}  ${session}${lifetime}`);
+    };
+    return [fmtFlow("in", t.in), fmtFlow("out", t.out)];
+}
+function buildEarningsPanel(state) {
+    if (state.status?.earnings) {
+        const e = state.status.earnings;
+        return [
+            row("pending payout", paint(["green", "bold"], `${formatMoney(e.pendingAmount)} ${e.currency}`)),
+        ];
+    }
+    if (state.status?.auth.loggedIn)
+        return [na("awaiting payout data…")];
+    return [na("login required to fetch earnings")];
+}
+function buildAvailableLlmsPanel(state, innerWidth) {
+    const lines = [];
+    const nameBudget = Math.max(20, innerWidth - 6); // leave room for "  · " indent
+    const localModels = state.localModels;
+    if (localModels === undefined) {
+        lines.push(row("local", paint("dim", "scanning…")));
+    }
+    else if (localModels.length === 0) {
+        lines.push(row("local", paint("dim", "none — run ") + paint(["bold", "cyan"], "peerllm-host models download")));
+    }
+    else {
+        lines.push(row("local", paint("cyan", String(localModels.length))));
+        for (const name of localModels) {
+            lines.push(paint("dim", "  · ") + paint("cyan", truncateVisible(name, nameBudget)));
+        }
+    }
+    if (state.models?.available !== undefined) {
+        lines.push(row("daemon list", paint("cyan", String(state.models.available.length))));
+    }
+    else {
+        lines.push(row("daemon list", na("daemon not reporting")));
+    }
+    const approved = state.models?.approved;
+    if (approved && approved.length > 0) {
+        lines.push(row("approved", paint(["green", "bold"], String(approved.length))));
+        for (const name of approved) {
+            lines.push(paint("dim", "  · ") + paint(["green", "bold"], truncateVisible(name, nameBudget)));
+        }
+    }
+    else if (approved !== undefined) {
+        lines.push(row("approved", na("none — orchestrator hasn't registered yet")));
+    }
+    return lines;
+}
+function buildRecentActivityPanel(state, innerWidth) {
+    if (state.logs.length === 0)
+        return [paint("dim", "(no recent events — host idle)")];
+    return state.logs.slice(-MAX_LOG_LINES).map((l) => formatLog(l, innerWidth - 2));
+}
+function render(state, cols) {
+    write(ANSI.home + ANSI.clear);
+    const width = frameWidth(cols);
+    const inner = width - FRAME_PAD; // visible cells available for row content
+    write(renderHeader(state, width) + "\n\n");
+    if (state.lastError) {
+        write("  " + paint("yellow", `⚠ ${state.lastError}`) + "\n\n");
+    }
+    const panels = [
+        ["Daemon", undefined, buildDaemonPanel(state)],
+        ["Host", state.status?.host?.stale ? "(stale)" : undefined, buildHostPanel(state)],
+        ["Model", undefined, buildModelPanel(state)],
+        ["Resources", undefined, buildResourcesPanel(state, inner)],
+        [
+            "Network",
+            state.status?.network?.stale ? "(stale)" : undefined,
+            buildNetworkPanel(state),
+        ],
+        ["Tokens", undefined, buildTokensPanel(state)],
+        [
+            "Earnings",
+            state.status?.earnings?.stale ? "(stale)" : undefined,
+            buildEarningsPanel(state),
+        ],
+        ["Available LLMs", undefined, buildAvailableLlmsPanel(state, inner)],
+        ["Recent activity", undefined, buildRecentActivityPanel(state, inner)],
+    ];
+    for (const [title, suffix, lines] of panels) {
+        write(renderPanel(title, suffix, lines, width) + "\n");
+    }
+    // Help bar — also framed for visual consistency.
+    const help = keyHint("q", "quit") +
         keyHint("r", "refresh now") +
         keyHint("l", "clear logs") +
-        keyHint("?", "help") +
-        "\n");
+        keyHint("?", "help");
+    write(renderPanel("Keys", undefined, [help.trimEnd()], width) + "\n");
 }
 function padSparkline(values, width) {
     if (values.length >= width)
@@ -181,136 +352,221 @@ function formatLog(l, maxWidth) {
     const visiblePrefixLen = ts.length + 1 + 5;
     return prefix + " " + truncate(l.message, Math.max(0, maxWidth - visiblePrefixLen - 1));
 }
-export function makeDashboardCommand() {
-    return new Command("dashboard")
-        .description("Interactive TUI: watch live host status, model, and traffic")
-        .option("--config-dir <path>", "override config directory")
-        .option("--interval <ms>", "refresh interval in milliseconds (default 1000)", "1000")
-        .action(async (opts) => {
-        const intervalMs = Math.max(250, Number.parseInt(opts.interval ?? "1000", 10) || 1000);
-        const paths = resolvePaths({ configDirOverride: opts.configDir });
-        const client = new IpcClient(paths.ipcEndpoint);
-        try {
-            await client.connect();
+export async function runDashboard(ipcEndpoint, modelsDir, intervalMs = 1000) {
+    const client = new IpcClient(ipcEndpoint);
+    try {
+        await client.connect();
+    }
+    catch (err) {
+        if (err instanceof DaemonUnreachableError) {
+            printError("daemon is not running", {
+                hint: "Start it with: peerllm-host start",
+            });
+            process.exit(EXIT.daemonNotRunning);
         }
-        catch (err) {
-            if (err instanceof DaemonUnreachableError) {
-                printError("daemon is not running", {
-                    hint: "Start it with: peerllm-host start",
-                });
-                process.exit(EXIT.daemonNotRunning);
-            }
-            printError(err.message);
-            process.exit(EXIT.runtimeError);
+        printError(err.message);
+        process.exit(EXIT.runtimeError);
+    }
+    const tui = enterTui();
+    const state = {
+        cpuSamples: [],
+        ramFraction: 0,
+        cpuFraction: 0,
+        logs: [],
+    };
+    let prevCpu = readCpuSnapshot();
+    // Init counters to (REFRESH_EVERY - 1) so the very first tick fires a refresh.
+    let gpuTick = GPU_REFRESH_EVERY - 1;
+    let diskTick = DISK_REFRESH_EVERY - 1;
+    client.onNotification((method, params) => {
+        const name = method.startsWith("event:") ? method.slice("event:".length) : method;
+        if (name === "log") {
+            const p = params;
+            if (p && typeof p.message === "string")
+                state.logs.push(p);
+            while (state.logs.length > MAX_LOG_LINES * 2)
+                state.logs.shift();
+        }
+        else if (name === "orchestratorStatus") {
+            void pollOnce();
         }
-        const tui = enterTui();
-        const state = {
-            cpuSamples: [],
-            ramFraction: 0,
-            cpuFraction: 0,
-            logs: [],
-        };
-        let prevCpu = readCpuSnapshot();
-        // Subscribe to daemon events for live updates between polls.
-        client.onNotification((method, params) => {
-            const name = method.startsWith("event:") ? method.slice("event:".length) : method;
-            if (name === "log") {
-                const p = params;
-                if (p && typeof p.message === "string")
-                    state.logs.push(p);
-                while (state.logs.length > MAX_LOG_LINES * 2)
-                    state.logs.shift();
+        else if (name === "hostStats") {
+            const p = params;
+            if (typeof p.cpuPercent === "number") {
+                state.cpuFraction = Math.max(0, Math.min(1, p.cpuPercent / 100));
+                state.cpuSamples.push(state.cpuFraction);
+                while (state.cpuSamples.length > MAX_CPU_SAMPLES)
+                    state.cpuSamples.shift();
             }
-            else if (name === "orchestratorStatus") {
-                // Force an immediate poll on connection-state changes.
-                void pollOnce();
+            if (typeof p.ramUsedMB === "number" && typeof p.ramTotalMB === "number" && p.ramTotalMB > 0) {
+                state.ramFraction = Math.max(0, Math.min(1, p.ramUsedMB / p.ramTotalMB));
             }
-            else if (name === "hostStats") {
-                const p = params;
-                if (typeof p.cpuPercent === "number") {
-                    state.cpuFraction = Math.max(0, Math.min(1, p.cpuPercent / 100));
-                    state.cpuSamples.push(state.cpuFraction);
-                    while (state.cpuSamples.length > MAX_CPU_SAMPLES)
-                        state.cpuSamples.shift();
-                }
-                if (typeof p.ramUsedMB === "number" && typeof p.ramTotalMB === "number" && p.ramTotalMB > 0) {
-                    state.ramFraction = Math.max(0, Math.min(1, p.ramUsedMB / p.ramTotalMB));
-                }
+            if (p.gpu) {
+                const prev = state.gpu ?? undefined;
+                state.gpu = {
+                    name: p.gpu.name ?? (prev && prev !== null ? prev.name : "GPU"),
+                    utilizationFraction: typeof p.gpu.utilizationPercent === "number"
+                        ? p.gpu.utilizationPercent / 100
+                        : prev && prev !== null
+                            ? prev.utilizationFraction
+                            : Number.NaN,
+                    vramUsedMB: p.gpu.vramUsedMB ?? (prev && prev !== null ? prev.vramUsedMB : 0),
+                    vramTotalMB: p.gpu.vramTotalMB ?? (prev && prev !== null ? prev.vramTotalMB : 0),
+                };
             }
-        });
+        }
+    });
+    try {
+        await client.call("events.subscribe", { filter: "*" });
+    }
+    catch {
+        // Non-fatal: polling still works without event subscription.
+    }
+    const pollOnce = async () => {
         try {
-            await client.call("events.subscribe", { filter: "*" });
+            const [status, models] = await Promise.all([
+                client.call(METHOD.getStatus),
+                client.call(METHOD.modelsState),
+            ]);
+            state.status = status;
+            state.models = models;
+            state.lastError = undefined;
         }
-        catch {
-            // Non-fatal: events are a nice-to-have; polling still works.
+        catch (err) {
+            state.lastError = `IPC: ${err.message}`;
+        }
+        state.lastUpdated = new Date();
+    };
+    const sampleLocal = async () => {
+        // CPU (sync, every tick)
+        const next = readCpuSnapshot();
+        const totalDelta = next.total - prevCpu.total;
+        const idleDelta = next.idle - prevCpu.idle;
+        prevCpu = next;
+        if (totalDelta > 0) {
+            state.cpuFraction = Math.max(0, Math.min(1, 1 - idleDelta / totalDelta));
         }
-        const pollOnce = async () => {
+        state.cpuSamples.push(state.cpuFraction);
+        while (state.cpuSamples.length > MAX_CPU_SAMPLES)
+            state.cpuSamples.shift();
+        // RAM (sync, every tick)
+        const total = totalmem();
+        const free = freemem();
+        if (total > 0)
+            state.ramFraction = Math.max(0, Math.min(1, 1 - free / total));
+        // GPU — throttled; uses systeminformation for cross-platform support.
+        // Daemon hostStats event takes precedence if it starts sending GPU data.
+        gpuTick++;
+        if (gpuTick >= GPU_REFRESH_EVERY) {
+            gpuTick = 0;
             try {
-                const [status, models] = await Promise.all([
-                    client.call(METHOD.getStatus),
-                    client.call(METHOD.modelsState),
-                ]);
-                state.status = status;
-                state.models = models;
-                state.lastError = undefined;
-            }
-            catch (err) {
-                state.lastError = `IPC: ${err.message}`;
+                const { controllers } = await graphics();
+                if (controllers.length === 0) {
+                    state.gpu = null;
+                }
+                else {
+                    const c = controllers[0];
+                    const util = typeof c.utilizationGpu === "number" ? c.utilizationGpu / 100 : Number.NaN;
+                    const vramTotal = (c.memoryTotal ?? c.vram) ?? 0;
+                    const vramUsed = c.memoryUsed ?? 0;
+                    state.gpu = {
+                        name: c.model ?? "GPU",
+                        utilizationFraction: util,
+                        vramUsedMB: vramUsed,
+                        vramTotalMB: vramTotal,
+                    };
+                }
             }
-            state.lastUpdated = new Date();
-        };
-        const sampleLocal = () => {
-            const next = readCpuSnapshot();
-            const totalDelta = next.total - prevCpu.total;
-            const idleDelta = next.idle - prevCpu.idle;
-            prevCpu = next;
-            if (totalDelta > 0) {
-                state.cpuFraction = Math.max(0, Math.min(1, 1 - idleDelta / totalDelta));
+            catch {
+                // Non-fatal: GPU info is best-effort.
             }
-            state.cpuSamples.push(state.cpuFraction);
-            while (state.cpuSamples.length > MAX_CPU_SAMPLES)
-                state.cpuSamples.shift();
-            const total = totalmem();
-            const free = freemem();
-            if (total > 0)
-                state.ramFraction = Math.max(0, Math.min(1, 1 - free / total));
-        };
-        const tick = async () => {
-            sampleLocal();
-            await pollOnce();
-            render(state, tui.cols);
-        };
-        // Initial paint, then steady cadence.
-        await tick();
-        const timer = setInterval(() => void tick(), intervalMs);
-        const exit = (code) => {
-            clearInterval(timer);
-            client.close();
-            tui.teardown();
-            write(moveTo(1, 1));
-            process.exit(code);
-        };
-        tui.onKey((key) => {
-            if (key.name === "q" || (key.ctrl && key.name === "c")) {
-                exit(EXIT.ok);
-                return;
+        }
+        // Disk + local model list — throttled together.
+        diskTick++;
+        if (diskTick >= DISK_REFRESH_EVERY) {
+            diskTick = 0;
+            // Disk usage via systeminformation (cross-platform).
+            try {
+                const fsSizes = await fsSize();
+                if (fsSizes.length > 0) {
+                    const mDir = modelsDir.toLowerCase().replace(/\\/g, "/");
+                    let match = fsSizes[0];
+                    let bestLen = 0;
+                    for (const fs of fsSizes) {
+                        const mount = (fs.mount ?? "").toLowerCase().replace(/\\/g, "/");
+                        if (mDir.startsWith(mount) && mount.length > bestLen) {
+                            bestLen = mount.length;
+                            match = fs;
+                        }
+                    }
+                    if (match.size > 0) {
+                        state.diskFraction = Math.max(0, Math.min(1, match.use / 100));
+                        state.diskTotalGB = match.size / 1024 ** 3;
+                        state.diskUsedGB = match.used / 1024 ** 3;
+                    }
+                }
             }
-            if (key.name === "r") {
-                void tick();
-                return;
+            catch {
+                // Non-fatal.
             }
-            if (key.name === "l") {
-                state.logs = [];
-                render(state, tui.cols);
-                return;
+            // Local GGUF model listing (sync readdir).
+            try {
+                state.localModels = existsSync(modelsDir)
+                    ? readdirSync(modelsDir)
+                        .filter((f) => f.toLowerCase().endsWith(".gguf"))
+                        .map((f) => f.replace(/\.gguf$/i, ""))
+                    : [];
             }
-            if (key.name === "?") {
-                state.lastError = "keys: q=quit · r=refresh · l=clear logs · ?=this help";
-                render(state, tui.cols);
+            catch {
+                // Non-fatal.
             }
-        });
-        // Park forever (timer + key handler drive the rest).
-        await new Promise(() => { });
+        }
+    };
+    const tick = async () => {
+        await sampleLocal();
+        await pollOnce();
+        render(state, tui.cols);
+    };
+    await tick();
+    const timer = setInterval(() => void tick(), intervalMs);
+    const exit = (code) => {
+        clearInterval(timer);
+        client.close();
+        tui.teardown();
+        write(moveTo(1, 1));
+        process.exit(code);
+    };
+    tui.onKey((key) => {
+        if (key.name === "q" || (key.ctrl && key.name === "c")) {
+            exit(EXIT.ok);
+            return;
+        }
+        if (key.name === "r") {
+            void tick();
+            return;
+        }
+        if (key.name === "l") {
+            state.logs = [];
+            render(state, tui.cols);
+            return;
+        }
+        if (key.name === "?") {
+            state.lastError = "keys: q=quit · r=refresh · l=clear logs · ?=this help";
+            render(state, tui.cols);
+        }
+    });
+    // Park forever (timer + key handler drive the rest).
+    await new Promise(() => { });
+}
+export function makeDashboardCommand() {
+    return new Command("dashboard")
+        .description("Interactive TUI: watch live host status, model, and traffic")
+        .option("--config-dir <path>", "override config directory")
+        .option("--interval <ms>", "refresh interval in milliseconds (default 1000)", "1000")
+        .action(async (opts) => {
+        const intervalMs = Math.max(250, Number.parseInt(opts.interval ?? "1000", 10) || 1000);
+        const paths = resolvePaths({ configDirOverride: opts.configDir });
+        await runDashboard(paths.ipcEndpoint, paths.modelsDir, intervalMs);
     });
 }
 //# sourceMappingURL=dashboard.js.map