peerllm-host-cli 0.2.0 → 0.5.0

package/dist/cli/banner.d.ts

@@ -0,0 +1,9 @@
+/** Multi-line PeerLLM block banner. Returns the full multi-row string. */
+export declare function renderBanner(): string;
+/** Inline colored "PeerLLM" wordmark — for one-line headers and prompts. */
+export declare function renderBrand(): string;
+/** Tagline shown under the banner in help / dashboard. */
+export declare function renderTagline(version: string): string;
+/** Banner + tagline, separated by blank lines. Suitable for --help and dashboard. */
+export declare function renderHeader(version: string): string;
+//# sourceMappingURL=banner.d.ts.map

package/dist/cli/banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../src/cli/banner.ts"],"names":[],"mappings":"AAyBA,0EAA0E;AAC1E,wBAAgB,YAAY,IAAI,MAAM,CAYrC;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,IAAI,MAAM,CAMpC;AAED,0DAA0D;AAC1D,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/cli/banner.js

@@ -0,0 +1,50 @@
+import { styleText } from "node:util";
+function paint(color, text) {
+    // util.styleText handles NO_COLOR + TTY detection automatically.
+    return styleText(Array.isArray(color) ? color : [color], text);
+}
+const LETTERS = {
+    P: ["██████╗ ", "██╔══██╗", "██████╔╝", "██╔═══╝ ", "██║     "],
+    E: ["███████╗", "██╔════╝", "█████╗  ", "██╔══╝  ", "███████╗"],
+    R: ["██████╗ ", "██╔══██╗", "██████╔╝", "██╔══██╗", "██║  ██║"],
+    L: ["██╗     ", "██║     ", "██║     ", "██║     ", "███████╗"],
+    M: ["███╗   ███╗", "████╗ ████║", "██╔████╔██║", "██║╚██╔╝██║", "██║ ╚═╝ ██║"],
+};
+// Each banner letter is colored to match the requested branding:
+//   Peer = blue, LL = green, M = red.
+const SEGMENTS = [
+    { letters: "PEER", color: "blue" },
+    { letters: "LL", color: "green" },
+    { letters: "M", color: "red" },
+];
+/** Multi-line PeerLLM block banner. Returns the full multi-row string. */
+export function renderBanner() {
+    const rows = ["", "", "", "", ""];
+    for (const seg of SEGMENTS) {
+        for (const ch of seg.letters) {
+            const letter = LETTERS[ch];
+            if (!letter)
+                continue;
+            for (let r = 0; r < 5; r++) {
+                rows[r] += paint(seg.color, letter[r] ?? "");
+            }
+        }
+    }
+    return rows.join("\n");
+}
+/** Inline colored "PeerLLM" wordmark — for one-line headers and prompts. */
+export function renderBrand() {
+    return (paint(["blue", "bold"], "Peer") +
+        paint(["green", "bold"], "LL") +
+        paint(["red", "bold"], "M"));
+}
+/** Tagline shown under the banner in help / dashboard. */
+export function renderTagline(version) {
+    return (paint("dim", "  Serve decentralized AI compute from this machine  ") +
+        paint("gray", `· v${version}`));
+}
+/** Banner + tagline, separated by blank lines. Suitable for --help and dashboard. */
+export function renderHeader(version) {
+    return `\n${renderBanner()}\n\n${renderTagline(version)}\n`;
+}
+//# sourceMappingURL=banner.js.map

package/dist/cli/banner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.js","sourceRoot":"","sources":["../../src/cli/banner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC,SAAS,KAAK,CAAC,KAAsB,EAAE,IAAY;IACjD,iEAAiE;IACjE,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;AACjE,CAAC;AAED,MAAM,OAAO,GAA6B;IACxC,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC;IAC/D,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC;IAC/D,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC;IAC/D,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC;IAC/D,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,CAAC;CAC/E,CAAC;AAEF,iEAAiE;AACjE,sCAAsC;AACtC,MAAM,QAAQ,GAA6C;IACzD,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IAClC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;IACjC,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE;CAC/B,CAAC;AAEF,0EAA0E;AAC1E,MAAM,UAAU,YAAY;IAC1B,MAAM,IAAI,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAClC,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;YAC7B,MAAM,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;YAC3B,IAAI,CAAC,MAAM;gBAAE,SAAS;YACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3B,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,WAAW;IACzB,OAAO,CACL,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAC/B,KAAK,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;QAC9B,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,CAC5B,CAAC;AACJ,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,aAAa,CAAC,OAAe;IAC3C,OAAO,CACL,KAAK,CAAC,KAAK,EAAE,sDAAsD,CAAC;QACpE,KAAK,CAAC,MAAM,EAAE,MAAM,OAAO,EAAE,CAAC,CAC/B,CAAC;AACJ,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,OAAO,KAAK,YAAY,EAAE,OAAO,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC;AAC9D,CAAC"}

package/dist/cli/commands/dashboard.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function runDashboard(ipcEndpoint: string, modelsDir: string, intervalMs?: number): Promise<void>;
+export declare function makeDashboardCommand(): Command;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/cli/commands/dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/dashboard.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqepC,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,SAAO,GAChB,OAAO,CAAC,IAAI,CAAC,CA2Nf;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAU9C"}

package/dist/cli/commands/dashboard.js

@@ -0,0 +1,572 @@
+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, 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;
+    for (const c of cpus()) {
+        const t = c.times;
+        idle += t.idle;
+        total += t.user + t.nice + t.sys + t.idle + t.irq;
+    }
+    return { idle, total };
+}
+function statusBadge(s) {
+    switch (s) {
+        case "connected":
+            return paint(["green", "bold"], "● connected");
+        case "connecting":
+            return paint(["yellow", "bold"], "◐ connecting");
+        case "error":
+            return paint(["red", "bold"], "✗ error");
+        default:
+            return paint("dim", "○ disconnected");
+    }
+}
+function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const m = Math.floor(seconds / 60);
+    if (m < 60)
+        return `${m}m ${seconds % 60}s`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ${m % 60}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h`;
+}
+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;
+}
+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));
+}
+/** 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 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));
+    }
+    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("total up", paint("gray", s.host.totalUptime), 12));
+        lines.push(row("conversations", paint("cyan", s.host.conversations.toLocaleString())) +
+            paint("dim", "    ") +
+            row("avg resp", `${s.host.averageResponseMs.toFixed(0)} ms`, 12));
+    }
+    else {
+        lines.push(row("status", na("backend stats loading…")));
+    }
+    return lines;
+}
+function buildModelPanel(state) {
+    if (state.models?.loaded) {
+        const m = state.models.loaded;
+        return [
+            row("loaded", paint(["bold", "green"], m.modelName)),
+            row("gpu layers", String(m.gpuLayers)) +
+                paint("dim", "    ") +
+                row("active conv.", paint("cyan", String(m.activeContexts)), 16),
+        ];
+    }
+    return [
+        paint("dim", "(no model loaded — ") +
+            paint(["bold", "cyan"], "peerllm-host models download") +
+            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…")));
+    }
+    else if (state.gpu === null) {
+        lines.push(row("GPU", na("no GPU detected")));
+    }
+    else {
+        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`));
+        }
+    }
+    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");
+    write(renderPanel("Keys", undefined, [help.trimEnd()], width) + "\n");
+}
+function padSparkline(values, width) {
+    if (values.length >= width)
+        return values.slice(-width);
+    const pad = new Array(width - values.length).fill(0);
+    return pad.concat(values);
+}
+function keyHint(key, label) {
+    return paint(["cyan", "bold"], `[${key}]`) + paint("dim", ` ${label}  `);
+}
+function formatLog(l, maxWidth) {
+    const levelColors = {
+        debug: "gray",
+        info: "cyan",
+        warn: "yellow",
+        error: "red",
+    };
+    const color = levelColors[l.level] ?? "gray";
+    const ts = l.timestamp ? new Date(l.timestamp).toLocaleTimeString() : "";
+    const prefix = paint("dim", ts + " ") + paint(color, l.level.padEnd(5));
+    const visiblePrefixLen = ts.length + 1 + 5;
+    return prefix + " " + truncate(l.message, Math.max(0, maxWidth - visiblePrefixLen - 1));
+}
+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);
+        }
+        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();
+        }
+        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 {
+            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}`;
+        }
+        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));
+        }
+        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 { 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,
+                    };
+                }
+            }
+            catch {
+                // Non-fatal: GPU info is best-effort.
+            }
+        }
+        // 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;
+                    }
+                }
+            }
+            catch {
+                // Non-fatal.
+            }
+            // 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, ""))
+                    : [];
+            }
+            catch {
+                // Non-fatal.
+            }
+        }
+    };
+    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