@termix-ssh/plugin-sdk 1.0.20 → 1.0.21

package/dist/host-scripts/journal.js

@@ -0,0 +1,194 @@
+/** journalctl scripts and parsers. */
+import { isUnit } from "./systemd.js";
+import { HostScriptError, shellQuote as q, utf8Decode } from "./text.js";
+export const MAX_JOURNAL_LINES = 5000;
+const FIELDS = "MESSAGE,PRIORITY,_SYSTEMD_UNIT,SYSLOG_IDENTIFIER,_PID,_COMM";
+const RELATIVE_RE = /^-\d{1,5}(s|m|min|h|d|w)$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}(:\d{2})?)?$/;
+const WORDS = ["today", "yesterday", "now"];
+export function isJournalTime(value) {
+    return (RELATIVE_RE.test(value) || DATE_RE.test(value) || WORDS.includes(value));
+}
+function str(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+/** Reads journal filters from a query string. Anything odd throws a HostScriptError. */
+export function parseJournalQuery(input) {
+    const rawUnits = Array.isArray(input.unit) ? input.unit : [input.unit];
+    const units = rawUnits.map(str).filter(Boolean);
+    for (const unit of units) {
+        if (!isUnit(unit))
+            throw new HostScriptError("That is not a valid unit name");
+    }
+    if (units.length > 20)
+        throw new HostScriptError("Too many units");
+    const query = {
+        units,
+        lines: 300,
+        kernel: input.kernel === "true" || input.kernel === true,
+    };
+    const priority = str(input.priority);
+    if (priority) {
+        const value = Number(priority);
+        if (!Number.isInteger(value) || value < 0 || value > 7) {
+            throw new HostScriptError("priority must be 0 to 7");
+        }
+        query.priority = value;
+    }
+    for (const key of ["since", "until"]) {
+        const value = str(input[key]);
+        if (!value)
+            continue;
+        if (!isJournalTime(value))
+            throw new HostScriptError(`${key} is not a valid time`);
+        query[key] = value;
+    }
+    const boot = str(input.boot);
+    if (boot) {
+        if (!/^(-?\d{1,4}|[0-9a-f]{32})$/.test(boot))
+            throw new HostScriptError("boot is not valid");
+        query.boot = boot;
+    }
+    const grep = typeof input.grep === "string" ? input.grep : "";
+    if (grep) {
+        if (grep.length > 200 || /[\r\n\0]/.test(grep)) {
+            throw new HostScriptError("The search is too long");
+        }
+        query.grep = grep;
+    }
+    const lines = Number(str(input.lines) || 300);
+    if (Number.isFinite(lines) && lines > 0) {
+        query.lines = Math.min(MAX_JOURNAL_LINES, Math.round(lines));
+    }
+    return query;
+}
+/** journalctl arguments for a query, each one quoted. */
+export function journalArgs(query, options = {}) {
+    const args = ["journalctl", "--no-pager", "-q", "-o", "json"];
+    args.push(`--output-fields=${FIELDS}`);
+    if (options.follow)
+        args.push("-f");
+    if (query.lines)
+        args.push("-n", String(Math.floor(query.lines)));
+    for (const unit of query.units) {
+        if (!isUnit(unit))
+            throw new HostScriptError("That is not a valid unit name");
+        args.push("-u", q(unit));
+    }
+    if (query.kernel)
+        args.push("-k");
+    if (query.priority !== undefined)
+        args.push("-p", String(Math.floor(query.priority)));
+    if (query.since)
+        args.push("--since", q(query.since));
+    if (query.until)
+        args.push("--until", q(query.until));
+    if (query.boot)
+        args.push("-b", q(query.boot));
+    if (query.grep && options.useGrep !== false) {
+        args.push("--case-sensitive=false", "-g", q(query.grep));
+    }
+    return args.join(" ");
+}
+export function journalScript(query) {
+    // Older journalctl builds have no -g. Then the search runs on our side instead.
+    const noGrep = journalArgs({ ...query, lines: query.grep ? MAX_JOURNAL_LINES : query.lines }, { useGrep: false });
+    return `
+command -v journalctl >/dev/null 2>&1 || { echo "SCRIPT_ERR:This host has no journal"; exit 1; }
+${journalArgs(query)} 2>/tmp/termix-journal.$$
+RC=$?
+if [ $RC -ne 0 ] && grep -qi "pattern" /tmp/termix-journal.$$; then
+  rm -f /tmp/termix-journal.$$
+  echo "@@TERMIX_NOGREP@@"
+  ${noGrep}
+  exit 0
+fi
+cat /tmp/termix-journal.$$ >&2; rm -f /tmp/termix-journal.$$
+exit $RC
+`;
+}
+function messageOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return utf8Decode(value.filter((n) => typeof n === "number"));
+    }
+    return value == null ? "" : String(value);
+}
+/** One `journalctl -o json` line, or null when it is not an entry. */
+export function parseEntry(line) {
+    const text = line.trim();
+    if (!text.startsWith("{"))
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const micros = Number(raw.__REALTIME_TIMESTAMP);
+    const priority = Number(raw.PRIORITY);
+    return {
+        time: Number.isFinite(micros) ? Math.floor(micros / 1000) : 0,
+        priority: Number.isInteger(priority) ? priority : 6,
+        unit: messageOf(raw._SYSTEMD_UNIT),
+        ident: messageOf(raw.SYSLOG_IDENTIFIER ?? raw._COMM),
+        pid: messageOf(raw._PID),
+        message: messageOf(raw.MESSAGE),
+    };
+}
+export function parseJournal(output, query) {
+    const fallback = output.includes("@@TERMIX_NOGREP@@");
+    const body = fallback ? output.split("@@TERMIX_NOGREP@@")[1] : output;
+    let entries = body
+        .split("\n")
+        .map(parseEntry)
+        .filter((entry) => entry !== null);
+    if (fallback && query.grep) {
+        const needle = query.grep.toLowerCase();
+        entries = entries
+            .filter((entry) => entry.message.toLowerCase().includes(needle))
+            .slice(-query.lines);
+    }
+    return entries;
+}
+export const BOOTS_SCRIPT = `journalctl --list-boots --no-pager 2>/dev/null | tail -n 50; exit 0\n`;
+export function parseBoots(output) {
+    const boots = [];
+    for (const line of output.split("\n")) {
+        const match = /^\s*(-?\d+)\s+([0-9a-f]{32})\s+(\w{3} \S+ \S+ \S+)\s*.?\s*(\w{3} \S+ \S+ \S+)?/.exec(line);
+        if (!match)
+            continue;
+        boots.push({
+            offset: Number(match[1]),
+            id: match[2],
+            first: match[3],
+            last: match[4] ?? "",
+        });
+    }
+    return boots.reverse();
+}
+export const USAGE_SCRIPT = `journalctl --disk-usage 2>&1; exit 0\n`;
+export function parseUsage(output) {
+    return /take up (\S+)/.exec(output)?.[1] ?? "";
+}
+const SIZE_RE = /^\d{1,6}(K|M|G)$/;
+const AGE_RE = /^\d{1,4}(d|w|month|months|year|years)$/;
+export function vacuumScript(body) {
+    const size = str(body.size);
+    const time = str(body.time);
+    if (!size && !time)
+        throw new HostScriptError("Give a size or an age");
+    if (size && !SIZE_RE.test(size))
+        throw new HostScriptError("Size looks like 500M or 2G");
+    if (time && !AGE_RE.test(time))
+        throw new HostScriptError("Age looks like 7d or 4w");
+    const flags = [
+        size ? `--vacuum-size=${size}` : "",
+        time ? `--vacuum-time=${time}` : "",
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return `journalctl ${flags} 2>&1 || { echo "SCRIPT_ERR:journalctl vacuum failed"; exit 1; }\n`;
+}

package/dist/host-scripts/metrics.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Linux metrics: one awk sample of /proc for CPU, memory, load, network and
+ * processes, plus df parsing for disks.
+ */
+/** The live sample command. The page size never changes on a host, so pass it back once known. */
+export declare const liveCmd: (pageBytes?: number) => string;
+export interface LiveSample {
+    /** The admin minimum between samples; the client never polls faster. */
+    minIntervalS?: number;
+    cpu: number | null;
+    cpuMix?: {
+        user: number;
+        system: number;
+        iowait: number;
+        steal: number;
+    };
+    cores: Array<number | null>;
+    coreIds: string[];
+    memTotalKb: number;
+    memCachedKb: number;
+    memFreeKb: number;
+    memUsedKb: number;
+    swapTotalKb: number;
+    swapUsedKb: number;
+    load: [number, number, number];
+    net: Array<{
+        name: string;
+        rxBps: number | null;
+        txBps: number | null;
+    }>;
+    count: number;
+    running: number;
+    procs: Array<{
+        pid: number;
+        name: string;
+        cpu: number;
+        memKb: number;
+        state: string;
+        ppid: number;
+    }>;
+    /** Seconds since boot. */
+    uptime?: number;
+    /** Total bytes received and sent on every interface but lo, since boot. */
+    netTotals?: {
+        rx: number;
+        tx: number;
+    };
+}
+/** What the next call needs from this one. */
+export interface LivePrev {
+    at: number;
+    uptime: number;
+    pageBytes: number;
+    cpu: Map<string, {
+        total: number;
+        idle: number;
+    }>;
+    /** Aggregate user nice system idle iowait irq softirq steal ticks, for the breakdown. */
+    cpuRaw?: number[];
+    /** Keyed by pid:starttime so a reused pid never inherits another process's ticks. */
+    ticks: Map<string, number>;
+    net: Map<string, {
+        rx: number;
+        tx: number;
+    }>;
+}
+/** Total and idle ticks from a /proc/stat `cpu` line. */
+export declare function parseCpuLine(cpuLine: string): {
+    total: number;
+    idle: number;
+} | undefined;
+/** Parses `liveCmd()` output. Rates need the `next` of the previous call. */
+export declare function parseLive(output: string, prev: LivePrev | undefined, at?: number): {
+    sample: LiveSample;
+    next: LivePrev;
+};
+/** GNU df sizes in KiB, without the header. */
+export declare const DF_BYTES_COMMAND = "df -TkP | tail -n +2";
+/** GNU df sizes as short human text, without the header. */
+export declare const DF_HUMAN_COMMAND = "df -hT -P | tail -n +2";
+export interface DfRow {
+    filesystem: string;
+    type: string;
+    mount: string;
+    parts: string[];
+}
+export interface DiskFilesystem {
+    filesystem: string;
+    type: string;
+    mount: string;
+    percent: number | null;
+    usedHuman: string | null;
+    totalHuman: string | null;
+    availableHuman: string | null;
+    usedBytes: number | null;
+    totalBytes: number | null;
+    availableBytes: number | null;
+    label?: string;
+}
+export interface MonitoredMount {
+    path: string;
+    label?: string;
+}
+/**
+ * Parses `df -T -P` style output: Filesystem, Type, then the size columns,
+ * with Mounted-on last. Pseudo filesystems are left out.
+ */
+export declare function parseDfLines(output: string): DfRow[];
+/** The most used real filesystem in a `df -TkP` row set. */
+export declare function findWorstMountIndex(bytesRows: DfRow[]): {
+    index: number;
+    usedBytes: number;
+    totalBytes: number;
+};
+/**
+ * Merges `df -TkP` size rows (parts[2..4] in `blockSizeBytes` units) and
+ * `df -hT -P` human rows into one list. Human rows only supply the display
+ * text, matched by mount point so a mismatched row count can't shift them.
+ */
+export declare function buildFilesystemList(bytesRows: DfRow[], humanRows: DfRow[], blockSizeBytes?: number): DiskFilesystem[];
+/**
+ * The headline disk is the root filesystem. On macOS "/" is the small sealed
+ * system volume, so the data volume wins there. With no root mount the most
+ * used one is shown.
+ */
+export declare function selectPrimaryFilesystem(filesystems: DiskFilesystem[]): DiskFilesystem | null;
+/**
+ * Drops mounts by exact path ("/mnt/nas") or by filesystem type substring
+ * ("nfs" matches nfs and nfs4), so network shares can be hidden.
+ */
+export declare function filterExcludedFilesystems(filesystems: DiskFilesystem[], excludedMounts?: string[] | null): DiskFilesystem[];
+export declare function mergeMonitoredFilesystems(filesystems: DiskFilesystem[], monitored: MonitoredMount[], customFilesystems: Array<DiskFilesystem | null>): DiskFilesystem[];
+/** Host name, OS, kernel and arch in one exec, as key=value lines. */
+export declare const SYSTEM_INFO_COMMAND = "echo \"hostname=$(hostname 2>/dev/null || cat /etc/hostname 2>/dev/null)\"; echo \"os=$( . /etc/os-release 2>/dev/null; echo \"$PRETTY_NAME\")\"; echo \"kernel=$(uname -r 2>/dev/null)\"; echo \"arch=$(uname -m 2>/dev/null)\"";

package/dist/host-scripts/metrics.js

@@ -0,0 +1,320 @@
+/**
+ * Linux metrics: one awk sample of /proc for CPU, memory, load, network and
+ * processes, plus df parsing for disks.
+ */
+// One awk reads every /proc file itself, so a sample is one exec of awk instead
+// of a shell plus six tools. Output sections are split by @@; each process line
+// is pid, utime+stime ticks, rss pages, starttime, state, ppid, comm.
+const AWK = String.raw `BEGIN{f="/proc/stat";while((getline l<f)>0)if(l~/^cpu/)print l;close(f);print "@@";f="/proc/meminfo";while((getline l<f)>0)if(l~/^(MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree):/)print l;close(f);print "@@";f="/proc/loadavg";getline l<f;print l;close(f);f="/proc/uptime";getline l<f;print l;close(f);print "@@";f="/proc/net/dev";while((getline l<f)>0)print l;close(f);print "@@";print pg;print "@@";for(i=1;i<ARGC;i++){f=ARGV[i];if((getline s<f)>0){a=index(s,"(");if(a&&match(s,/\)[^)]*$/)){split(substr(s,RSTART+2),x," ");print substr(s,1,a-2)"	"(x[12]+x[13])"	"x[22]"\t"x[20]"\t"x[1]"	"x[2]"	"substr(s,a+1,RSTART-a-1)}}close(f)}}`;
+/** The live sample command. The page size never changes on a host, so pass it back once known. */
+export const liveCmd = (pageBytes) => "awk -v pg=" +
+    (pageBytes ?? '"$(getconf PAGESIZE)"') +
+    " '" +
+    AWK +
+    "' /proc/[0-9]*/stat";
+/** Total and idle ticks from a /proc/stat `cpu` line. */
+export function parseCpuLine(cpuLine) {
+    const parts = cpuLine.trim().split(/\s+/);
+    if (parts[0] !== "cpu")
+        return undefined;
+    const nums = parts
+        .slice(1)
+        .map((n) => Number(n))
+        .filter((n) => Number.isFinite(n));
+    if (nums.length < 4)
+        return undefined;
+    const idle = (nums[3] ?? 0) + (nums[4] ?? 0);
+    const total = nums.reduce((a, b) => a + b, 0);
+    return { total, idle };
+}
+const TOP_N = 60;
+/** Parses `liveCmd()` output. Rates need the `next` of the previous call. */
+export function parseLive(output, prev, at = Date.now()) {
+    const [cpuS = "", memS = "", loadS = "", netS = "", pageS = "", procS = ""] = output.split("@@\n");
+    // Only the first 8 fields: guest and guest_nice are already inside user and nice.
+    const cpu = new Map();
+    let cpuRaw;
+    for (const l of cpuS.split("\n")) {
+        const name = l.split(/\s+/)[0];
+        if (!name.startsWith("cpu"))
+            continue;
+        if (name === "cpu")
+            cpuRaw = l.split(/\s+/).slice(1, 9).map(Number);
+        const c = parseCpuLine(l
+            .replace(/^cpu\d*/, "cpu")
+            .split(/\s+/)
+            .slice(0, 9)
+            .join(" "));
+        if (c)
+            cpu.set(name, c);
+    }
+    // Matched by name, so an offline core does not shift the ones after it.
+    const pct = (name) => {
+        const p = prev?.cpu.get(name);
+        const c = cpu.get(name);
+        if (!p || !c || c.total <= p.total)
+            return null;
+        const used = c.total - p.total - (c.idle - p.idle);
+        return Math.max(0, Math.min(100, (used / (c.total - p.total)) * 100));
+    };
+    // Where the busy time went since the last sample, as percent of all ticks.
+    let cpuMix;
+    if (prev?.cpuRaw && cpuRaw && cpuRaw.length === 8) {
+        const d = cpuRaw.map((v, i) => v - (prev.cpuRaw?.[i] ?? 0));
+        const total = d.reduce((a, b) => a + b, 0);
+        if (total > 0 && d.every((v) => v >= 0)) {
+            const p = (n) => (n / total) * 100;
+            cpuMix = {
+                user: p(d[0] + d[1]),
+                system: p(d[2] + d[5] + d[6]),
+                iowait: p(d[4]),
+                steal: p(d[7]),
+            };
+        }
+    }
+    const mem = {};
+    for (const l of memS.split("\n")) {
+        const m = l.match(/^(\w+):\s+(\d+)/);
+        if (m)
+            mem[m[1]] = Number(m[2]);
+    }
+    const [la = "", up = ""] = loadS.trim().split("\n");
+    const laParts = la.split(/\s+/).map(Number);
+    const uptime = Number(up.split(/\s+/)[0]) || 0;
+    const nets = new Map();
+    for (const l of netS.split("\n")) {
+        const [name, rest] = l.split(":");
+        if (!rest || name.trim() === "lo")
+            continue;
+        const f = rest.trim().split(/\s+/);
+        nets.set(name.trim(), { rx: Number(f[0]) || 0, tx: Number(f[8]) || 0 });
+    }
+    // A reboot makes uptime go backwards, so rates start again.
+    const dt = prev && uptime > prev.uptime ? uptime - prev.uptime : 0;
+    const rate = (now, before) => dt > 0 && before !== undefined && now >= before
+        ? (now - before) / dt
+        : null;
+    const pageBytes = Number(pageS.trim()) || prev?.pageBytes || 4096;
+    const pageKb = pageBytes / 1024;
+    const aggDelta = prev && cpu.has("cpu") && prev.cpu.has("cpu")
+        ? cpu.get("cpu").total - prev.cpu.get("cpu").total
+        : 0;
+    const cores = [...cpu.keys()].filter((k) => k !== "cpu");
+    const ncpu = Math.max(1, cores.length);
+    const ticks = new Map();
+    const procs = [];
+    for (const l of procS.split("\n")) {
+        const [pid, t, rss, start, state, ppid, ...rest] = l.split("\t");
+        const name = rest.join("\t");
+        if (!name)
+            continue;
+        const key = pid + ":" + start;
+        const tk = Number(t) || 0;
+        ticks.set(key, tk);
+        const before = prev?.ticks.get(key);
+        procs.push({
+            pid: Number(pid),
+            name,
+            cpu: before !== undefined && aggDelta > 0 && tk >= before
+                ? ((tk - before) / aggDelta) * ncpu * 100
+                : 0,
+            memKb: (Number(rss) || 0) * pageKb,
+            state: state || "?",
+            ppid: Number(ppid) || 0,
+        });
+    }
+    procs.sort((a, b) => b.cpu - a.cpu || b.memKb - a.memKb);
+    // Awk exits 0 when /proc is missing (macOS, restricted containers); that is not a sample.
+    if (!cpu.has("cpu") || !mem.MemTotal || !uptime) {
+        throw new Error("live sample unavailable: /proc data missing");
+    }
+    const memTotalKb = mem.MemTotal;
+    const swapTotalKb = mem.SwapTotal ?? 0;
+    let rxTotal = 0;
+    let txTotal = 0;
+    for (const c of nets.values()) {
+        rxTotal += c.rx;
+        txTotal += c.tx;
+    }
+    return {
+        sample: {
+            cpu: pct("cpu"),
+            cores: cores.map(pct),
+            coreIds: cores.map((k) => k.slice(3)),
+            cpuMix,
+            memTotalKb,
+            memCachedKb: (mem.Buffers ?? 0) + (mem.Cached ?? 0),
+            memFreeKb: mem.MemFree ?? 0,
+            memUsedKb: memTotalKb - (mem.MemAvailable ?? 0),
+            swapTotalKb,
+            swapUsedKb: swapTotalKb - (mem.SwapFree ?? 0),
+            load: [laParts[0] || 0, laParts[1] || 0, laParts[2] || 0],
+            net: [...nets].map(([name, c]) => ({
+                name,
+                rxBps: rate(c.rx, prev?.net.get(name)?.rx),
+                txBps: rate(c.tx, prev?.net.get(name)?.tx),
+            })),
+            count: procs.length,
+            running: procs.filter((p) => p.state === "R").length,
+            procs: procs.slice(0, TOP_N),
+            uptime,
+            netTotals: { rx: rxTotal, tx: txTotal },
+        },
+        next: { at, uptime, pageBytes, cpu, cpuRaw, ticks, net: nets },
+    };
+}
+// Disks
+const DARWIN_DATA_MOUNT = "/System/Volumes/Data";
+const PSEUDO_FS_RE = /^(tmpfs|devtmpfs|overlay|udev|none|shm|squashfs|efivarfs)$/;
+/** GNU df sizes in KiB, without the header. */
+export const DF_BYTES_COMMAND = "df -TkP | tail -n +2";
+/** GNU df sizes as short human text, without the header. */
+export const DF_HUMAN_COMMAND = "df -hT -P | tail -n +2";
+function toFixedNum(n, digits = 2) {
+    if (typeof n !== "number" || !Number.isFinite(n))
+        return null;
+    return Number(n.toFixed(digits));
+}
+/**
+ * Parses `df -T -P` style output: Filesystem, Type, then the size columns,
+ * with Mounted-on last. Pseudo filesystems are left out.
+ */
+export function parseDfLines(output) {
+    return output
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const parts = line.split(/\s+/);
+        return {
+            filesystem: parts[0] || "",
+            type: parts[1] || "",
+            mount: parts[6] || "",
+            parts,
+        };
+    })
+        .filter((row) => row.parts.length >= 7 && !PSEUDO_FS_RE.test(row.type));
+}
+/** The most used real filesystem in a `df -TkP` row set. */
+export function findWorstMountIndex(bytesRows) {
+    let worstIndex = -1;
+    let worstUsedBytes = -1;
+    let worstTotalBytes = 0;
+    bytesRows.forEach((row, index) => {
+        const totalBytes = Number(row.parts[2]);
+        const usedBytes = Number(row.parts[3]);
+        if (!Number.isFinite(totalBytes) ||
+            !Number.isFinite(usedBytes) ||
+            totalBytes <= 0) {
+            return;
+        }
+        const usedRatio = usedBytes / totalBytes;
+        const worstRatio = worstTotalBytes > 0 ? worstUsedBytes / worstTotalBytes : -1;
+        if (usedRatio > worstRatio) {
+            worstIndex = index;
+            worstUsedBytes = usedBytes;
+            worstTotalBytes = totalBytes;
+        }
+    });
+    return {
+        index: worstIndex,
+        usedBytes: worstUsedBytes,
+        totalBytes: worstTotalBytes,
+    };
+}
+/**
+ * Merges `df -TkP` size rows (parts[2..4] in `blockSizeBytes` units) and
+ * `df -hT -P` human rows into one list. Human rows only supply the display
+ * text, matched by mount point so a mismatched row count can't shift them.
+ */
+export function buildFilesystemList(bytesRows, humanRows, blockSizeBytes = 1) {
+    const aligned = humanRows.length === bytesRows.length;
+    return bytesRows
+        .map((row, index) => {
+        const totalBytes = Number(row.parts[2]) * blockSizeBytes;
+        const usedBytes = Number(row.parts[3]) * blockSizeBytes;
+        const availableBytes = Number(row.parts[4]) * blockSizeBytes;
+        if (!Number.isFinite(totalBytes) || totalBytes <= 0)
+            return null;
+        const humanRow = aligned
+            ? humanRows[index]
+            : humanRows.find((h) => h.mount === row.mount);
+        const percent = Number.isFinite(usedBytes)
+            ? Math.max(0, Math.min(100, (usedBytes / totalBytes) * 100))
+            : null;
+        return {
+            filesystem: row.filesystem,
+            type: row.type,
+            mount: row.mount,
+            percent: toFixedNum(percent, 0),
+            usedHuman: humanRow?.parts[3] || null,
+            totalHuman: humanRow?.parts[2] || null,
+            availableHuman: humanRow?.parts[4] || null,
+            usedBytes: Number.isFinite(usedBytes) ? usedBytes : null,
+            totalBytes,
+            availableBytes: Number.isFinite(availableBytes) ? availableBytes : null,
+        };
+    })
+        .filter((fs) => fs !== null);
+}
+/**
+ * The headline disk is the root filesystem. On macOS "/" is the small sealed
+ * system volume, so the data volume wins there. With no root mount the most
+ * used one is shown.
+ */
+export function selectPrimaryFilesystem(filesystems) {
+    if (filesystems.length === 0)
+        return null;
+    const root = filesystems.find((fs) => fs.mount === DARWIN_DATA_MOUNT) ??
+        filesystems.find((fs) => fs.mount === "/");
+    if (root)
+        return root;
+    let best = filesystems[0];
+    for (const fs of filesystems) {
+        const ratio = (fs.usedBytes ?? 0) / (fs.totalBytes || 1);
+        const bestRatio = (best.usedBytes ?? 0) / (best.totalBytes || 1);
+        if (ratio > bestRatio)
+            best = fs;
+    }
+    return best;
+}
+/**
+ * Drops mounts by exact path ("/mnt/nas") or by filesystem type substring
+ * ("nfs" matches nfs and nfs4), so network shares can be hidden.
+ */
+export function filterExcludedFilesystems(filesystems, excludedMounts) {
+    if (!excludedMounts || excludedMounts.length === 0)
+        return filesystems;
+    const normalized = excludedMounts
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return filesystems;
+    return filesystems.filter((fs) => {
+        const mount = fs.mount.toLowerCase();
+        const type = fs.type.toLowerCase();
+        return !normalized.some((entry) => mount === entry || (type && type.includes(entry)));
+    });
+}
+export function mergeMonitoredFilesystems(filesystems, monitored, customFilesystems) {
+    const result = [...filesystems];
+    monitored.forEach((entry, index) => {
+        const path = entry.path.trim();
+        const custom = customFilesystems[index];
+        if (!path || !custom)
+            return;
+        const existing = result.find((fs) => fs.mount === path);
+        if (existing) {
+            existing.label = entry.label?.trim() || undefined;
+            return;
+        }
+        result.push({
+            ...custom,
+            mount: path,
+            label: entry.label?.trim() || undefined,
+        });
+    });
+    return result;
+}
+/** Host name, OS, kernel and arch in one exec, as key=value lines. */
+export const SYSTEM_INFO_COMMAND = `echo "hostname=$(hostname 2>/dev/null || cat /etc/hostname 2>/dev/null)"; echo "os=$( . /etc/os-release 2>/dev/null; echo "$PRETTY_NAME")"; echo "kernel=$(uname -r 2>/dev/null)"; echo "arch=$(uname -m 2>/dev/null)"`;

package/dist/host-scripts/openrc.d.ts

@@ -0,0 +1,6 @@
+/** OpenRC scripts, with states mapped onto the words systemd uses. */
+import { type UnitAction, type UnitSummary } from "./systemd.js";
+export declare const OPENRC_LIST_SCRIPT = "\nrc-status --servicelist 2>/dev/null\necho \"@@TERMIX_RUNLEVELS@@\"\nrc-update show -v 2>/dev/null\nexit 0\n";
+export declare function parseOpenRcList(output: string): UnitSummary[];
+export declare function openRcActionScript(name: string, action: UnitAction): string;
+export declare function openRcStatusScript(name: string): string;