n8n-nodes-soterai 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to `n8n-nodes-soterai` will be documented in this file.
+
+## [0.1.0] - 2026-06-26
+
+### Added
+
+- Initial release of the SoterAI community node for n8n.
+- **Input Guard** action: scan user messages for prompt injection, jailbreaks, and other threats before they reach the LLM.
+- **Output Guard** action: scan AI-generated responses for unsafe content before sending to users.
+- **PII Redactor** action: detect and redact sensitive data (emails, phone numbers, secrets) with configurable redaction modes (partial, full, hash).
+- **RAG Scanner** action: scan documents and chunks for embedded threats before adding to vector databases.
+- **Incident Logger** action: log security incidents to the SoterAI ops dashboard with platform, workflow ID, risk score, and reason.
+- Configurable **Policy Mode** (Monitor, Balanced, Strict) for input and output guards.
+- Configurable **On Threat** behavior (Block, Redact, Warn, Continue).
+- Optional per-node **Project ID** override and **Metadata JSON** for audit trails.
+- Example workflow: Protected Chatbot with input guard, threat routing, and output guard.
+- SoterAI API credential type with API key, base URL, and default project ID.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 SoterAI
+
+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,190 @@
+# n8n-nodes-soterai
+
+[![npm version](https://img.shields.io/npm/v/n8n-nodes-soterai.svg)](https://www.npmjs.com/package/n8n-nodes-soterai)
+[![n8n community node](https://img.shields.io/badge/n8n-community%20node-ff6d5a)](https://n8n.io)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+SoterAI community node for [n8n](https://n8n.io) -- protect your AI workflows from prompt injection, jailbreaks, PII leakage, and unsafe outputs.
+
+SoterAI is an AI security platform that sits between your users and your LLMs. It analyses every input and output in real time, blocks threats, redacts sensitive data, and records incidents for audit review. This n8n node lets you add that protection to any n8n workflow with drag-and-drop.
+
+## Installation
+
+### From the n8n GUI (recommended)
+
+1. Open your n8n instance.
+2. Go to **Settings > Community Nodes**.
+3. Enter `n8n-nodes-soterai` and click **Install**.
+4. The **SoterAI** node will appear in your node panel.
+
+### From npm
+
+```bash
+cd ~/.n8n
+npm install n8n-nodes-soterai
+```
+
+Restart n8n after installation.
+
+## Credentials Setup
+
+1. Sign up at [https://app.soterai.dev](https://app.soterai.dev) and create a project.
+2. Generate an API key from the project dashboard (it starts with `sk_`).
+3. In n8n, go to **Credentials > New Credential > SoterAI API**.
+4. Paste your API key.
+5. (Optional) Set a **Base URL** if you are running a self-hosted SoterAI instance.
+6. (Optional) Set a default **Project ID** -- this can also be overridden per node.
+
+Full credential documentation: [https://docs.soterai.dev/integrations/n8n](https://docs.soterai.dev/integrations/n8n)
+
+## Actions
+
+### SoterAI Input Guard
+
+Check user messages for prompt injection, jailbreaks, and other threats **before** they reach the LLM.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| Input Text | string | The user message to analyse |
+| Policy Mode | MONITOR / BALANCED / STRICT | Server-side policy strictness |
+| On Threat | BLOCK / REDACT / WARN / CONTINUE | Local behavior when a threat is detected |
+| Project ID | string | Optional project override |
+| Metadata JSON | string | Optional audit metadata (JSON object) |
+
+### SoterAI Output Guard
+
+Check AI-generated responses for unsafe content, hallucinated PII, or policy violations **before** sending them to users.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| AI Output Text | string | The AI response to analyse |
+| Policy Mode | MONITOR / BALANCED / STRICT | Server-side policy strictness |
+| On Threat | BLOCK / REDACT / WARN / CONTINUE | Local behavior when a threat is detected |
+| Project ID | string | Optional project override |
+| Metadata JSON | string | Optional audit metadata (JSON object) |
+
+### SoterAI PII Redactor
+
+Detect and redact sensitive data (emails, phone numbers, API keys, secrets) from any text.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| Text | string | The text to scan for PII |
+| Redaction Mode | PARTIAL / FULL / HASH | How detected PII is replaced |
+| Project ID | string | Optional project override |
+| Metadata JSON | string | Optional audit metadata (JSON object) |
+
+### SoterAI RAG Scanner
+
+Scan documents and text chunks for embedded threats, hidden instructions, or data poisoning **before** adding them to a vector database.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| Document Text | string | The document or chunk text to scan |
+| Source Name | string | Optional label for the document source |
+| Project ID | string | Optional project override |
+| Metadata JSON | string | Optional audit metadata (JSON object) |
+
+### SoterAI Incident Logger
+
+Log a security incident to the SoterAI ops dashboard for security review. This action requires admin-level API access and will return a graceful no-op if the caller lacks the required permissions.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| Platform | string | Where the incident originated (default: `n8n`) |
+| Workflow ID | string | ID of the workflow where the incident was detected |
+| Risk Score | number | Risk score from 0.0 to 1.0 |
+| Reason | string | Human-readable incident description |
+| Project ID | string | Optional project override |
+| Metadata JSON | string | Optional audit metadata (JSON object) |
+
+## Output Fields
+
+### Input Guard / Output Guard
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `allowed` | boolean | Whether the API considers the text safe |
+| `blocked` | boolean | Whether the node blocked the item (based on On Threat) |
+| `riskScore` | number | Risk score from 0.0 to 1.0 |
+| `categories` | string[] | Array of detected risk types |
+| `safeText` | string | Redacted/safe version of the text |
+| `outputText` | string | The text to use downstream (empty if blocked) |
+| `reason` | string | Human-readable explanation |
+| `warning` | string | Present when On Threat is WARN |
+| `incidentId` | string | Incident ID if one was created |
+| `rawResponse` | object | Full API response for advanced use |
+
+### PII Redactor
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `safeText` | string | Text with PII redacted |
+| `detectedEntities` | array | List of detected PII entities with type, label, severity |
+| `riskScore` | number | Overall risk score |
+| `rawResponse` | object | Full API response |
+
+### RAG Scanner
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `allowed` | boolean | Whether the document is safe to ingest |
+| `riskScore` | number | Overall risk score |
+| `issues` | array | List of issues with type, severity, message |
+| `safeText` | string | Cleaned version of the document |
+| `incidentId` | string | Incident ID if one was created |
+| `rawResponse` | object | Full API response |
+
+### Incident Logger
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `logged` | boolean | Whether the incident was successfully logged |
+| `incidentId` | string | ID of the created incident (if logged) |
+| `reason` | string | Explanation if logging failed (e.g. insufficient permissions) |
+| `rawResponse` | object | Full API response |
+
+## Example Workflow
+
+An importable example workflow is included at `examples/protected-chatbot-workflow.json`.
+
+The workflow implements a protected chatbot pattern:
+
+```
+[Webhook] -> [SoterAI Input Guard] -> [IF blocked?]
+                                          |-- Yes -> [Reply: "Blocked"]
+                                          |-- No  -> [OpenAI Chat] -> [SoterAI Output Guard] -> [Reply]
+```
+
+To import: in n8n, go to **Workflows > Import from File** and select the JSON file.
+
+## Privacy and Security
+
+- **API keys** are stored in n8n's encrypted credential store and are never logged or exposed in workflow outputs.
+- **All security analysis** happens server-side via the SoterAI policy engine. No user data is analysed locally.
+- **Nodes are stateless connectors** -- no user data, messages, or documents are stored locally by the node.
+- **Network traffic** uses HTTPS exclusively. The node communicates only with your configured SoterAI API endpoint.
+- **No telemetry** is collected by this node.
+
+## Resources
+
+- [SoterAI Documentation](https://docs.soterai.dev)
+- [n8n Integration Guide](https://docs.soterai.dev/integrations/n8n)
+- [SoterAI Dashboard](https://app.soterai.dev)
+- [Privacy Policy](https://soterai.dev/privacy)
+- [Terms of Service](https://soterai.dev/terms)
+- [Pricing](https://soterai.dev/pricing)
+- [Status](https://soterai.dev/status)
+- [Support](https://soterai.dev/support)
+- [GitHub Repository](https://github.com/SoterAI/n8n-nodes-soterai)
+- [npm Package](https://www.npmjs.com/package/n8n-nodes-soterai)
+
+## Support
+
+- **Email**: support@soterai.dev
+- **GitHub Issues**: [https://github.com/SoterAI/n8n-nodes-soterai/issues](https://github.com/SoterAI/n8n-nodes-soterai/issues)
+- **Documentation**: [https://docs.soterai.dev](https://docs.soterai.dev)
+
+## License
+
+[MIT](LICENSE)

package/dist/credentials/SoterApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import type { ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class SoterApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/SoterApi.credentials.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoterApi = void 0;
+class SoterApi {
+    constructor() {
+        this.name = "soterApi";
+        this.displayName = "SoterAI API";
+        this.documentationUrl = "https://docs.soterai.dev/integrations/n8n";
+        this.properties = [
+            {
+                displayName: "API Key",
+                name: "apiKey",
+                type: "string",
+                typeOptions: { password: true },
+                default: "",
+                required: true,
+                description: "Your SoterAI API key (sk_...)",
+            },
+            {
+                displayName: "Base URL",
+                name: "baseUrl",
+                type: "string",
+                default: "https://api.soterai.dev",
+                description: "SoterAI API base URL. Change only for self-hosted deployments.",
+            },
+            {
+                displayName: "Project ID",
+                name: "projectId",
+                type: "string",
+                default: "",
+                description: "Default project ID for all requests (optional, can be set per node)",
+            },
+        ];
+    }
+}
+exports.SoterApi = SoterApi;

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

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

package/dist/nodes/SoterGuard.node.js

@@ -0,0 +1,504 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoterGuard = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class SoterGuard {
+    constructor() {
+        this.description = {
+            displayName: "SoterAI",
+            name: "soterGuard",
+            icon: "file:soterai.png",
+            group: ["transform"],
+            version: 1,
+            subtitle: '={{$parameter["action"]}}',
+            description: "Protect AI workflows with SoterAI — input/output guard, PII redaction, RAG document scanning",
+            defaults: {
+                name: "SoterAI",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "soterApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Action",
+                    name: "action",
+                    type: "options",
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: "SoterAI Input Guard",
+                            value: "inputGuard",
+                            description: "Check user message before it reaches the LLM",
+                            action: "Check user input for threats",
+                        },
+                        {
+                            name: "SoterAI Output Guard",
+                            value: "outputGuard",
+                            description: "Check AI response before it is sent to the user",
+                            action: "Check AI output for threats",
+                        },
+                        {
+                            name: "SoterAI PII Redactor",
+                            value: "piiRedactor",
+                            description: "Redact sensitive data (PII, secrets) from any text",
+                            action: "Redact PII from text",
+                        },
+                        {
+                            name: "SoterAI RAG Scanner",
+                            value: "ragScanner",
+                            description: "Scan documents/chunks before adding to RAG/vector DB",
+                            action: "Scan RAG document for threats",
+                        },
+                        {
+                            name: "SoterAI Incident Logger",
+                            value: "incidentLogger",
+                            description: "Log a security incident to the SoterAI ops dashboard. Requires admin access; returns a graceful no-op if the caller lacks permissions.",
+                            action: "Log security incident",
+                        },
+                    ],
+                    default: "inputGuard",
+                },
+                // ── Input Guard fields ──
+                {
+                    displayName: "Input Text",
+                    name: "inputText",
+                    type: "string",
+                    typeOptions: { rows: 4 },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["inputGuard"] } },
+                    description: "The user message to check for prompt injection, jailbreaks, and other threats",
+                },
+                // ── Output Guard fields ──
+                {
+                    displayName: "AI Output Text",
+                    name: "outputText",
+                    type: "string",
+                    typeOptions: { rows: 4 },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["outputGuard"] } },
+                    description: "The AI-generated response to check before sending to the user",
+                },
+                // ── PII Redactor fields ──
+                {
+                    displayName: "Text",
+                    name: "piiText",
+                    type: "string",
+                    typeOptions: { rows: 4 },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["piiRedactor"] } },
+                    description: "The text to scan and redact PII from",
+                },
+                {
+                    displayName: "Redaction Mode",
+                    name: "redactionMode",
+                    type: "options",
+                    options: [
+                        { name: "Partial", value: "PARTIAL", description: "Partially mask sensitive data" },
+                        { name: "Full", value: "FULL", description: "Fully replace sensitive data with tokens" },
+                        { name: "Hash", value: "HASH", description: "Replace with deterministic hashes" },
+                    ],
+                    default: "PARTIAL",
+                    displayOptions: { show: { action: ["piiRedactor"] } },
+                    description: "How to redact detected PII",
+                },
+                // ── RAG Scanner fields ──
+                {
+                    displayName: "Document Text",
+                    name: "ragText",
+                    type: "string",
+                    typeOptions: { rows: 4 },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["ragScanner"] } },
+                    description: "Document or chunk text to scan before adding to a vector database",
+                },
+                {
+                    displayName: "Source Name",
+                    name: "sourceName",
+                    type: "string",
+                    default: "",
+                    displayOptions: { show: { action: ["ragScanner"] } },
+                    description: 'Optional label for the document source (e.g. "uploaded-pdf", "web-scrape")',
+                },
+                // ── Incident Logger fields ──
+                {
+                    displayName: "Platform",
+                    name: "incidentPlatform",
+                    type: "string",
+                    default: "n8n",
+                    required: true,
+                    displayOptions: { show: { action: ["incidentLogger"] } },
+                    description: 'Platform where the incident originated (e.g. "n8n", "slack", "api")',
+                },
+                {
+                    displayName: "Workflow ID",
+                    name: "incidentWorkflowId",
+                    type: "string",
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["incidentLogger"] } },
+                    description: "ID of the workflow or process where the incident was detected",
+                },
+                {
+                    displayName: "Risk Score",
+                    name: "incidentRiskScore",
+                    type: "number",
+                    typeOptions: { minValue: 0, maxValue: 1, numberStepSize: 0.01 },
+                    default: 0,
+                    required: true,
+                    displayOptions: { show: { action: ["incidentLogger"] } },
+                    description: "Risk score from 0.0 (safe) to 1.0 (critical)",
+                },
+                {
+                    displayName: "Reason",
+                    name: "incidentReason",
+                    type: "string",
+                    typeOptions: { rows: 2 },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { action: ["incidentLogger"] } },
+                    description: "Human-readable reason or description for the incident",
+                },
+                // ── Common fields ──
+                {
+                    displayName: "Project ID",
+                    name: "projectId",
+                    type: "string",
+                    default: "",
+                    description: "SoterAI project ID (overrides the credential default)",
+                },
+                {
+                    displayName: "Policy Mode",
+                    name: "policyMode",
+                    type: "options",
+                    options: [
+                        { name: "Monitor", value: "MONITOR", description: "Log threats but allow all traffic" },
+                        { name: "Balanced", value: "BALANCED", description: "Block high-risk, allow medium with redaction" },
+                        { name: "Strict", value: "STRICT", description: "Block anything above low risk" },
+                    ],
+                    default: "BALANCED",
+                    displayOptions: { show: { action: ["inputGuard", "outputGuard"] } },
+                    description: "Server-side policy strictness",
+                },
+                {
+                    displayName: "On Threat",
+                    name: "onThreat",
+                    type: "options",
+                    options: [
+                        { name: "Block", value: "BLOCK", description: "Stop the workflow item" },
+                        { name: "Redact", value: "REDACT", description: "Continue with redacted safe text" },
+                        { name: "Warn", value: "WARN", description: "Continue but flag the threat in output" },
+                        { name: "Continue", value: "CONTINUE", description: "Ignore the threat and continue" },
+                    ],
+                    default: "BLOCK",
+                    displayOptions: { show: { action: ["inputGuard", "outputGuard"] } },
+                    description: "What to do locally when SoterAI flags a threat",
+                },
+                {
+                    displayName: "Metadata JSON",
+                    name: "metadata",
+                    type: "string",
+                    typeOptions: { rows: 2 },
+                    default: "",
+                    description: "Optional JSON metadata to attach to the request for audit logging",
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials("soterApi");
+        const apiKey = credentials.apiKey;
+        const baseUrl = credentials.baseUrl || "https://api.soterai.dev";
+        const credentialProjectId = credentials.projectId || undefined;
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const action = this.getNodeParameter("action", i);
+                const projectId = this.getNodeParameter("projectId", i, "") || credentialProjectId;
+                const metadataRaw = this.getNodeParameter("metadata", i, "");
+                const metadata = metadataRaw ? parseMetadata(metadataRaw) : undefined;
+                let result;
+                switch (action) {
+                    case "inputGuard": {
+                        const text = this.getNodeParameter("inputText", i);
+                        const policyMode = this.getNodeParameter("policyMode", i);
+                        const onThreat = this.getNodeParameter("onThreat", i);
+                        result = await executeInputGuard(apiKey, baseUrl, {
+                            text, projectId, policyMode, onThreat, metadata,
+                        });
+                        break;
+                    }
+                    case "outputGuard": {
+                        const text = this.getNodeParameter("outputText", i);
+                        const policyMode = this.getNodeParameter("policyMode", i);
+                        const onThreat = this.getNodeParameter("onThreat", i);
+                        result = await executeOutputGuard(apiKey, baseUrl, {
+                            text, projectId, policyMode, onThreat, metadata,
+                        });
+                        break;
+                    }
+                    case "piiRedactor": {
+                        const text = this.getNodeParameter("piiText", i);
+                        const redactionMode = this.getNodeParameter("redactionMode", i);
+                        result = await executePiiRedactor(apiKey, baseUrl, {
+                            text, projectId, redactionMode, metadata,
+                        });
+                        break;
+                    }
+                    case "ragScanner": {
+                        const text = this.getNodeParameter("ragText", i);
+                        const sourceName = this.getNodeParameter("sourceName", i, "");
+                        result = await executeRagScanner(apiKey, baseUrl, {
+                            text, projectId, sourceName, metadata,
+                        });
+                        break;
+                    }
+                    case "incidentLogger": {
+                        const platform = this.getNodeParameter("incidentPlatform", i);
+                        const workflowId = this.getNodeParameter("incidentWorkflowId", i);
+                        const riskScore = this.getNodeParameter("incidentRiskScore", i);
+                        const reason = this.getNodeParameter("incidentReason", i);
+                        result = await executeIncidentLogger(apiKey, baseUrl, {
+                            platform, workflowId, riskScore, reason, projectId, metadata,
+                        });
+                        break;
+                    }
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown action: ${action}`, { itemIndex: i });
+                }
+                returnData.push({ json: result });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: true,
+                            message: error instanceof Error ? error.message : "SoterAI request failed.",
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.SoterGuard = SoterGuard;
+async function soterPost(apiKey, baseUrl, path, body) {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "User-Agent": "n8n-nodes-soterai/0.1.0",
+        },
+        body: JSON.stringify(body),
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        const msg = typeof data.message === "string" ? data.message : `SoterAI API error ${response.status}`;
+        throw new Error(msg);
+    }
+    return data;
+}
+async function executeInputGuard(apiKey, baseUrl, params) {
+    const meta = { ...params.metadata };
+    if (params.projectId)
+        meta.projectId = params.projectId;
+    if (params.policyMode)
+        meta.policyMode = params.policyMode;
+    const raw = await soterPost(apiKey, baseUrl, "/api/guard/input", {
+        message: params.text,
+        metadata: meta,
+    });
+    const allowed = raw.allowed;
+    const result = {
+        allowed,
+        riskScore: raw.riskScore ?? 0,
+        categories: raw.riskTypes ?? [],
+        safeText: raw.safeText ?? raw.redactedText ?? params.text,
+        reason: raw.reason ?? "",
+        incidentId: raw.incidentId ?? null,
+        rawResponse: raw,
+    };
+    if (!allowed && params.onThreat) {
+        switch (params.onThreat) {
+            case "BLOCK":
+                result.blocked = true;
+                result.outputText = "";
+                break;
+            case "REDACT":
+                result.blocked = false;
+                result.outputText = raw.safeText ?? raw.redactedText ?? "[REDACTED]";
+                break;
+            case "WARN":
+                result.blocked = false;
+                result.outputText = params.text;
+                result.warning = raw.reason ?? "";
+                break;
+            case "CONTINUE":
+                result.blocked = false;
+                result.outputText = params.text;
+                break;
+        }
+    }
+    else {
+        result.blocked = false;
+        result.outputText = raw.safeText ?? raw.redactedText ?? params.text;
+    }
+    return result;
+}
+async function executeOutputGuard(apiKey, baseUrl, params) {
+    const meta = { ...params.metadata };
+    if (params.projectId)
+        meta.projectId = params.projectId;
+    if (params.policyMode)
+        meta.policyMode = params.policyMode;
+    const raw = await soterPost(apiKey, baseUrl, "/api/guard/output", {
+        aiResponse: params.text,
+        metadata: meta,
+    });
+    const allowed = raw.allowed;
+    const result = {
+        allowed,
+        riskScore: raw.riskScore ?? 0,
+        categories: raw.riskTypes ?? [],
+        safeText: raw.safeText ?? raw.redactedText ?? params.text,
+        reason: raw.reason ?? "",
+        incidentId: raw.incidentId ?? null,
+        rawResponse: raw,
+    };
+    if (!allowed && params.onThreat) {
+        switch (params.onThreat) {
+            case "BLOCK":
+                result.blocked = true;
+                result.outputText = "";
+                break;
+            case "REDACT":
+                result.blocked = false;
+                result.outputText = raw.safeText ?? raw.redactedText ?? "[REDACTED]";
+                break;
+            case "WARN":
+                result.blocked = false;
+                result.outputText = params.text;
+                result.warning = raw.reason ?? "";
+                break;
+            case "CONTINUE":
+                result.blocked = false;
+                result.outputText = params.text;
+                break;
+        }
+    }
+    else {
+        result.blocked = false;
+        result.outputText = raw.safeText ?? raw.redactedText ?? params.text;
+    }
+    return result;
+}
+async function executePiiRedactor(apiKey, baseUrl, params) {
+    const meta = { ...params.metadata };
+    if (params.projectId)
+        meta.projectId = params.projectId;
+    if (params.redactionMode)
+        meta._redactionMode = params.redactionMode;
+    const raw = await soterPost(apiKey, baseUrl, "/api/guard/input", {
+        message: params.text,
+        metadata: meta,
+    });
+    const findings = raw.findings ?? [];
+    const piiEntities = findings
+        .filter((f) => f.type === "PII_DETECTED" || f.type === "INDIA_PII_DETECTED" || f.type === "SECRET_DETECTED")
+        .map((f) => ({
+        type: f.type,
+        label: f.label,
+        severity: f.severity,
+    }));
+    return {
+        safeText: raw.safeText ?? raw.redactedText ?? params.text,
+        detectedEntities: piiEntities,
+        riskScore: raw.riskScore ?? 0,
+        rawResponse: raw,
+    };
+}
+async function executeRagScanner(apiKey, baseUrl, params) {
+    const meta = { ...params.metadata, _ragScan: true };
+    if (params.projectId)
+        meta.projectId = params.projectId;
+    if (params.sourceName)
+        meta._sourceName = params.sourceName;
+    const raw = await soterPost(apiKey, baseUrl, "/api/guard/input", {
+        message: params.text,
+        metadata: meta,
+    });
+    const findings = raw.findings ?? [];
+    const issues = findings.map((f) => ({
+        type: f.type,
+        severity: f.severity,
+        message: f.message ?? f.label,
+    }));
+    return {
+        allowed: raw.allowed,
+        riskScore: raw.riskScore ?? 0,
+        issues: issues,
+        safeText: raw.safeText ?? raw.redactedText ?? params.text,
+        incidentId: raw.incidentId ?? null,
+        rawResponse: raw,
+    };
+}
+async function executeIncidentLogger(apiKey, baseUrl, params) {
+    const body = {
+        platform: params.platform,
+        workflowId: params.workflowId,
+        riskScore: params.riskScore,
+        reason: params.reason,
+    };
+    if (params.projectId)
+        body.projectId = params.projectId;
+    if (params.metadata)
+        body.metadata = params.metadata;
+    try {
+        const raw = await soterPost(apiKey, baseUrl, "/api/ops/incidents", body);
+        return {
+            logged: true,
+            incidentId: raw.incidentId ?? raw.id ?? null,
+            rawResponse: raw,
+        };
+    }
+    catch (error) {
+        // Graceful no-op: if the caller lacks admin permissions, return success with logged=false
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("403") || message.includes("401") || message.includes("Forbidden") || message.includes("Unauthorized")) {
+            return {
+                logged: false,
+                reason: "Insufficient permissions to log incidents. Admin access is required.",
+                rawResponse: { error: message },
+            };
+        }
+        throw error;
+    }
+}
+function parseMetadata(raw) {
+    if (!raw.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore invalid JSON — don't break the workflow for optional metadata
+    }
+    return undefined;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "n8n-nodes-soterai",
+  "version": "0.1.0",
+  "description": "SoterAI adds prompt injection, jailbreak, PII leakage, and unsafe output protection to AI workflows.",
+  "license": "MIT",
+  "author": {
+    "name": "SoterAI",
+    "email": "support@soterai.dev",
+    "url": "https://soterai.dev"
+  },
+  "homepage": "https://github.com/SoterAI/n8n-nodes-soterai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SoterAI/n8n-nodes-soterai.git"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "ai-security",
+    "prompt-injection",
+    "jailbreak",
+    "pii",
+    "soter",
+    "soterai",
+    "guardrails"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/SoterApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/SoterGuard.node.js"
+    ]
+  },
+  "main": "dist/nodes/SoterGuard.node.js",
+  "files": [
+    "dist",
+    "nodes/*.png",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc && copyfiles \"nodes/*.png\" dist",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
+  },
+  "devDependencies": {
+    "copyfiles": "^2.4.1",
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.0.0"
+  }
+}