n8n-nodes-redactor 4.0.0 → 4.2.0

package/dist/nodes/Redactor/injection.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INJECTION_DESCRIPTIONS = void 0;
 exports.detectPromptInjection = detectPromptInjection;
 exports.scanForInjection = scanForInjection;
 const INJECTION_PATTERNS = [
@@ -200,6 +201,11 @@ const INJECTION_PATTERNS = [
         description: 'Fake end-of-prompt marker',
     },
 ];
+exports.INJECTION_DESCRIPTIONS = [
+    ...INJECTION_PATTERNS.map((p) => p.description),
+    'Invisible Unicode characters detected',
+    'Base64-encoded injection payload detected',
+];
 const ZERO_WIDTH_RE = /(?:\u200B|\u200C|\u200D|\uFEFF|\u00AD|\u2060|\u2061|\u2062|\u2063|\u2064|\u2066|\u2067|\u2068|\u2069|\u206A|\u206B|\u206C|\u206D|\u206E|\u206F)/g;
 const BASE64_SUSPICIOUS_RE = /[A-Za-z0-9+/]{40,}={0,2}/g;
 const INJECTION_SEEDS = [
@@ -258,7 +264,7 @@ function detectPromptInjection(text) {
                     matches.push({
                         category: 'encoded_payload',
                         pattern: 'Base64-encoded injection payload detected',
-                        matchedText: `Decoded: "${decoded.slice(0, 50)}..."`,
+                        matchedText: `(decoded payload of ${decoded.length} characters withheld)`,
                         severity: 'HIGH',
                         score: 0.35,
                     });

package/dist/nodes/Redactor/profiles.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTenantProfile = parseTenantProfile;
+const regexSafety_1 = require("./regexSafety");
 const MODES = ['token', 'mask', 'hash', 'redact', 'pseudonymize', 'blackout', 'remove'];
 const FIELD_MODES = ['all', 'allowlist', 'denylist'];
 const MATCH_TYPES = ['exact', 'contains', 'regex'];
@@ -25,6 +26,9 @@ function entries(value, name, defaultType) {
         const type = (_a = e.type) !== null && _a !== void 0 ? _a : defaultType;
         if (typeof type !== 'string' || !MATCH_TYPES.includes(type))
             fail(`${name}[${i}].type must be one of ${MATCH_TYPES.join(', ')}`);
+        const problem = type === 'regex' ? (0, regexSafety_1.checkRegex)(e.value) : null;
+        if (problem)
+            fail(`${name}[${i}].value regex ${problem}`);
         return { value: e.value, type: type };
     });
 }
@@ -54,12 +58,9 @@ function parseCustomPatterns(value) {
         if (!isObject(c) || typeof c.label !== 'string' || typeof c.regex !== 'string') {
             fail(`customPatterns[${i}] needs string label and regex`);
         }
-        try {
-            new RegExp(c.regex);
-        }
-        catch {
-            fail(`customPatterns[${i}].regex is not a valid regular expression`);
-        }
+        const problem = (0, regexSafety_1.checkRegex)(c.regex);
+        if (problem)
+            fail(`customPatterns[${i}].regex ${problem}`);
         return { label: c.label, regex: c.regex, category: typeof c.category === 'string' ? c.category : undefined };
     });
 }

package/dist/nodes/Redactor/regexSafety.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRegex = checkRegex;
+const MAX_REGEX_LENGTH = 500;
+function readBraces(src, i) {
+    const m = /^\{(\d+)(,(\d*))?\}/.exec(src.slice(i));
+    if (!m)
+        return null;
+    const min = Number(m[1]);
+    const max = m[2] === undefined ? min : m[3] === '' ? Infinity : Number(m[3]);
+    return { min, max, length: m[0].length };
+}
+function readQuantifier(src, i) {
+    const c = src[i];
+    let q = null;
+    if (c === '*')
+        q = { min: 0, max: Infinity, length: 1 };
+    else if (c === '+')
+        q = { min: 1, max: Infinity, length: 1 };
+    else if (c === '?')
+        q = { min: 0, max: 1, length: 1 };
+    else if (c === '{')
+        q = readBraces(src, i);
+    if (q && src[i + q.length] === '?')
+        q.length += 1;
+    return q;
+}
+function skipClass(src, i) {
+    let j = i + 1;
+    if (src[j] === '^')
+        j++;
+    if (src[j] === ']')
+        j++;
+    while (j < src.length && src[j] !== ']')
+        j += src[j] === '\\' ? 2 : 1;
+    return j + 1;
+}
+function groupPrefixLength(src, i) {
+    if (src[i + 1] !== '?')
+        return 1;
+    const named = /^\(\?<[A-Za-z_$][\w$]*>/.exec(src.slice(i));
+    if (named)
+        return named[0].length;
+    const look = /^\(\?(?::|=|!|<=|<!)/.exec(src.slice(i));
+    return look ? look[0].length : 1;
+}
+function readToken(src, i, stack) {
+    var _a;
+    const c = src[i];
+    if (c === '\\') {
+        if (/[1-9k]/.test((_a = src[i + 1]) !== null && _a !== void 0 ? _a : ''))
+            return { atomEnd: i, closed: null, error: 'back-references are not supported' };
+        return { atomEnd: i + 2, closed: null };
+    }
+    if (c === '[')
+        return { atomEnd: skipClass(src, i), closed: null };
+    if (c === '(') {
+        stack.push({ hasVariableQuantifier: false, hasAlternation: false });
+        return { atomEnd: i, closed: null, next: i + groupPrefixLength(src, i) };
+    }
+    if (c === '|') {
+        stack[stack.length - 1].hasAlternation = true;
+        return { atomEnd: i, closed: null, next: i + 1 };
+    }
+    const closed = c === ')' && stack.length > 1 ? stack.pop() : null;
+    return { atomEnd: i + 1, closed };
+}
+const NESTED = 'a repeated group contains a quantifier or alternation (catastrophic backtracking)';
+function isRisky(frame) {
+    return !!frame && (frame.hasVariableQuantifier || frame.hasAlternation);
+}
+const NO_GROUP = { hasVariableQuantifier: false, hasAlternation: false };
+const repeats = (q) => q !== null && q.max > 1;
+const isVariable = (q) => q !== null && q.min !== q.max;
+function applyQuantifier(q, closed, top) {
+    if (repeats(q) && isRisky(closed))
+        return NESTED;
+    const inner = closed !== null && closed !== void 0 ? closed : NO_GROUP;
+    top.hasVariableQuantifier || (top.hasVariableQuantifier = isVariable(q) || inner.hasVariableQuantifier);
+    top.hasAlternation || (top.hasAlternation = inner.hasAlternation);
+    return null;
+}
+function structuralProblem(src) {
+    const stack = [{ hasVariableQuantifier: false, hasAlternation: false }];
+    let i = 0;
+    while (i < src.length) {
+        const step = readToken(src, i, stack);
+        if (step.error)
+            return step.error;
+        if (step.next !== undefined) {
+            i = step.next;
+            continue;
+        }
+        const q = readQuantifier(src, step.atomEnd);
+        const problem = applyQuantifier(q, step.closed, stack[stack.length - 1]);
+        if (problem)
+            return problem;
+        i = step.atomEnd + (q ? q.length : 0);
+    }
+    return null;
+}
+function checkRegex(regexStr) {
+    if (typeof regexStr !== 'string' || regexStr.length === 0)
+        return 'is empty';
+    if (regexStr.length > MAX_REGEX_LENGTH)
+        return `is longer than ${MAX_REGEX_LENGTH} characters`;
+    try {
+        new RegExp(regexStr, 'g');
+    }
+    catch {
+        return 'is not a valid regular expression';
+    }
+    return structuralProblem(regexStr);
+}

package/dist/nodes/Redactor/runtime.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePassphrase = resolvePassphrase;
+exports.workflowNamespace = workflowNamespace;
+exports.assertUserRegexes = assertUserRegexes;
+exports.sanitizeInjection = sanitizeInjection;
+const n8n_workflow_1 = require("n8n-workflow");
+const regexSafety_1 = require("./regexSafety");
+const injection_1 = require("./injection");
+const VAULT_CREDENTIAL = 'redactorVaultApi';
+async function resolvePassphrase(fns) {
+    var _a;
+    if ((_a = fns.getNode().credentials) === null || _a === void 0 ? void 0 : _a[VAULT_CREDENTIAL]) {
+        let cred;
+        try {
+            cred = (await fns.getCredentials(VAULT_CREDENTIAL));
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(fns.getNode(), 'The Redactor Vault credential could not be read, so the vault stays locked.', {
+                description: `Nothing was stored. Re-enter the passphrase in the credential. Cause: ${error.message}`,
+            });
+        }
+        if (typeof cred.passphrase !== 'string' || cred.passphrase === '') {
+            throw new n8n_workflow_1.NodeOperationError(fns.getNode(), 'The Redactor Vault credential has an empty passphrase.', {
+                description: 'Nothing was stored. Set a passphrase in the credential, or remove the credential from the node.',
+            });
+        }
+        return cred.passphrase;
+    }
+    try {
+        return fns.getNodeParameter('vaultPassphrase', 0, '') || '';
+    }
+    catch {
+        return '';
+    }
+}
+function workflowNamespace(fns) {
+    try {
+        const id = fns.getWorkflow().id;
+        if (id !== undefined && id !== null && String(id) !== '')
+            return `wf:${String(id)}`;
+    }
+    catch {
+    }
+    return 'wf:unsaved';
+}
+function assertUserRegexes(fns, customPatterns, lists) {
+    const refuse = (what, problem) => {
+        throw new n8n_workflow_1.NodeOperationError(fns.getNode(), `${what} regex ${problem}`, {
+            description: 'Rewrite the pattern without nested or alternated repetition, for example [ab]+ instead of (a|b)+.',
+        });
+    };
+    for (const cp of customPatterns) {
+        if (!cp.label || !cp.regex)
+            continue;
+        const problem = (0, regexSafety_1.checkRegex)(cp.regex);
+        if (problem)
+            refuse(`Custom pattern "${cp.label}"`, problem);
+    }
+    for (const list of lists) {
+        for (const entry of list.entries) {
+            const problem = entry.type === 'regex' ? (0, regexSafety_1.checkRegex)(entry.value) : null;
+            if (problem)
+                refuse(`${list.name} entry "${entry.value}"`, problem);
+        }
+    }
+}
+function sanitizeInjection(result) {
+    const matchedPatterns = result.matchedPatterns.map((m) => {
+        var _a;
+        return ({
+            category: m.category,
+            pattern: (_a = injection_1.INJECTION_DESCRIPTIONS.find((d) => m.pattern === d || m.pattern.endsWith(` ${d}`))) !== null && _a !== void 0 ? _a : 'Prompt injection detector',
+            matchedText: '(withheld)',
+            severity: m.severity,
+            score: m.score,
+        });
+    });
+    return { ...result, matchedPatterns };
+}

package/dist/nodes/Redactor/vault.js

@@ -45,64 +45,101 @@ function isExpired(createdAt, ttl, now = Date.now()) {
 const memoryStore = new Map();
 const reverseIndex = new Map();
 const MAX_SESSIONS = 1000;
+const MAX_TOTAL_SESSIONS = 20000;
+function assertNoConflict(session, entry) {
+    const existing = session.entries[entry.token];
+    if (existing && existing.original !== entry.original) {
+        throw new Error(`Vault token "${entry.token}" already maps to a different value in session "${session.sessionId}"`);
+    }
+}
 class MemoryVault {
-    getOrCreateSession(sessionId, ttl) {
-        this.cleanup();
-        if (memoryStore.size >= MAX_SESSIONS && !memoryStore.has(sessionId)) {
+    constructor(namespace = '') {
+        this.namespace = namespace;
+    }
+    key(sessionId) {
+        return `${this.namespace}\u0000${sessionId}`;
+    }
+    ownKeys() {
+        const prefix = `${this.namespace}\u0000`;
+        return Array.from(memoryStore.keys()).filter((k) => k.startsWith(prefix));
+    }
+    drop(key) {
+        memoryStore.delete(key);
+        reverseIndex.delete(key);
+    }
+    evictIfFull(key) {
+        if (memoryStore.has(key))
+            return;
+        const own = this.ownKeys();
+        if (own.length >= MAX_SESSIONS)
+            this.drop(own[0]);
+        if (memoryStore.size >= MAX_TOTAL_SESSIONS) {
             const oldest = memoryStore.keys().next().value;
-            if (oldest !== undefined) {
-                memoryStore.delete(oldest);
-                reverseIndex.delete(oldest);
-            }
+            if (oldest !== undefined)
+                this.drop(oldest);
         }
-        if (!memoryStore.has(sessionId)) {
-            memoryStore.set(sessionId, {
-                sessionId,
-                entries: {},
-                createdAt: new Date().toISOString(),
-                ttl,
-            });
+    }
+    getOrCreateSession(sessionId, ttl) {
+        this.cleanup();
+        const key = this.key(sessionId);
+        this.evictIfFull(key);
+        if (!memoryStore.has(key)) {
+            memoryStore.set(key, { sessionId, entries: {}, createdAt: new Date().toISOString(), ttl });
         }
-        return memoryStore.get(sessionId);
+        return memoryStore.get(key);
     }
     getSession(sessionId) {
-        const session = memoryStore.get(sessionId);
+        const key = this.key(sessionId);
+        const session = memoryStore.get(key);
         if (!session)
             return null;
         if (isExpired(session.createdAt, session.ttl)) {
-            memoryStore.delete(sessionId);
-            reverseIndex.delete(sessionId);
+            this.drop(key);
             return null;
         }
         return session;
     }
     addEntry(sessionId, entry) {
-        const session = memoryStore.get(sessionId);
-        if (session) {
-            session.entries[entry.token] = entry;
-            if (!reverseIndex.has(sessionId))
-                reverseIndex.set(sessionId, new Map());
-            reverseIndex.get(sessionId).set(entry.original, entry);
-        }
+        const key = this.key(sessionId);
+        const session = memoryStore.get(key);
+        if (!session)
+            return;
+        assertNoConflict(session, entry);
+        session.entries[entry.token] = entry;
+        if (!reverseIndex.has(key))
+            reverseIndex.set(key, new Map());
+        reverseIndex.get(key).set(entry.original, entry);
     }
     findByOriginal(sessionId, original) {
-        const index = reverseIndex.get(sessionId);
-        if (index) {
-            const entry = index.get(original);
-            if (entry)
-                return entry;
-        }
-        const session = memoryStore.get(sessionId);
+        var _a;
+        const key = this.key(sessionId);
+        const entry = (_a = reverseIndex.get(key)) === null || _a === void 0 ? void 0 : _a.get(original);
+        if (entry)
+            return entry;
+        const session = memoryStore.get(key);
         if (!session)
             return undefined;
         return Object.values(session.entries).find((e) => e.original === original);
     }
     deleteSession(sessionId) {
-        memoryStore.delete(sessionId);
-        reverseIndex.delete(sessionId);
+        this.drop(this.key(sessionId));
+    }
+    purgeAll() {
+        const keys = this.ownKeys();
+        const entries = keys.reduce((n, k) => { var _a, _b; return n + Object.keys((_b = (_a = memoryStore.get(k)) === null || _a === void 0 ? void 0 : _a.entries) !== null && _b !== void 0 ? _b : {}).length; }, 0);
+        keys.forEach((k) => this.drop(k));
+        return { sessions: keys.length, entries };
+    }
+    purgeSession(sessionId) {
+        const session = memoryStore.get(this.key(sessionId));
+        this.deleteSession(sessionId);
+        return { found: !!session, entries: session ? Object.keys(session.entries).length : null };
     }
     listSessions() {
-        return Array.from(memoryStore.values()).map((s) => ({
+        return this.ownKeys()
+            .map((k) => memoryStore.get(k))
+            .filter((s) => !isExpired(s.createdAt, s.ttl))
+            .map((s) => ({
             sessionId: s.sessionId,
             entryCount: Object.keys(s.entries).length,
             createdAt: s.createdAt,
@@ -114,10 +151,9 @@ class MemoryVault {
     cleanup() {
         let removed = 0;
         const now = Date.now();
-        for (const [id, session] of memoryStore.entries()) {
+        for (const [key, session] of memoryStore.entries()) {
             if (isExpired(session.createdAt, session.ttl, now)) {
-                memoryStore.delete(id);
-                reverseIndex.delete(id);
+                this.drop(key);
                 removed++;
             }
         }
@@ -132,13 +168,18 @@ class WorkflowVault {
         this.store = store;
         this.passphrase = passphrase;
         this.cache = new Map();
-        const existing = store[STORE_KEY];
-        if (!existing || typeof existing !== 'object' || Array.isArray(existing)) {
-            store[STORE_KEY] = {};
-        }
-        this.cleanup();
     }
     get sessions() {
+        const existing = this.store[STORE_KEY];
+        if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+            return existing;
+        }
+        return {};
+    }
+    writableSessions() {
+        const existing = this.store[STORE_KEY];
+        if (!existing || typeof existing !== 'object' || Array.isArray(existing))
+            this.store[STORE_KEY] = {};
         return this.store[STORE_KEY];
     }
     key(sessionId) {
@@ -158,23 +199,20 @@ class WorkflowVault {
         }
         return null;
     }
+    isUnreadable(sessionId) {
+        const stored = this.sessions[this.key(sessionId)];
+        if (!stored || typeof stored !== 'object' || isExpired(stored.createdAt, stored.ttl))
+            return false;
+        const session = this.decode(stored);
+        return !session || session.sessionId !== sessionId;
+    }
     load(sessionId) {
         const cached = this.cache.get(sessionId);
-        if (cached) {
-            if (isExpired(cached.createdAt, cached.ttl)) {
-                this.deleteSession(sessionId);
-                return null;
-            }
-            return cached;
-        }
-        const k = this.key(sessionId);
-        const stored = this.sessions[k];
-        if (!stored)
+        if (cached)
+            return isExpired(cached.createdAt, cached.ttl) ? null : cached;
+        const stored = this.sessions[this.key(sessionId)];
+        if (!stored || isExpired(stored.createdAt, stored.ttl))
             return null;
-        if (isExpired(stored.createdAt, stored.ttl)) {
-            delete this.sessions[k];
-            return null;
-        }
         const session = this.decode(stored);
         if (!session || session.sessionId !== sessionId)
             return null;
@@ -186,6 +224,9 @@ class WorkflowVault {
         const existing = this.load(sessionId);
         if (existing)
             return existing;
+        if (this.isUnreadable(sessionId)) {
+            throw new Error(`Session "${sessionId}" exists but cannot be decrypted with this passphrase. Use the passphrase it was written with, or a different Session ID.`);
+        }
         const session = { sessionId, entries: {}, createdAt: new Date().toISOString(), ttl };
         this.cache.set(sessionId, session);
         return session;
@@ -195,8 +236,10 @@ class WorkflowVault {
     }
     addEntry(sessionId, entry) {
         const session = this.cache.get(sessionId);
-        if (session)
-            session.entries[entry.token] = entry;
+        if (!session)
+            return;
+        assertNoConflict(session, entry);
+        session.entries[entry.token] = entry;
     }
     findByOriginal(sessionId, original) {
         const session = this.cache.get(sessionId);
@@ -206,11 +249,34 @@ class WorkflowVault {
     }
     deleteSession(sessionId) {
         this.cache.delete(sessionId);
-        delete this.sessions[this.key(sessionId)];
+        const k = this.key(sessionId);
+        if (k in this.sessions)
+            delete this.writableSessions()[k];
+    }
+    purgeAll() {
+        const stored = Object.values(this.sessions);
+        const entries = stored.reduce((n, rec) => {
+            const session = rec && typeof rec === 'object' ? this.decode(rec) : null;
+            return n + (session ? Object.keys(session.entries).length : 0);
+        }, 0);
+        this.cache.clear();
+        if (stored.length)
+            this.store[STORE_KEY] = {};
+        return { sessions: stored.length, entries };
+    }
+    purgeSession(sessionId) {
+        var _a;
+        const stored = this.sessions[this.key(sessionId)];
+        const live = (_a = this.cache.get(sessionId)) !== null && _a !== void 0 ? _a : (stored && typeof stored === 'object' ? this.decode(stored) : null);
+        const found = !!stored || this.cache.has(sessionId);
+        this.deleteSession(sessionId);
+        return { found, entries: live && live.sessionId === sessionId ? Object.keys(live.entries).length : null };
     }
     listSessions() {
         const out = [];
         for (const stored of Object.values(this.sessions)) {
+            if (!stored || typeof stored !== 'object' || isExpired(stored.createdAt, stored.ttl))
+                continue;
             const session = this.decode(stored);
             if (!session)
                 continue;
@@ -227,8 +293,12 @@ class WorkflowVault {
         const session = this.cache.get(sessionId);
         if (!session)
             return;
+        if (this.isUnreadable(sessionId)) {
+            throw new Error(`Refusing to overwrite session "${sessionId}": it cannot be decrypted with this passphrase.`);
+        }
+        const sessions = this.writableSessions();
         const k = this.key(sessionId);
-        if (!this.sessions[k])
+        if (!sessions[k])
             this.evictIfFull();
         const stored = { createdAt: session.createdAt, ttl: session.ttl };
         if (this.passphrase) {
@@ -237,23 +307,28 @@ class WorkflowVault {
         else {
             stored.session = session;
         }
-        this.sessions[k] = stored;
+        sessions[k] = stored;
     }
     evictIfFull() {
-        const keys = Object.keys(this.sessions);
+        const sessions = this.writableSessions();
+        const keys = Object.keys(sessions);
         if (keys.length < MAX_STORED_SESSIONS)
             return;
         keys
-            .sort((a, b) => new Date(this.sessions[a].createdAt).getTime() - new Date(this.sessions[b].createdAt).getTime())
+            .sort((a, b) => new Date(sessions[a].createdAt).getTime() - new Date(sessions[b].createdAt).getTime())
             .slice(0, keys.length - MAX_STORED_SESSIONS + 1)
-            .forEach((k) => delete this.sessions[k]);
+            .forEach((k) => delete sessions[k]);
     }
     cleanup() {
         let removed = 0;
         const now = Date.now();
-        for (const [k, stored] of Object.entries(this.sessions)) {
-            if (!stored || typeof stored !== 'object' || isExpired(stored.createdAt, stored.ttl, now)) {
-                delete this.sessions[k];
+        const stale = Object.entries(this.sessions)
+            .filter(([, stored]) => !stored || typeof stored !== 'object' || isExpired(stored.createdAt, stored.ttl, now))
+            .map(([k]) => k);
+        if (stale.length) {
+            const sessions = this.writableSessions();
+            for (const k of stale) {
+                delete sessions[k];
                 removed++;
             }
         }
@@ -265,9 +340,9 @@ class WorkflowVault {
     }
 }
 exports.WorkflowVault = WorkflowVault;
-function createVault(storage, store, passphrase) {
+function createVault(storage, store, passphrase, namespace = '') {
     if ((storage === 'workflow' || storage === 'file') && store) {
         return new WorkflowVault(store, passphrase || '');
     }
-    return new MemoryVault();
+    return new MemoryVault(namespace);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-redactor",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "Redact, mask and anonymize PII before it reaches an LLM, then restore it. 216 patterns for emails, phones, addresses, IBAN, cards, names, SSN, passport and tax IDs. Reversible encrypted vault, GDPR Art.30 ROPA record, prompt-injection check. Runs on n8n Cloud and self-hosted n8n 2.x.",
   "keywords": [
     "n8n-community-node-package",
@@ -63,8 +63,8 @@
     "build": "n8n-node build",
     "build:watch": "tsc --watch",
     "dev": "n8n-node dev",
-    "lint": "eslint package.json nodes",
-    "lint:fix": "eslint package.json nodes --fix",
+    "lint": "eslint package.json nodes credentials",
+    "lint:fix": "eslint package.json nodes credentials --fix",
     "test": "jest",
     "typecheck": "tsc --noEmit",
     "hooks": "git config core.hooksPath .husky"
@@ -72,13 +72,16 @@
   "files": [
     "dist",
     "!dist/**/*.map",
+    "!dist/**/*.d.ts",
     "README.md",
     "LICENSE"
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
     "strict": false,
-    "credentials": [],
+    "credentials": [
+      "dist/credentials/RedactorVaultApi.credentials.js"
+    ],
     "nodes": [
       "dist/nodes/Redactor/Redactor.node.js"
     ]

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

@@ -1,5 +0,0 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
-export declare class Redactor implements INodeType {
-    description: INodeTypeDescription;
-    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
-}

package/dist/nodes/Redactor/audit.d.ts

@@ -1,21 +0,0 @@
-import { RedactionHit, RedactionMode } from './types';
-import { ClassificationLabel } from './classification';
-export interface AuditLogEntry {
-    version: string;
-    timestamp: string;
-    eventId: string;
-    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-    action: string;
-    mode: RedactionMode | string;
-    status: 'SUCCESS' | 'PARTIAL' | 'FAILED';
-    totalHits: number;
-    hitsByCategory: Record<string, number>;
-    hitsByPattern: Record<string, number>;
-    classificationLevel?: string;
-    inputItemCount: number;
-    processingTimeMs: number;
-    patternsUsed: number;
-    presidioEnabled: boolean;
-    sessionId?: string;
-}
-export declare function buildAuditEntry(action: string, mode: RedactionMode | string, hits: RedactionHit[], inputItemCount: number, processingTimeMs: number, patternsUsed: number, presidioEnabled: boolean, classification?: ClassificationLabel, sessionId?: string): AuditLogEntry;

package/dist/nodes/Redactor/classification.d.ts

@@ -1,13 +0,0 @@
-import { PiiCategory, RedactionHit } from './types';
-export type SensitivityLevel = 'PUBLIC' | 'INTERNAL' | 'CONFIDENTIAL' | 'RESTRICTED';
-export interface ClassificationLabel {
-    level: SensitivityLevel;
-    numericLevel: 0 | 1 | 2 | 3;
-    reason: string;
-    topCategory: PiiCategory | 'none';
-    hitCountByLevel: Record<SensitivityLevel, number>;
-    escalated: boolean;
-    totalHits: number;
-    averageConfidence: number;
-}
-export declare function classifyData(hits: RedactionHit[]): ClassificationLabel;

package/dist/nodes/Redactor/context.d.ts

@@ -1,7 +0,0 @@
-export declare const CONTEXT_WORDS: Record<string, string[]>;
-export declare const SEMANTIC_CONFIDENCE = 0.9;
-export declare const AMBIGUOUS_FIELD_CONFIDENCE = 0.85;
-export declare const CUSTOM_PATTERN_CONFIDENCE = 0.7;
-export declare const DENY_LIST_CONFIDENCE = 1;
-export declare function hasContextWords(text: string, matchStart: number, matchEnd: number, words: string[]): boolean;
-export declare function calculateConfidence(patternName: string, hasValidator: boolean, validatorPassed: boolean, text: string, matchStart: number, matchEnd: number): number;