n8n-nodes-botarmor 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BotArmor AI
+
+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

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# n8n-nodes-botarmor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+n8n node for **BotArmor AI**: crash-test your customer-service chatbot (a red-teaming audit of its live webhook), wait for the grade, and stop a workflow when the bot is below your threshold — a CI-style gate for no-code bots.
+
+BotArmor tests bots you own, or that you have the owner's written permission to test. Every audit start asks you to confirm it.
+
+## Install
+
+In n8n: **Settings → Community Nodes → Install**, package name `n8n-nodes-botarmor`.
+
+## Credentials
+
+**BotArmor API**: a personal API key (`ba_live_…`) from the BotArmor dashboard, tab **API**. Revoke it there at any time.
+
+## Operations
+
+| Resource | Operation | What it does |
+|---|---|---|
+| Audit | Start | Starts a live audit of a registered agent (10–20 min). Returns `audit_code`. |
+| Audit | Retest | Re-runs a finished audit with your patched prompt; the report shows before/after per scenario. |
+| Audit | Get Status | `status` (running / completed / failed), `grade` (A–F), `gate.passed` against your minimum grade. With **Fail When Below Threshold**, the node errors (HTTP 412) on a weak bot and stops the workflow. |
+| Audit | Get Many | Your audits, newest first. |
+| Audit | Verify Report | Public check that a report is authentic, not altered, anchored and still current. |
+| Agent | Get Many | Your registered agents (ids for Start). |
+
+## Typical workflow
+
+`Start` → `Wait 10 min` → `Get Status` → `IF status = running` (loop back through a 5-min `Wait`) → `IF gate.passed` → publish / alert.
+
+A ready-made template is in [`templates/reaudit-on-prompt-change.json`](templates/reaudit-on-prompt-change.json): when the prompt cell of your bot changes in a Google Sheet, it retests the bot and posts the grade to Slack.
+
+## Languages
+
+Reports in English, French, German or Spanish (**Report Language**). The attacker speaks your bot's language: detected from its prompt by default, or set with **Bot Language** — a French agency can audit an English-speaking bot and get the report in French.
+
+## Development
+
+```bash
+npm install
+npm run build
+```
+
+No runtime dependencies: the node is declarative, each operation is one HTTPS call to the BotArmor API.
+
+Releases are published from GitHub Actions through npm Trusted Publishing, with provenance: bump the version in `package.json`, commit, and push a tag `v<version>`. No npm token is stored anywhere.
+
+## License
+
+MIT

package/dist/credentials/BotArmorApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotArmorApi = void 0;
+// A personal API key from the BotArmor dashboard (tab "API"). Sent as a Bearer token; never logged by the node.
+class BotArmorApi {
+    constructor() {
+        this.name = 'botArmorApi';
+        this.displayName = 'BotArmor API';
+        this.documentationUrl = 'https://botarmor-arena.netlify.app';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Starts with ba_live_. Create it in the BotArmor dashboard, tab "API".',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://vps-57bd57fc.vps.ovh.net',
+                description: 'Address of the BotArmor API',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: { headers: { Authorization: '=Bearer {{$credentials.apiKey}}' } },
+        };
+        this.test = {
+            request: { baseURL: '={{$credentials.baseUrl}}', url: '/api/agents' },
+        };
+    }
+}
+exports.BotArmorApi = BotArmorApi;

package/dist/nodes/BotArmor/BotArmor.node.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotArmor = void 0;
+// Declarative node: every operation is one call to the BotArmor API, no runtime dependency.
+// Typical workflow: Start Audit -> Wait 10 min -> Get Status (loop while "running") -> IF gate.passed.
+const LEVELS = [
+    ['logic', 'Logic Maze'],
+    ['toxic', 'Angry Customer'],
+    ['hacker', 'Fake CEO'],
+    ['lawyer', 'Scam Lawyer'],
+    ['multilang', 'Language Mix'],
+    ['loop', 'Infinite Loop'],
+    ['roleplay', 'Roleplay Trap'],
+    ['phishing', 'Payload & Phishing'],
+    ['ethics', 'Ethics & Compliance'],
+    ['burst', 'Multi-Turn Burst'],
+    ['disclosure', 'AI Disclosure (Art. 50)'],
+    ['facts', 'Invented Facts'],
+].map(([value, name]) => ({ name, value }));
+const AUTHORIZATION = "I confirm that I own this agent or hold the owner's written authorization to subject it to adversarial testing; I accept the rules of engagement (point-in-time test, test markers, consumption of the agent's operations) and I understand this test is not a certification.";
+class BotArmor {
+    constructor() {
+        this.description = {
+            displayName: 'BotArmor',
+            name: 'botArmor',
+            icon: 'file:botarmor.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Crash-test your chatbot with BotArmor AI and gate a workflow on its grade',
+            defaults: { name: 'BotArmor' },
+            inputs: ['main'],
+            outputs: ['main'],
+            usableAsTool: true,
+            credentials: [{ name: 'botArmorApi', required: true }],
+            requestDefaults: {
+                baseURL: '={{$credentials.baseUrl}}',
+                headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+            },
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Audit', value: 'audit' },
+                        { name: 'Agent', value: 'agent' },
+                    ],
+                    default: 'audit',
+                },
+                // ---------------- Audit ----------------
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['audit'] } },
+                    options: [
+                        {
+                            name: 'Start',
+                            value: 'start',
+                            action: 'Start an audit',
+                            description: 'Start a live audit of a registered agent (takes 10 to 20 minutes)',
+                            routing: { request: { method: 'POST', url: '/api/audits' } },
+                        },
+                        {
+                            name: 'Retest',
+                            value: 'retest',
+                            action: 'Retest after patches',
+                            description: 'Re-run a finished audit with the patched prompt; the report shows before/after',
+                            routing: { request: { method: 'POST', url: '=/api/audits/{{$parameter["auditCode"]}}/retest' } },
+                        },
+                        {
+                            name: 'Get Status',
+                            value: 'getStatus',
+                            action: 'Get the status and grade of an audit',
+                            description: 'Status (running, completed, failed), grade and whether it meets your threshold',
+                            routing: { request: { method: 'GET', url: '=/api/audits/{{$parameter["auditCode"]}}/status' } },
+                        },
+                        {
+                            name: 'Get Many',
+                            value: 'getAll',
+                            action: 'List audits',
+                            routing: {
+                                request: { method: 'GET', url: '/api/audits' },
+                                output: { postReceive: [{ type: 'rootProperty', properties: { property: 'audits' } }] },
+                            },
+                        },
+                        {
+                            name: 'Verify Report',
+                            value: 'verify',
+                            action: 'Verify a report',
+                            description: 'Check that a report is authentic and still current (public, signed, anchored)',
+                            routing: { request: { method: 'GET', url: '=/verify/{{$parameter["auditCode"]}}?format=json' } },
+                        },
+                    ],
+                    default: 'start',
+                },
+                {
+                    displayName: 'Agent ID',
+                    name: 'agentId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'ID of the agent registered in BotArmor (Agent > Get Many lists them)',
+                    displayOptions: { show: { resource: ['audit'], operation: ['start'] } },
+                    routing: { send: { type: 'body', property: 'agent_id' } },
+                },
+                {
+                    displayName: 'Audit Code',
+                    name: 'auditCode',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    placeholder: 'BA-XXXXXXXX',
+                    displayOptions: { show: { resource: ['audit'], operation: ['retest', 'getStatus', 'verify'] } },
+                },
+                {
+                    displayName: 'System Prompt',
+                    name: 'systemPrompt',
+                    type: 'string',
+                    typeOptions: { rows: 6 },
+                    required: true,
+                    default: '',
+                    description: "Your bot's instructions, used as the judge's rulebook. BotArmor stores only its SHA-256.",
+                    displayOptions: { show: { resource: ['audit'], operation: ['start', 'retest'] } },
+                    routing: { send: { type: 'body', property: 'system_prompt' } },
+                },
+                {
+                    displayName: 'Knowledge Base',
+                    name: 'knowledgeBase',
+                    type: 'string',
+                    typeOptions: { rows: 3 },
+                    default: '',
+                    description: 'Price list, opening hours… (optional)',
+                    displayOptions: { show: { resource: ['audit'], operation: ['start', 'retest'] } },
+                    routing: { send: { type: 'body', property: 'knowledge_base' } },
+                },
+                {
+                    displayName: 'I Own This Agent or Have Written Permission to Test It',
+                    name: 'authorizationConfirmed',
+                    type: 'boolean',
+                    required: true,
+                    default: false,
+                    description: AUTHORIZATION,
+                    displayOptions: { show: { resource: ['audit'], operation: ['start', 'retest'] } },
+                    routing: { send: { type: 'body', property: 'authorization_confirmed' } },
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: { show: { resource: ['audit'], operation: ['start'] } },
+                    options: [
+                        {
+                            displayName: 'Scenarios',
+                            name: 'levels',
+                            type: 'multiOptions',
+                            options: LEVELS,
+                            default: [],
+                            description: 'Attack scenarios to run (all when empty)',
+                            routing: { send: { type: 'body', property: 'levels' } },
+                        },
+                        {
+                            displayName: 'Report Language',
+                            name: 'lang',
+                            type: 'options',
+                            options: [
+                                { name: 'English', value: 'en' },
+                                { name: 'French', value: 'fr' },
+                                { name: 'German', value: 'de' },
+                                { name: 'Spanish', value: 'es' },
+                            ],
+                            default: 'fr',
+                            description: 'Language of the report, for whoever reads it',
+                            routing: { send: { type: 'body', property: 'lang' } },
+                        },
+                        {
+                            displayName: 'Bot Language',
+                            name: 'botLang',
+                            type: 'options',
+                            options: [
+                                { name: 'Detect From the Prompt', value: '' },
+                                { name: 'Dutch', value: 'nl' },
+                                { name: 'English', value: 'en' },
+                                { name: 'French', value: 'fr' },
+                                { name: 'German', value: 'de' },
+                                { name: 'Italian', value: 'it' },
+                                { name: 'Portuguese', value: 'pt' },
+                                { name: 'Spanish', value: 'es' },
+                            ],
+                            default: '',
+                            description: 'Language the attacker speaks to your bot. Can differ from the report language.',
+                            routing: { send: { type: 'body', property: 'bot_lang' } },
+                        },
+                        {
+                            displayName: 'Test Google Sheet ID',
+                            name: 'spreadsheetId',
+                            type: 'string',
+                            default: '',
+                            description: 'A TEST sheet shared with the BotArmor service account as Editor; checks what the bot writes',
+                            routing: { send: { type: 'body', property: 'backend.spreadsheet_id' } },
+                        },
+                        {
+                            displayName: 'Test Sheet Range',
+                            name: 'range',
+                            type: 'string',
+                            default: 'Sheet1!A1:H',
+                            routing: { send: { type: 'body', property: 'backend.range' } },
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Minimum Grade',
+                    name: 'minGrade',
+                    type: 'options',
+                    options: ['A', 'B', 'C', 'D', 'F'].map((g) => ({ name: g, value: g })),
+                    default: 'B',
+                    description: 'Threshold for gate.passed',
+                    displayOptions: { show: { resource: ['audit'], operation: ['getStatus'] } },
+                    routing: { send: { type: 'query', property: 'min_grade' } },
+                },
+                {
+                    displayName: 'Fail When Below Threshold',
+                    name: 'strict',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to make the node error (HTTP 412) when a finished audit is below the minimum grade, stopping the workflow',
+                    displayOptions: { show: { resource: ['audit'], operation: ['getStatus'] } },
+                    routing: { send: { type: 'query', property: 'strict', value: '={{$value ? 1 : 0}}' } },
+                },
+                // ---------------- Agent ----------------
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['agent'] } },
+                    options: [
+                        {
+                            name: 'Get Many',
+                            value: 'getAll',
+                            action: 'List agents',
+                            routing: {
+                                request: { method: 'GET', url: '/api/agents' },
+                                output: { postReceive: [{ type: 'rootProperty', properties: { property: 'agents' } }] },
+                            },
+                        },
+                    ],
+                    default: 'getAll',
+                },
+            ],
+        };
+    }
+}
+exports.BotArmor = BotArmor;

package/dist/nodes/BotArmor/botarmor.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#22d3ee"/><path d="M32 10 14 17v13c0 12 7.7 21.3 18 24 10.3-2.7 18-12 18-24V17L32 10z" fill="#0b1120"/><text x="32" y="40" text-anchor="middle" font-family="Arial,Helvetica,sans-serif" font-weight="700" font-size="16" fill="#22d3ee">BA</text></svg>

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "n8n-nodes-botarmor",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "n8n node for BotArmor AI: crash-test your chatbot (red-teaming audit), wait for the grade and stop a workflow when it is below your threshold.",
+  "keywords": [
+    "n8n-community-node-package",
+    "botarmor",
+    "chatbot",
+    "red-teaming",
+    "ai-security",
+    "audit"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/sidorenkav-collab/n8n-nodes-botarmor#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sidorenkav-collab/n8n-nodes-botarmor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sidorenkav-collab/n8n-nodes-botarmor/issues"
+  },
+  "author": {
+    "name": "BotArmor AI"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').cpSync('nodes/BotArmor/botarmor.svg','dist/nodes/BotArmor/botarmor.svg')\"",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/BotArmorApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/BotArmor/BotArmor.node.js"
+    ]
+  },
+  "devDependencies": {
+    "n8n-workflow": "2.16.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}