n8n-nodes-nilai 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Moore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# n8n-nodes-nilai
+
+Use [Nillion **nilAI**](https://docs.nillion.com/build/private-llms/overview) — private LLM inference that runs inside a **Trusted Execution Environment (TEE)** — directly in your n8n workflows, with **built-in cryptographic verification** of every response.
+
+This is an [n8n community node](https://docs.n8n.io/integrations/community-nodes/). It lets you add private, verifiable AI to any workflow with nothing more than an API key.
+
+## Why nilAI?
+
+Ordinary AI nodes send your data to a provider you have to trust. nilAI is different:
+
+- **Private by construction.** Models run inside a TEE (a hardware-isolated, encrypted enclave). The operator — including Nillion — cannot see your prompts or the model's output.
+- **Verifiable.** Every response is cryptographically signed *inside* the enclave. This node verifies that signature against the enclave's public key, so you can *prove* the answer came from a genuine Nillion TEE and was not altered in transit. The result is exposed as a `tee_verified` field.
+- **Drop-in.** nilAI is OpenAI-compatible, so anything you do with a normal LLM — summarisation, classification, triage, extraction, Q&A — works here, privately.
+
+### What is a TEE, briefly?
+
+A Trusted Execution Environment is a secure region of a CPU/GPU that runs code in an encrypted, hardware-isolated enclave. Data inside is invisible to the host operating system, the cloud provider and the operator. The hardware can produce a signed *attestation* proving which code is running and that it is genuinely inside a real enclave. nilAI runs LLMs inside TEEs and signs each response, turning "trust us" into "verify it yourself."
+
+## Installation
+
+In n8n: **Settings → Community Nodes → Install**, then enter `n8n-nodes-nilai`.
+
+(For local development, build the package and load it via `N8N_CUSTOM_EXTENSIONS`.)
+
+## Credentials
+
+Create a **nilAI API** credential and paste your API key. Get one for free at the [Nillion developer portal](https://developer.nillion.com/nilai). The base URL defaults to Nillion mainnet.
+
+## Usage
+
+Add the **nilAI** node, pick a model (loaded live from your endpoint), and enter a prompt. Output fields:
+
+| Field | Meaning |
+|---|---|
+| `text` | The model's response |
+| `tee_verified` | `true` if the response signature verified against the enclave's public key |
+| `signature` | The raw TEE signature (secp256k1 / ECDSA) |
+| `usage` | Token usage |
+
+Turn off **Simplify Output** to receive the full raw nilAI response.
+
+## How verification works
+
+nilAI signs each response inside the enclave (secp256k1 ECDSA over SHA-256). This node fetches the enclave's public key from `/v1/public_key`, reconstructs the exact signed bytes from the raw response, and verifies the signature — all locally, with no external dependencies.
+
+## Resources
+
+- [nilAI / Private LLMs docs](https://docs.nillion.com/build/private-llms/overview)
+- [Nillion developer portal](https://developer.nillion.com/nilai)
+- [n8n community nodes](https://docs.n8n.io/integrations/community-nodes/)
+
+## License
+
+[MIT](LICENSE)

package/dist/credentials/NilAiApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class NilAiApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: "file:nilai.svg";
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/NilAiApi.credentials.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NilAiApi = void 0;
+class NilAiApi {
+    constructor() {
+        this.name = 'nilAiApi';
+        this.displayName = 'nilAI API';
+        this.icon = 'file:nilai.svg';
+        this.documentationUrl = 'https://developer.nillion.com/nilai';
+        this.properties = [
+            {
+                displayName: 'Don\'t have a key yet? Create a free nilAI account with starter credit at <a href="https://developer.nillion.com/nilai" target="_blank">developer.nillion.com/nilai</a>.',
+                name: 'signupNotice',
+                type: 'notice',
+                default: '',
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Paste your nilAI API key. Get one free (with starter credit) at developer.nillion.com/nilai.',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://api.nilai.nillion.network',
+                description: 'nilAI API base URL. Defaults to Nillion mainnet.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl}}',
+                url: '/v1/models',
+            },
+        };
+    }
+}
+exports.NilAiApi = NilAiApi;

package/dist/credentials/nilai.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <rect x="0" y="0" width="64" height="64" fill="#0000FF"/>
+  <path d="M17 47 L17 17 L47 17 L47 47 L38 47 L38 27 L26 27 L26 47 Z" fill="#FFFFFF"/>
+</svg>

package/dist/nodes/NilAi/NilAi.node.d.ts

@@ -0,0 +1,11 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare function verifyNilaiSignature(rawBody: string, publicKeyB64: string): boolean;
+export declare class NilAi implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/NilAi/NilAi.node.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NilAi = void 0;
+exports.verifyNilaiSignature = verifyNilaiSignature;
+const crypto_1 = require("crypto");
+const attestation_1 = require("./attestation");
+const SPKI_SECP256K1_COMPRESSED_PREFIX = Buffer.from('3036301006072a8648ce3d020106052b8104000a032200', 'hex');
+function publicKeyFromCompressedBase64(b64) {
+    const point = Buffer.from(b64.trim().replace(/^"|"$/g, ''), 'base64');
+    const spki = Buffer.concat([SPKI_SECP256K1_COMPRESSED_PREFIX, point]);
+    return (0, crypto_1.createPublicKey)({ key: spki, format: 'der', type: 'spki' });
+}
+function verifyNilaiSignature(rawBody, publicKeyB64) {
+    try {
+        const obj = JSON.parse(rawBody);
+        const signatureB64 = obj.signature;
+        if (!signatureB64)
+            return false;
+        let preimage = rawBody.replace(`"signature":"${signatureB64}"`, '"signature":""');
+        for (const field of ['created_at', 'temperature', 'top_p']) {
+            preimage = preimage.replace(new RegExp(`("${field}":)(-?\\d+)([,}\\]])`), '$1$2.0$3');
+        }
+        const publicKey = publicKeyFromCompressedBase64(publicKeyB64);
+        return (0, crypto_1.verify)('sha256', Buffer.from(preimage, 'utf8'), { key: publicKey, dsaEncoding: 'der' }, Buffer.from(signatureB64, 'base64'));
+    }
+    catch {
+        return false;
+    }
+}
+class NilAi {
+    constructor() {
+        this.description = {
+            displayName: 'nilAI',
+            name: 'nilAi',
+            icon: 'file:nilai.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["model"]}}',
+            description: 'Private, verifiable AI inference inside a Trusted Execution Environment (TEE), powered by Nillion nilAI.',
+            defaults: {
+                name: 'nilAI',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'nilAiApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                    },
+                    default: 'google/gemma-4-26B-A4B-it',
+                    description: 'The model to run inside the nilAI TEE. Loaded live from your nilAI endpoint.',
+                },
+                {
+                    displayName: 'Instructions',
+                    name: 'instructions',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 2,
+                    },
+                    default: '',
+                    description: "What you want the model to do, e.g. 'Summarise this in 3 sentences and 3-5 key bullet points'.",
+                    hint: 'Plain text — the task only. Keep your data out of here (put that in Input). Leave empty to send just the Input as-is.',
+                },
+                {
+                    displayName: 'Input',
+                    name: 'prompt',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The content to act on. The model receives Instructions followed by this.',
+                    hint: 'Usually a reference to data from a previous node — e.g. the document text. Instructions + Input are combined into the prompt for you.',
+                },
+                {
+                    displayName: 'Simplify Output',
+                    name: 'simplify',
+                    type: 'boolean',
+                    default: true,
+                    description: "Whether to return a clean result instead of nilAI's full raw response object.",
+                    hint: 'On: tidy output — just the answer, the verification results and token usage. Off: the complete raw nilAI response (every field), handy for debugging.',
+                },
+                {
+                    displayName: 'Verify TEE Signature',
+                    name: 'verify',
+                    type: 'boolean',
+                    default: true,
+                    description: "Whether to cryptographically verify this response's signature against the enclave's key. Adds a tee_verified field.",
+                    hint: 'Proves THIS response was signed inside the nilAI enclave and was not altered in transit. Adds tee_verified (true/false).',
+                },
+                {
+                    displayName: 'Verify Enclave Attestation',
+                    name: 'verifyAttestation',
+                    type: 'boolean',
+                    default: true,
+                    description: "Whether to verify the serving enclave's AMD SEV-SNP hardware attestation against AMD's certificate chain. Adds an attestation object.",
+                    hint: "Proves the SERVER is a genuine AMD SEV-SNP TEE running the expected nilAI build (chained to AMD's root certificates). Independent of the signature check — use either or both.",
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getModels() {
+                    const credentials = await this.getCredentials('nilAiApi');
+                    const baseUrl = (credentials.baseUrl || 'https://api.nilai.nillion.network').replace(/\/+$/, '');
+                    const response = await this.helpers.httpRequestWithAuthentication.call(this, 'nilAiApi', {
+                        method: 'GET',
+                        url: `${baseUrl}/v1/models`,
+                        json: true,
+                    });
+                    const models = (response?.data ?? response);
+                    if (!Array.isArray(models))
+                        return [];
+                    return models
+                        .map((model) => ({ name: model.id, value: model.id }))
+                        .sort((a, b) => a.name.localeCompare(b.name));
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('nilAiApi');
+        const baseUrl = (credentials.baseUrl || 'https://api.nilai.nillion.network').replace(/\/+$/, '');
+        const verifyAttestation = this.getNodeParameter('verifyAttestation', 0, true);
+        const attestation = verifyAttestation ? await (0, attestation_1.verifyEnclaveAttestation)(this, baseUrl) : undefined;
+        let publicKeyB64;
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const model = this.getNodeParameter('model', i);
+                const instructions = this.getNodeParameter('instructions', i, '');
+                const prompt = this.getNodeParameter('prompt', i);
+                const doVerify = this.getNodeParameter('verify', i);
+                const simplify = this.getNodeParameter('simplify', i);
+                const rawResponse = await this.helpers.httpRequestWithAuthentication.call(this, 'nilAiApi', {
+                    method: 'POST',
+                    url: `${baseUrl}/v1/responses`,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ model, input: [instructions, prompt].map((s) => (s || '').trim()).filter(Boolean).join('\n\n') }),
+                    json: false,
+                    encoding: 'arraybuffer',
+                });
+                const rawBody = typeof rawResponse === 'string'
+                    ? rawResponse
+                    : Buffer.from(rawResponse).toString('utf8');
+                const parsed = JSON.parse(rawBody);
+                let teeVerified = null;
+                if (doVerify) {
+                    if (publicKeyB64 === undefined) {
+                        publicKeyB64 = (await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${baseUrl}/v1/public_key`,
+                            json: true,
+                            timeout: 15000,
+                        }));
+                    }
+                    teeVerified = verifyNilaiSignature(rawBody, publicKeyB64);
+                }
+                const outputItems = Array.isArray(parsed?.output) ? parsed.output : [];
+                const message = outputItems.find((o) => o?.type === 'message') ?? outputItems[0];
+                const contents = Array.isArray(message?.content) ? message.content : [];
+                const part = contents.find((c) => c?.type === 'output_text') ?? contents[0];
+                const text = typeof part?.text === 'string' ? part.text : null;
+                if (simplify) {
+                    returnData.push({
+                        json: {
+                            text,
+                            tee_verified: teeVerified,
+                            attestation,
+                            model: parsed?.model,
+                            signature: parsed?.signature ?? null,
+                            usage: parsed?.usage ?? null,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    returnData.push({
+                        json: { ...parsed, tee_verified: teeVerified, attestation },
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.NilAi = NilAi;

package/dist/nodes/NilAi/attestation.d.ts

@@ -0,0 +1,21 @@
+import type { IExecuteFunctions } from 'n8n-workflow';
+export interface AttestationResult {
+    attestation_verified: boolean;
+    processor?: string;
+    nilcc_version?: string;
+    measurement?: string;
+    measurement_matches_known_build?: boolean | null;
+    report_data?: string;
+    checks?: Record<string, boolean>;
+    error?: string;
+}
+export declare function detectProcessor(family: number, model: number): string | null;
+export interface ReportedTcb {
+    bootloader: number;
+    tee: number;
+    snp: number;
+    microcode: number;
+}
+export declare function verifyTcbExtensions(vcekDer: Buffer, tcb: ReportedTcb, chipIdHex: string): boolean;
+export declare function checkReportDataBinding(reportDataHex: string, certDer: Buffer): boolean;
+export declare function verifyEnclaveAttestation(ctx: IExecuteFunctions, baseUrl: string): Promise<AttestationResult>;

package/dist/nodes/NilAi/attestation.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProcessor = detectProcessor;
+exports.verifyTcbExtensions = verifyTcbExtensions;
+exports.checkReportDataBinding = checkReportDataBinding;
+exports.verifyEnclaveAttestation = verifyEnclaveAttestation;
+const crypto_1 = require("crypto");
+const tls_1 = require("tls");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const KDS_DOMAIN = 'kdsintf.amd.com';
+const KNOWN_MEASUREMENTS = {
+    '0.3.0': '981bcaa62bcd63cb03c7b93a67d1a8c17ff63e45e6d16323a8784bacbfcb254313741bcf32d0bccc795d6ea0e6ac1481',
+};
+const certChainCache = {};
+const vcekCache = {};
+function certCacheDir() {
+    for (const base of [(0, path_1.join)((0, os_1.homedir)(), '.n8n'), (0, os_1.tmpdir)()]) {
+        try {
+            const dir = (0, path_1.join)(base, '.nilai-cert-cache');
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+            return dir;
+        }
+        catch {
+        }
+    }
+    return (0, os_1.tmpdir)();
+}
+function readCertCache(name) {
+    try {
+        const p = (0, path_1.join)(certCacheDir(), name);
+        return (0, fs_1.existsSync)(p) ? (0, fs_1.readFileSync)(p) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCertCache(name, data) {
+    try {
+        (0, fs_1.writeFileSync)((0, path_1.join)(certCacheDir(), name), data);
+    }
+    catch {
+    }
+}
+function detectProcessor(family, model) {
+    if (family === 0x19) {
+        if (model <= 0x0f)
+            return 'Milan';
+        if ((model >= 0x10 && model <= 0x1f) || (model >= 0xa0 && model <= 0xaf))
+            return 'Genoa';
+        return null;
+    }
+    if (family === 0x1a)
+        return 'Turin';
+    return null;
+}
+function leToBe48(le) {
+    const be = Buffer.from(le).reverse();
+    return be.subarray(be.length - 48);
+}
+const SNP_OID = {
+    bootloader: '2b060104019c78010301',
+    tee: '2b060104019c78010302',
+    snp: '2b060104019c78010303',
+    ucode: '2b060104019c78010308',
+    hwid: '2b060104019c780104',
+};
+function extValue(der, oidHex) {
+    const oid = Buffer.from(oidHex, 'hex');
+    const idx = der.indexOf(oid);
+    if (idx < 0)
+        return null;
+    let p = idx + oid.length;
+    if (der[p] === 0x01)
+        p += 3;
+    if (der[p] !== 0x04)
+        return null;
+    let len = der[p + 1];
+    let start = p + 2;
+    if (len & 0x80) {
+        const n = len & 0x7f;
+        len = 0;
+        for (let i = 0; i < n; i++)
+            len = (len << 8) | der[start + i];
+        start += n;
+    }
+    return der.subarray(start, start + len);
+}
+function intExt(der, oidHex) {
+    const v = extValue(der, oidHex);
+    if (!v || v[0] !== 0x02)
+        return null;
+    return v[v.length - 1];
+}
+function verifyTcbExtensions(vcekDer, tcb, chipIdHex) {
+    if (intExt(vcekDer, SNP_OID.bootloader) !== tcb.bootloader)
+        return false;
+    if (intExt(vcekDer, SNP_OID.tee) !== tcb.tee)
+        return false;
+    if (intExt(vcekDer, SNP_OID.snp) !== tcb.snp)
+        return false;
+    if (intExt(vcekDer, SNP_OID.ucode) !== tcb.microcode)
+        return false;
+    const hwid = extValue(vcekDer, SNP_OID.hwid);
+    if (!hwid || hwid.toString('hex') !== chipIdHex)
+        return false;
+    return true;
+}
+function parseCertChain(pem) {
+    try {
+        const blocks = pem.match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g) ?? [];
+        let ark;
+        let ask;
+        for (const block of blocks) {
+            const c = new crypto_1.X509Certificate(block);
+            if (c.verify(c.publicKey))
+                ark = c;
+            else
+                ask = c;
+        }
+        return ark && ask ? { ark, ask } : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getServerCertDer(host) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let socket;
+        const finish = (v) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket?.destroy();
+            }
+            catch {
+            }
+            resolve(v);
+        };
+        const timer = setTimeout(() => finish(null), 7000);
+        try {
+            socket = (0, tls_1.connect)({ host, port: 443, servername: host, rejectUnauthorized: true }, () => {
+                try {
+                    const peer = socket.getPeerCertificate();
+                    finish(peer && peer.raw ? peer.raw : null);
+                }
+                catch {
+                    finish(null);
+                }
+            });
+            socket.on('error', () => finish(null));
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function checkReportDataBinding(reportDataHex, certDer) {
+    try {
+        const spki = new crypto_1.X509Certificate(certDer).publicKey.export({ type: 'spki', format: 'der' });
+        const fingerprint = (0, crypto_1.createHash)('sha256').update(spki).digest('hex');
+        return (reportDataHex.length === 128 &&
+            reportDataHex.slice(0, 2) === '00' &&
+            reportDataHex.slice(2, 66) === fingerprint &&
+            /^0+$/.test(reportDataHex.slice(66)));
+    }
+    catch {
+        return false;
+    }
+}
+async function verifyEnclaveAttestation(ctx, baseUrl) {
+    try {
+        const reportResp = (await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: `${baseUrl}/nilcc/api/v2/report`,
+            json: true, timeout: 15000,
+        }));
+        const report = reportResp.report;
+        const raw = Buffer.from(reportResp.raw_report, 'hex');
+        const nilccVersion = reportResp.environment?.nilcc_version;
+        if (raw.length < 0x4a0) {
+            throw new Error(`attestation report too short (${raw.length} bytes, expected 1184)`);
+        }
+        const policy = raw.readBigUInt64LE(0x08);
+        const debugAllowed = ((policy >> 19n) & 1n) === 1n;
+        const tcb = {
+            bootloader: raw[0x180],
+            tee: raw[0x181],
+            snp: raw[0x186],
+            microcode: raw[0x187],
+        };
+        const chipIdHex = raw.subarray(0x1a0, 0x1e0).toString('hex');
+        const reportVersion = raw.readUInt32LE(0x00);
+        const family = reportVersion >= 3 ? raw[0x188] : report.cpuid_fam_id;
+        const model = reportVersion >= 3 ? raw[0x189] : report.cpuid_mod_id;
+        const processor = detectProcessor(family, model);
+        if (!processor) {
+            throw new Error(`unsupported processor (family 0x${family.toString(16)}, model 0x${model.toString(16)})`);
+        }
+        const pad2 = (n) => String(n).padStart(2, '0');
+        if (!certChainCache[processor]) {
+            const chainCacheName = `certchain_${processor}.pem`;
+            const cachedChain = readCertCache(chainCacheName);
+            let chain = cachedChain ? parseCertChain(cachedChain.toString('utf8')) : null;
+            if (!chain) {
+                const chainPem = (await ctx.helpers.httpRequest({
+                    method: 'GET',
+                    url: `https://${KDS_DOMAIN}/vcek/v1/${processor}/cert_chain`,
+                    encoding: 'text',
+                    timeout: 15000,
+                }));
+                chain = parseCertChain(chainPem);
+                if (!chain)
+                    throw new Error('AMD KDS returned an unparseable certificate chain');
+                writeCertCache(chainCacheName, Buffer.from(chainPem, 'utf8'));
+            }
+            certChainCache[processor] = chain;
+        }
+        const { ark, ask } = certChainCache[processor];
+        const vcekUrl = `https://${KDS_DOMAIN}/vcek/v1/${processor}/${chipIdHex}` +
+            `?blSPL=${pad2(tcb.bootloader)}&teeSPL=${pad2(tcb.tee)}&snpSPL=${pad2(tcb.snp)}&ucodeSPL=${pad2(tcb.microcode)}`;
+        if (!vcekCache[vcekUrl]) {
+            const vcekCacheName = `vcek_${chipIdHex}_${tcb.bootloader}_${tcb.tee}_${tcb.snp}_${tcb.microcode}.der`;
+            const cachedDer = readCertCache(vcekCacheName);
+            let vcekCert = null;
+            if (cachedDer) {
+                try {
+                    vcekCert = new crypto_1.X509Certificate(cachedDer);
+                }
+                catch {
+                    vcekCert = null;
+                }
+            }
+            if (!vcekCert) {
+                const fetched = (await ctx.helpers.httpRequest({
+                    method: 'GET',
+                    url: vcekUrl,
+                    encoding: 'arraybuffer',
+                    timeout: 15000,
+                }));
+                const der = Buffer.from(fetched);
+                vcekCert = new crypto_1.X509Certificate(der);
+                writeCertCache(vcekCacheName, der);
+            }
+            vcekCache[vcekUrl] = vcekCert;
+        }
+        const vcek = vcekCache[vcekUrl];
+        const arkSelfSigned = ark.verify(ark.publicKey);
+        const askByArk = ask.verify(ark.publicKey);
+        const vcekByAsk = vcek.verify(ask.publicKey);
+        const sig = Buffer.concat([
+            leToBe48(raw.subarray(0x2a0, 0x2e8)),
+            leToBe48(raw.subarray(0x2e8, 0x330)),
+        ]);
+        const signedBytes = raw.subarray(0x0, 0x2a0);
+        let sigValid = false;
+        try {
+            sigValid = (0, crypto_1.verify)('sha384', signedBytes, { key: vcek.publicKey, dsaEncoding: 'ieee-p1363' }, sig);
+        }
+        catch {
+            sigValid = false;
+        }
+        const measurement = raw.subarray(0x90, 0x90 + 48).toString('hex');
+        const known = nilccVersion ? KNOWN_MEASUREMENTS[nilccVersion] : undefined;
+        const measurementMatches = known ? measurement === known : null;
+        const reportData = raw.subarray(0x50, 0x50 + 64).toString('hex');
+        const tcbOk = verifyTcbExtensions(vcek.raw, tcb, chipIdHex);
+        const host = (() => {
+            try {
+                return new URL(baseUrl).hostname;
+            }
+            catch {
+                return '';
+            }
+        })();
+        const serverCertDer = host ? await getServerCertDer(host) : null;
+        const tlsBound = serverCertDer ? checkReportDataBinding(reportData, serverCertDer) : false;
+        const checks = {
+            ark_self_signed: arkSelfSigned,
+            ask_signed_by_ark: askByArk,
+            vcek_signed_by_ask: vcekByAsk,
+            report_signature_valid: sigValid,
+            vcek_tcb_matches_report: tcbOk,
+            tls_session_bound: tlsBound,
+            debug_disabled: !debugAllowed,
+        };
+        const attestation_verified = Object.values(checks).every(Boolean) && measurementMatches !== false;
+        return {
+            attestation_verified,
+            processor,
+            nilcc_version: nilccVersion,
+            measurement,
+            measurement_matches_known_build: measurementMatches,
+            report_data: reportData,
+            checks,
+        };
+    }
+    catch (e) {
+        return { attestation_verified: false, error: e.message };
+    }
+}

package/dist/nodes/NilAi/nilai.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <rect x="0" y="0" width="64" height="64" fill="#0000FF"/>
+  <path d="M17 47 L17 17 L47 17 L47 47 L38 47 L38 27 L26 27 L26 47 Z" fill="#FFFFFF"/>
+</svg>

package/index.js

@@ -0,0 +1 @@
+module.exports = {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "n8n-nodes-nilai",
+  "version": "0.1.0",
+  "description": "Use Nillion nilAI — private LLM inference in a TEE, OpenAI-compatible — directly in n8n, with built-in cryptographic verification of every response.",
+  "keywords": [
+    "n8n-community-node-package",
+    "nillion",
+    "nilai",
+    "tee",
+    "privacy",
+    "llm",
+    "ai",
+    "confidential-computing"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/iamrobertmoore/n8n-nodes-nilai",
+  "author": {
+    "name": "Robert Moore",
+    "email": "iamrobertmoore@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamrobertmoore/n8n-nodes-nilai.git"
+  },
+  "engines": {
+    "node": ">=18.10"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc && mkdir -p dist/nodes/NilAi dist/credentials && cp nodes/NilAi/nilai.svg dist/nodes/NilAi/nilai.svg && cp nodes/NilAi/nilai.svg dist/credentials/nilai.svg",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "index.js"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/NilAiApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/NilAi/NilAi.node.js"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "n8n-workflow": "^2.16.0",
+    "typescript": "^5.6.0"
+  }
+}