@silentjma/n8n-nodes-unraid 0.0.0-stage → 0.1.1

package/dist/lib/analysis.js

@@ -0,0 +1,398 @@
+"use strict";
+// Pure analysis helpers: turn Unraid API snapshots and log lines into findings with suggested next steps.
+// No n8n imports so the rules can be unit-tested and reused by both nodes.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_HEALTH_OPTIONS = exports.LOG_RULE_NAMES = void 0;
+exports.severityAtLeast = severityAtLeast;
+exports.sortFindings = sortFindings;
+exports.containerName = containerName;
+exports.classifyLogLine = classifyLogLine;
+exports.analyzeHealth = analyzeHealth;
+exports.summarizeFindings = summarizeFindings;
+const SEVERITY_RANK = { info: 0, warning: 1, critical: 2 };
+function severityAtLeast(severity, minimum) {
+    return SEVERITY_RANK[severity] >= SEVERITY_RANK[minimum];
+}
+function sortFindings(findings) {
+    return [...findings].sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity] || a.key.localeCompare(b.key));
+}
+/** Docker names come back as ["/plex"]; the first one without the slash is what the WebGUI shows. */
+function containerName(container) {
+    const first = container.names?.find((n) => n) ?? container.id ?? '';
+    return first.replace(/^\//, '');
+}
+const num = (value) => {
+    if (value === null || value === undefined || value === '')
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+};
+const pct = (used, total) => {
+    const u = num(used);
+    const t = num(total);
+    return u !== undefined && t ? Math.round((u / t) * 1000) / 10 : undefined;
+};
+const LOG_RULES = [
+    {
+        rule: 'disk-io-error',
+        pattern: /\b(I\/O error|blk_update_request|critical medium error|Buffer I\/O error|md: disk\d+ (read|write) error|ata\d+(\.\d+)?: .*(failed command|exception|hard resetting link|link is slow|SError)|UNC\b|end_request)/i,
+        severity: 'critical',
+        category: 'disk',
+        nextSteps: [
+            'Identify the disk from the ataX / sdX / diskN in the line (Tools › System Devices or Main tab).',
+            'Run a SMART extended test on that disk and check reallocated / pending sector counts.',
+            'Reseat or replace the SATA/SAS cable and power cable; link resets are usually cabling.',
+            'If the disk is disabled in the array, do not write to it; rebuild from parity once the cause is fixed.',
+        ],
+    },
+    {
+        rule: 'filesystem-corruption',
+        pattern: /\b(BTRFS (error|critical|warning)|XFS \(.*\): (Corruption|Metadata|Internal error|log I\/O error)|EXT4-fs error|ZFS.*(error|faulted|degraded)|checksum error|csum failed|parent transid verify failed)/i,
+        severity: 'critical',
+        category: 'filesystem',
+        nextSteps: [
+            'Note the affected device (e.g. md1p1, nvme0n1p1) and stop writing to it.',
+            'Start the array in maintenance mode and run a filesystem check (Main › disk › Check Filesystem Status).',
+            'For BTRFS pools run a scrub; for ZFS run "zpool status -v" and a scrub.',
+            'Run memtest if checksum errors keep appearing on several devices (bad RAM causes them).',
+        ],
+    },
+    {
+        rule: 'out-of-memory',
+        pattern: /\b(Out of memory|oom-kill|oom_reaper|invoked oom-killer|Killed process \d+)/i,
+        severity: 'critical',
+        category: 'memory',
+        nextSteps: [
+            'Find the killed process / container in the line and set a memory limit on it (--memory=… in Extra Parameters).',
+            'Check for containers writing to RAM (paths mapped to /tmp or not to /mnt/user) filling the rootfs.',
+            'Review VM memory allocations against total RAM.',
+        ],
+    },
+    {
+        rule: 'hardware-mce',
+        pattern: /\b(Machine check|mce: \[Hardware Error\]|Hardware Error|EDAC .*(error|CE|UE)|PCIe Bus Error|AER: (Corrected|Uncorrected))/i,
+        severity: 'critical',
+        category: 'hardware',
+        nextSteps: [
+            'Install mcelog (NerdTools / Nerd Pack) to decode the machine check, or check the BIOS event log.',
+            'Run memtest86 for at least one full pass.',
+            'Update the BIOS and check CPU / VRM temperatures and PSU health.',
+        ],
+    },
+    {
+        rule: 'kernel-trace',
+        pattern: /\b(Call Trace|kernel BUG|general protection fault|Kernel panic|BUG: unable to handle|watchdog: BUG: soft lockup|rcu_sched self-detected stall|macvlan.*(call trace|broadcast))/i,
+        severity: 'critical',
+        category: 'kernel',
+        nextSteps: [
+            'Download diagnostics (Tools › Diagnostics) while the trace is still in the syslog.',
+            'If the trace mentions macvlan, switch Docker custom networks to ipvlan (Settings › Docker).',
+            'Check that Unraid and plugins are up to date; post the diagnostics on the Unraid forum if it repeats.',
+        ],
+    },
+    {
+        rule: 'disk-space',
+        pattern: /\b(No space left on device|disk quota exceeded|cache.*(full|is full)|docker\.img.*(full|100%)|ENOSPC)/i,
+        severity: 'critical',
+        category: 'storage',
+        nextSteps: [
+            'Check docker.img / cache / array usage on the Main tab.',
+            'Run the Mover if the cache is full, and set a minimum free space on shares.',
+            'Find containers writing inside docker.img (Docker › Container Size) and map their paths to appdata.',
+        ],
+    },
+    {
+        rule: 'parity-errors',
+        pattern: /\b(parity (check|sync).*(error|incorrect)|sync errors?|Parity.*finished.*\d+ errors)/i,
+        severity: 'warning',
+        category: 'parity',
+        nextSteps: [
+            'If this follows an unclean shutdown, run a correcting parity check.',
+            'If errors repeat on consecutive checks, run memtest and check disk SMART data.',
+        ],
+    },
+    {
+        rule: 'auth-failure',
+        pattern: /\b(authentication failure|Failed password|Invalid user|Failed login|webGUI: Unsuccessful login|refused connect|Bad protocol version)/i,
+        severity: 'warning',
+        category: 'security',
+        nextSteps: [
+            'Check the source IP: if it is not on your LAN, the server is exposed to the internet.',
+            'Disable port forwarding for SSH / WebGUI; use WireGuard, Tailscale or Unraid Connect remote access instead.',
+            'Set a strong root password and consider disabling SSH password login.',
+        ],
+    },
+    {
+        rule: 'segfault',
+        pattern: /\b(segfault at|traps: .* (general protection|trap divide error)|core dumped)/i,
+        severity: 'warning',
+        category: 'application',
+        nextSteps: [
+            'Identify the process; if it belongs to a container, restart it and check for an image update.',
+            'Repeated segfaults across processes can point to bad RAM; run memtest.',
+        ],
+    },
+    {
+        rule: 'docker-error',
+        pattern: /\b(dockerd|containerd|docker)\b.*\b(error|failed|cannot|unable)\b/i,
+        severity: 'warning',
+        category: 'docker',
+        nextSteps: [
+            'Check the named container\'s own log (Docker › container › Logs) for the root cause.',
+            'Restart the container; if Docker itself fails, check that docker.img is not full or corrupted.',
+        ],
+    },
+    {
+        rule: 'network',
+        pattern: /\b(Link is Down|NIC Link is Down|link down|carrier lost|bond\d+: .*(link status definitely down|No active)|duplicate address detected|DHCP.*(failed|timeout))/i,
+        severity: 'warning',
+        category: 'network',
+        nextSteps: [
+            'Check the network cable, switch port and NIC; note which interface went down.',
+            'If it flaps, check for duplicate IPs and bonding / bridging settings (Settings › Network).',
+        ],
+    },
+    {
+        rule: 'temperature',
+        pattern: /\b(temperature above threshold|cpu clock throttled|Package temperature|overheat|thermal)\b/i,
+        severity: 'warning',
+        category: 'temperature',
+        nextSteps: [
+            'Check fans, airflow and dust; confirm CPU cooler mounting.',
+            'Review fan curves (Dynamix Auto Fan Control) and disk temperature thresholds.',
+        ],
+    },
+    {
+        rule: 'app-fatal',
+        pattern: /\b(fatal( error)?:|panic:|unhandled exception|uncaught exception|traceback \(most recent call last\)|database disk image is malformed|database is locked|corrupt(ed|ion)\b)/i,
+        severity: 'warning',
+        category: 'application',
+        nextSteps: [
+            'Read the lines before this one in the container log for the root cause.',
+            'For database corruption: stop the container, back up its appdata, then repair or restore the database.',
+            'Check the appdata path is on a healthy disk / pool and not full.',
+        ],
+    },
+    {
+        rule: 'generic-error',
+        pattern: /\b(error|failed|failure|fatal|critical|panic|denied)\b/i,
+        severity: 'info',
+        category: 'general',
+        nextSteps: ['Look at the surrounding log lines for context; repeated occurrences deserve a closer look.'],
+    },
+];
+const BENIGN = [
+    /ACPI (Error|Warning|BIOS Error).*(AE_NOT_FOUND|AE_ALREADY_EXISTS)/i, // Common BIOS table noise.
+    /\bcorrected error\b.*\bPCIe\b.*\bReceiver Error\b/i,
+    /\b(error|failed)=0\b/i,
+];
+function classifyLogLine(line) {
+    if (!line.trim() || BENIGN.some((p) => p.test(line)))
+        return null;
+    for (const r of LOG_RULES) {
+        if (r.pattern.test(line))
+            return { severity: r.severity, category: r.category, rule: r.rule, nextSteps: r.nextSteps };
+    }
+    return null;
+}
+exports.LOG_RULE_NAMES = LOG_RULES.map((r) => r.rule);
+exports.DEFAULT_HEALTH_OPTIONS = {
+    diskUsageWarningPercent: 90,
+    diskUsageCriticalPercent: 97,
+    defaultTempWarning: 45,
+    defaultTempCritical: 55,
+    defaultSsdTempWarning: 60,
+    defaultSsdTempCritical: 70,
+    memoryWarningPercent: 90,
+    cpuWarningPercent: 95,
+    reportStoppedAutostartContainers: true,
+    reportContainerUpdates: true,
+    includeUnraidNotifications: true,
+    ignoreContainers: [],
+};
+const diskLabel = (d) => d.name || d.device || d.id;
+function analyzeHealth(snapshot, options = {}) {
+    const o = { ...exports.DEFAULT_HEALTH_OPTIONS, ...options };
+    const findings = [];
+    const array = snapshot.array;
+    if (array?.state && array.state !== 'STARTED') {
+        findings.push({
+            key: `array:state:${array.state}`,
+            severity: 'critical',
+            category: 'array',
+            title: `Array is ${array.state}`,
+            details: `The Unraid array is in state ${array.state}; shares, Docker and VMs on the array are unavailable.`,
+            nextSteps: array.state === 'STOPPED'
+                ? ['If this was not intentional, check the Main tab for missing disks before starting the array.', 'Start the array once all disks are present.']
+                : ['Open the Main tab: the state names the problem (missing / wrong / too small disk).', 'Do not start the array or format anything until the disk assignment is correct.'],
+            suggestedAction: array.state === 'STOPPED' ? { resource: 'array', operation: 'start' } : undefined,
+        });
+    }
+    const arrayDisks = [...(array?.parities ?? []), ...(array?.disks ?? []), ...(array?.caches ?? [])];
+    for (const d of arrayDisks) {
+        const label = diskLabel(d);
+        if (d.status && !['DISK_OK', 'DISK_NP'].includes(d.status)) {
+            findings.push({
+                key: `disk:status:${d.id}:${d.status}`,
+                severity: 'critical',
+                category: 'disk',
+                title: `${label} is ${d.status.replace(/^DISK_/, '').toLowerCase()}`,
+                details: `${d.type ?? 'Disk'} ${label} (${d.device ?? 'no device'}) reports status ${d.status}.`,
+                nextSteps: d.status.includes('DSBL') || d.status === 'DISK_INVALID'
+                    ? [
+                        'The disk is disabled (red X) and is being emulated from parity. Do not write heavily to the array.',
+                        'Check SMART data and cabling, then download diagnostics before changing anything.',
+                        'Rebuild onto the same disk (if healthy) or a replacement: stop array, unassign, start, stop, reassign, start.',
+                    ]
+                    : ['Check the Main tab for the disk assignment and whether the disk is physically connected.', 'Download diagnostics before reassigning disks.'],
+            });
+        }
+        const errors = num(d.numErrors);
+        if (errors && errors > 0) {
+            findings.push({
+                key: `disk:errors:${d.id}`,
+                severity: 'warning',
+                category: 'disk',
+                title: `${label} has ${errors} read/write error(s)`,
+                details: `The array driver recorded ${errors} unrecoverable I/O errors on ${label} since the counters were last cleared.`,
+                nextSteps: ['Run a SMART extended test on the disk.', 'Check / replace the SATA and power cables.', 'Clear the statistics after fixing so new errors stand out.'],
+            });
+        }
+        if (d.temp !== null && d.temp !== undefined) {
+            const ssd = d.rotational === false;
+            const crit = d.critical ?? (ssd ? o.defaultSsdTempCritical : o.defaultTempCritical);
+            const warn = d.warning ?? (ssd ? o.defaultSsdTempWarning : o.defaultTempWarning);
+            const level = d.temp >= crit ? 'critical' : d.temp >= warn ? 'warning' : null;
+            if (level) {
+                findings.push({
+                    key: `disk:temp:${d.id}:${level}`,
+                    severity: level,
+                    category: 'temperature',
+                    title: `${label} is at ${d.temp}°C`,
+                    details: `${label} temperature ${d.temp}°C exceeds the ${level} threshold (${level === 'critical' ? crit : warn}°C).`,
+                    nextSteps: ['Check case fans and airflow over the drive cage.', 'Pause a running parity check if it is driving the temperature up.', 'Review fan control and per-disk thresholds (Settings › Disk Settings).'],
+                });
+            }
+        }
+        const usage = pct(d.fsUsed, d.fsSize);
+        if (usage !== undefined && usage >= o.diskUsageWarningPercent) {
+            const level = usage >= o.diskUsageCriticalPercent ? 'critical' : 'warning';
+            findings.push({
+                key: `disk:usage:${d.id}:${level}`,
+                severity: level,
+                category: 'storage',
+                title: `${label} is ${usage}% full`,
+                details: `Filesystem on ${label} is ${usage}% used.`,
+                nextSteps: d.type === 'CACHE'
+                    ? ['Run the Mover (Main › Move) and check share cache settings.', 'Set a minimum free space on the pool so writes overflow to the array.']
+                    : ['Set a minimum free space on shares and check the split level / allocation method.', 'Plan a new or larger disk if all data disks are filling up.'],
+            });
+        }
+    }
+    const parity = array?.parityCheckStatus;
+    if (parity?.status === 'FAILED') {
+        findings.push({
+            key: 'parity:failed',
+            severity: 'critical',
+            category: 'parity',
+            title: 'Last parity check failed',
+            details: 'The most recent parity check did not finish successfully.',
+            nextSteps: ['Check the syslog around the end of the check for disk errors.', 'Run the check again once disk issues are fixed.'],
+        });
+    }
+    else if (parity && (parity.errors ?? 0) > 0 && !parity.running) {
+        findings.push({
+            key: `parity:errors:${parity.errors}`,
+            severity: 'warning',
+            category: 'parity',
+            title: `Parity check found ${parity.errors} error(s)`,
+            details: `The last parity check (${parity.status}) reported ${parity.errors} sync errors.`,
+            nextSteps: ['After an unclean shutdown, run a correcting check once.', 'If errors return on the next non-correcting check, run memtest and inspect SMART data.'],
+        });
+    }
+    for (const d of snapshot.disks ?? []) {
+        if (d.smartStatus && d.smartStatus !== 'OK' && d.smartStatus !== 'UNKNOWN') {
+            findings.push({
+                key: `smart:${d.id}:${d.smartStatus}`,
+                severity: 'critical',
+                category: 'disk',
+                title: `SMART status of ${d.name || d.device} is ${d.smartStatus}`,
+                details: `Physical disk ${d.device} reports SMART status ${d.smartStatus}.`,
+                nextSteps: ['Back up anything on this disk that is not protected by parity.', 'Order a replacement and run an extended SMART test to confirm.'],
+            });
+        }
+    }
+    const ignored = new Set(o.ignoreContainers.map((n) => n.trim().toLowerCase()).filter(Boolean));
+    for (const c of snapshot.docker?.containers ?? []) {
+        const name = containerName(c);
+        if (ignored.has(name.toLowerCase()))
+            continue;
+        if (o.reportStoppedAutostartContainers && c.autoStart && c.state && c.state !== 'RUNNING') {
+            findings.push({
+                key: `container:down:${name}`,
+                severity: 'warning',
+                category: 'docker',
+                title: `Container ${name} is ${c.state.toLowerCase()}`,
+                details: `${name} (${c.image}) has autostart enabled but is ${c.state} — ${c.status ?? ''}`.trim(),
+                nextSteps: [
+                    `Read the last log lines of ${name} for the exit reason.`,
+                    `Restart ${name}; if it exits again, check its appdata paths and recent image changes.`,
+                ],
+                suggestedAction: { resource: 'dockerContainer', operation: c.state === 'PAUSED' ? 'unpause' : 'start', id: c.id, name },
+            });
+        }
+        if (o.reportContainerUpdates && c.isUpdateAvailable) {
+            findings.push({
+                key: `container:update:${name}`,
+                severity: 'info',
+                category: 'docker-update',
+                title: `Update available for ${name}`,
+                details: `A newer image is available for ${name} (${c.image}).`,
+                nextSteps: [`Read the release notes of ${c.image} for breaking changes.`, `Update ${name} (back up its appdata first for databases).`],
+                suggestedAction: { resource: 'dockerContainer', operation: 'update', id: c.id, name },
+            });
+        }
+    }
+    if (o.includeUnraidNotifications) {
+        for (const n of snapshot.notifications?.warningsAndAlerts ?? []) {
+            findings.push({
+                key: `notification:${n.id}`,
+                severity: n.importance === 'ALERT' ? 'critical' : 'warning',
+                category: 'unraid-notification',
+                title: n.subject || n.title || 'Unraid notification',
+                details: [n.title, n.description].filter(Boolean).join(' — '),
+                nextSteps: ['Open the notification in the Unraid WebGUI and archive it once handled.'],
+            });
+        }
+    }
+    const mem = snapshot.metrics?.memory?.percentTotal;
+    if (mem !== undefined && mem >= o.memoryWarningPercent) {
+        findings.push({
+            key: 'memory:high',
+            severity: 'warning',
+            category: 'memory',
+            title: `Memory usage at ${Math.round(mem)}%`,
+            details: `RAM usage is ${Math.round(mem)}% (swap ${Math.round(snapshot.metrics?.memory?.percentSwapTotal ?? 0)}%).`,
+            nextSteps: ['Find the heaviest containers (Docker › Advanced view / ctop).', 'Set memory limits on containers and check VM allocations.'],
+        });
+    }
+    const cpu = snapshot.metrics?.cpu?.percentTotal;
+    if (cpu !== undefined && cpu >= o.cpuWarningPercent) {
+        findings.push({
+            key: 'cpu:high',
+            severity: 'info',
+            category: 'cpu',
+            title: `CPU usage at ${Math.round(cpu)}%`,
+            details: `Total CPU usage is ${Math.round(cpu)}% at the time of the check.`,
+            nextSteps: ['Check whether a parity check, mover, transcode or backup is running.', 'Pin heavy containers / VMs to specific cores if this is persistent.'],
+        });
+    }
+    return sortFindings(findings);
+}
+function summarizeFindings(findings) {
+    const counts = { critical: 0, warning: 0, info: 0 };
+    for (const f of findings)
+        counts[f.severity]++;
+    const status = counts.critical ? 'critical' : counts.warning ? 'warning' : counts.info ? 'info' : 'ok';
+    return { status, counts, total: findings.length };
+}

package/dist/lib/client.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unraidGraphql = unraidGraphql;
+const n8n_workflow_1 = require("n8n-workflow");
+async function unraidGraphql(query, variables = {}) {
+    const credentials = await this.getCredentials('unraidApi');
+    const baseUrl = String(credentials.serverUrl ?? '').replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(baseUrl)) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid Unraid server URL "${baseUrl}". It must start with http:// or https://.`);
+    }
+    let response;
+    try {
+        response = (await this.helpers.httpRequestWithAuthentication.call(this, 'unraidApi', {
+            method: 'POST',
+            url: `${baseUrl}/graphql`,
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: { query, variables },
+            json: true,
+            skipSslCertificateValidation: credentials.allowUnauthorizedCerts === true,
+        }));
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: 'Unraid API request failed',
+            description: baseUrl.startsWith('http://')
+                ? 'If SSL is enabled on Unraid, http:// is redirected to https:// and the request body is lost. Use the https:// URL (with Ignore SSL Issues for the self-signed certificate).'
+                : 'Check the server URL, that the API is enabled (Unraid 7.2+ or the Unraid Connect plugin) and that the API key is valid.',
+        });
+    }
+    if (response?.errors?.length) {
+        const message = response.errors.map((e) => (e.path?.length ? `${e.path.join('.')}: ${e.message}` : e.message)).join('; ');
+        const forbidden = response.errors.some((e) => e.extensions?.code === 'FORBIDDEN' || /forbidden|permission/i.test(e.message));
+        const unauthenticated = response.errors.some((e) => e.extensions?.code === 'UNAUTHENTICATED');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unraid API error: ${message}`, {
+            description: unauthenticated
+                ? 'The API key is invalid or was revoked. Create a new one in Settings › Management Access › API Keys and update the Unraid API credential.'
+                : forbidden
+                    ? 'The API key lacks the permission for this operation. Give it the admin role, or the matching resource permission.'
+                    : undefined,
+        });
+    }
+    if (!response?.data) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Unraid API returned no data');
+    }
+    return response.data;
+}

package/dist/lib/containers.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listContainerRefs = listContainerRefs;
+exports.matchContainer = matchContainer;
+exports.commandSafeName = commandSafeName;
+exports.resolveContainerIds = resolveContainerIds;
+exports.containerOptions = containerOptions;
+exports.withName = withName;
+const n8n_workflow_1 = require("n8n-workflow");
+const analysis_1 = require("./analysis");
+const client_1 = require("./client");
+const queries_1 = require("./queries");
+async function listContainerRefs() {
+    const data = await client_1.unraidGraphql.call(this, queries_1.Q.containerNames);
+    return data.docker.containers ?? [];
+}
+function matchContainer(refs, value) {
+    const v = value.trim();
+    const lower = v.replace(/^\//, '').toLowerCase();
+    return (refs.find((c) => c.id === v || c.id.endsWith(`:${v}`)) ??
+        refs.find((c) => (0, analysis_1.containerName)(c).toLowerCase() === lower) ??
+        refs.find((c) => c.names.some((n) => n.replace(/^\//, '').toLowerCase() === lower)) ??
+        refs.find((c) => commandSafeName((0, analysis_1.containerName)(c)) === commandSafeName(v)));
+}
+/** Telegram commands allow only [a-z0-9_], so "Plex-Media-Server" is sent as plex_media_server. */
+function commandSafeName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+/** Resolves names/IDs, reusing one container listing per execution via the cache object. */
+async function resolveContainerIds(values, cache) {
+    cache.refs ??= await listContainerRefs.call(this);
+    return values.map((value) => {
+        const match = matchContainer(cache.refs, value);
+        if (!match) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No Docker container named or with ID "${value}"`, {
+                description: `Known containers: ${cache.refs.map((c) => (0, analysis_1.containerName)(c)).join(', ') || 'none'}`,
+            });
+        }
+        return match.id;
+    });
+}
+async function containerOptions() {
+    const refs = await listContainerRefs.call(this);
+    return refs
+        .map((c) => ({ name: `${(0, analysis_1.containerName)(c)} (${c.state.toLowerCase()})`, value: (0, analysis_1.containerName)(c) }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Adds a plain `name` field next to Docker's `names` array. */
+function withName(container) {
+    return { name: (0, analysis_1.containerName)(container), ...container };
+}

package/dist/lib/logs.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLogContent = splitLogContent;
+exports.invalidPatternReason = invalidPatternReason;
+exports.compilePattern = compilePattern;
+exports.filterLogLines = filterLogLines;
+// Log text -> structured lines, optionally filtered by regex and classified with suggested next steps.
+const analysis_1 = require("./analysis");
+function splitLogContent(content, startLine) {
+    const raw = content.split(/\r?\n/);
+    if (raw.length && raw[raw.length - 1] === '')
+        raw.pop();
+    return raw.map((line, i) => ({ lineNumber: startLine ? startLine + i : undefined, line }));
+}
+/** Why a filter pattern is not a valid regular expression, or null when it is fine (or empty). */
+function invalidPatternReason(pattern) {
+    if (!pattern?.trim())
+        return null;
+    try {
+        new RegExp(pattern, 'i');
+        return null;
+    }
+    catch (error) {
+        return `Invalid filter pattern "${pattern}": ${error.message}`;
+    }
+}
+/** Case-insensitive regex for a filter pattern; undefined when empty or invalid (validate with invalidPatternReason first). */
+function compilePattern(pattern) {
+    return invalidPatternReason(pattern) === null && pattern?.trim() ? new RegExp(pattern, 'i') : undefined;
+}
+function filterLogLines(lines, filter) {
+    const regex = compilePattern(filter.pattern);
+    const out = [];
+    for (const l of lines) {
+        if (regex && !regex.test(l.line))
+            continue;
+        if (filter.analyze) {
+            const match = (0, analysis_1.classifyLogLine)(l.line);
+            if (filter.minSeverity && filter.minSeverity !== 'all' && (!match || !(0, analysis_1.severityAtLeast)(match.severity, filter.minSeverity)))
+                continue;
+            out.push(match ? { ...l, ...match } : l);
+        }
+        else {
+            out.push(l);
+        }
+    }
+    return out;
+}

package/dist/lib/queries.js

@@ -0,0 +1,86 @@
+"use strict";
+// GraphQL documents used by the Unraid nodes, written against api/generated-schema.graphql from github.com/unraid/api.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M = exports.Q = exports.METRICS_FIELDS = exports.NOTIFICATION_FIELDS = exports.PHYSICAL_DISK_FIELDS = exports.ARRAY_FIELDS = exports.PARITY_FIELDS = exports.ARRAY_DISK_FIELDS = exports.CONTAINER_FIELDS = void 0;
+exports.CONTAINER_FIELDS = `
+	id names image imageId state status created autoStart autoStartOrder
+	isUpdateAvailable isRebuildReady isOrphaned webUiUrl iconUrl projectUrl
+	ports { ip privatePort publicPort type }`;
+exports.ARRAY_DISK_FIELDS = `
+	id idx name device size status type temp warning critical rotational isSpinning
+	numReads numWrites numErrors fsSize fsFree fsUsed fsType comment`;
+exports.PARITY_FIELDS = 'date duration speed status errors progress correcting paused running';
+exports.ARRAY_FIELDS = `
+	id state
+	capacity { kilobytes { free used total } disks { free used total } }
+	parityCheckStatus { ${exports.PARITY_FIELDS} }
+	parities { ${exports.ARRAY_DISK_FIELDS} }
+	disks { ${exports.ARRAY_DISK_FIELDS} }
+	caches { ${exports.ARRAY_DISK_FIELDS} }
+	boot { ${exports.ARRAY_DISK_FIELDS} }`;
+exports.PHYSICAL_DISK_FIELDS = 'id device type name vendor size firmwareRevision serialNum interfaceType smartStatus temperature isSpinning';
+exports.NOTIFICATION_FIELDS = 'id title subject description importance link type timestamp formattedTimestamp';
+exports.METRICS_FIELDS = `
+	cpu { percentTotal }
+	memory { total used free available percentTotal swapTotal swapUsed percentSwapTotal }`;
+exports.Q = {
+    online: '{ online }',
+    info: `{
+		online
+		info {
+			time
+			os { platform distro release kernel arch hostname uptime }
+			cpu { manufacturer brand cores threads speed speedmax }
+			system { manufacturer model virtual }
+		}
+	}`,
+    metrics: `{ metrics { ${exports.METRICS_FIELDS} } }`,
+    array: `{ array { ${exports.ARRAY_FIELDS} } }`,
+    parityHistory: `{ parityHistory { ${exports.PARITY_FIELDS} } }`,
+    disks: `{ disks { ${exports.PHYSICAL_DISK_FIELDS} } }`,
+    shares: '{ shares { id name free used size comment cache include exclude splitLevel } }',
+    containers: `{ docker { containers { ${exports.CONTAINER_FIELDS} } } }`,
+    containerNames: '{ docker { containers { id names state } } }',
+    container: `query ($id: PrefixedID!) { docker { container(id: $id) { ${exports.CONTAINER_FIELDS} } } }`,
+    containerLogs: `query ($id: PrefixedID!, $since: DateTime, $tail: Int) {
+		docker { logs(id: $id, since: $since, tail: $tail) { containerId cursor lines { timestamp message } } }
+	}`,
+    containerUpdateStatuses: '{ docker { containerUpdateStatuses { name updateStatus } } }',
+    vms: '{ vms { domains { id name state } } }',
+    logFiles: '{ logFiles { name path size modifiedAt } }',
+    logFile: `query ($path: String!, $lines: Int, $startLine: Int) {
+		logFile(path: $path, lines: $lines, startLine: $startLine) { path content totalLines startLine }
+	}`,
+    notifications: `query ($filter: NotificationFilter!) { notifications { list(filter: $filter) { ${exports.NOTIFICATION_FIELDS} } } }`,
+    notificationOverview: `{ notifications { overview {
+		unread { info warning alert total }
+		archive { info warning alert total }
+	} } }`,
+    warningsAndAlerts: `{ notifications { warningsAndAlerts { ${exports.NOTIFICATION_FIELDS} } } }`,
+    health: `{
+		info { os { hostname uptime } }
+		array { ${exports.ARRAY_FIELDS} }
+		disks { ${exports.PHYSICAL_DISK_FIELDS} }
+		docker { containers { ${exports.CONTAINER_FIELDS} } }
+		notifications { warningsAndAlerts { ${exports.NOTIFICATION_FIELDS} } }
+		metrics { ${exports.METRICS_FIELDS} }
+	}`,
+};
+exports.M = {
+    arraySetState: `mutation ($input: ArrayStateInput!) { array { setState(input: $input) { id state } } }`,
+    parityStart: 'mutation ($correct: Boolean!) { parityCheck { start(correct: $correct) } }',
+    parityPause: 'mutation { parityCheck { pause } }',
+    parityResume: 'mutation { parityCheck { resume } }',
+    parityCancel: 'mutation { parityCheck { cancel } }',
+    dockerAction: (action) => `mutation ($id: PrefixedID!) { docker { ${action}(id: $id) { ${exports.CONTAINER_FIELDS} } } }`,
+    dockerUpdateMany: `mutation ($ids: [PrefixedID!]!) { docker { updateContainers(ids: $ids) { ${exports.CONTAINER_FIELDS} } } }`,
+    dockerUpdateAll: `mutation { docker { updateAllContainers { ${exports.CONTAINER_FIELDS} } } }`,
+    dockerRefreshDigests: 'mutation { refreshDockerDigests }',
+    vmAction: (action) => `mutation ($id: PrefixedID!) { vm { ${action}(id: $id) } }`,
+    createNotification: `mutation ($input: NotificationData!) { createNotification(input: $input) { ${exports.NOTIFICATION_FIELDS} } }`,
+    notifyIfUnique: `mutation ($input: NotificationData!) { notifyIfUnique(input: $input) { ${exports.NOTIFICATION_FIELDS} } }`,
+    archiveNotification: `mutation ($id: PrefixedID!) { archiveNotification(id: $id) { ${exports.NOTIFICATION_FIELDS} } }`,
+    archiveAll: `mutation ($importance: NotificationImportance) { archiveAll(importance: $importance) {
+		unread { info warning alert total } archive { info warning alert total }
+	} }`,
+};