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

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,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLogContent = splitLogContent;
+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 }));
+}
+function compilePattern(pattern) {
+    if (!pattern?.trim())
+        return undefined;
+    try {
+        return new RegExp(pattern, 'i');
+    }
+    catch (error) {
+        throw new Error(`Invalid filter pattern "${pattern}": ${error.message}`);
+    }
+}
+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 }
+	} }`,
+};