@xshieldai/n8n-nodes 1.1.0

package/README.md

@@ -0,0 +1,70 @@
+# @ankr/n8n-nodes-kavachos
+
+**KavachOS n8n community nodes** — pre-execution DAN gate and kernel enforcement for AI agents.
+
+Part of the **xShieldAI Posture Suite** · [kavachos.xshieldai.com](https://kavachos.xshieldai.com)
+
+---
+
+## Nodes
+
+### KavachGate
+
+Intercepts AI agent actions **before execution**. Calls the Aegis KAVACH HTTP gate to:
+
+1. Classify danger level (DAN 1–4)
+2. Notify approvers via Telegram / WhatsApp (opt-in, requires `webhook_url` in `~/.aegis/config.json`)
+3. Wait for ALLOW or STOP
+4. Block the workflow on STOP or timeout (silence = STOP)
+
+**Framework-neutral**: all policy lives in Aegis (`localhost:4850`). The n8n node is a thin HTTP client.
+
+### KavachRun
+
+Wraps a subprocess in kavachos **kernel enforcement** (seccomp-bpf + cgroup BPF egress firewall).
+
+- Linux only — gracefully degrades on macOS/Windows with a configurable fallback (warn / skip / throw)
+- Use **after** KavachGate for defense in depth: policy gate + kernel enforcement
+- `trust_mask` controls which syscall groups the process may call
+- `domain` selects the egress allowlist (maritime, logistics, OT, finance, general)
+
+---
+
+## Install
+
+```bash
+# In your n8n data directory
+npm install @ankr/n8n-nodes-kavachos
+```
+
+Then restart n8n and add the **Aegis API** credential pointing to your Aegis dashboard (`http://localhost:4850` by default).
+
+---
+
+## Quick Start
+
+1. **Start Aegis**: `npx @rocketlang/aegis` (or `kavachos run n8n --domain=general`)
+2. **Add credential**: Aegis API → base URL `http://localhost:4850`
+3. **Import template**: `examples/n8n-governed-agent.json`
+4. **Run**: Trigger → KavachGate → AI Agent → Audit
+
+---
+
+## Gate API
+
+The `KavachGate` node calls:
+
+```
+POST http://localhost:4850/api/v1/kavach/gate
+{ "command": "...", "tool_name": "n8n-agent", "session_id": "...", "dry_run": false }
+
+→ { "allow": true|false, "level": 0-4, "reason": "...", "decision": "ALLOW|STOP|TIMEOUT", "approval_id": "...", "_meta": {...} }
+```
+
+`allow: false` → KavachGate throws (halt workflow) or passes `allow=false` downstream — configurable per node.
+
+---
+
+## License
+
+AGPL-3.0 — governance layer is open. Enterprise Edition (multi-tenant, Merkle ledger, EU AI Act evidence): [xshieldai.com](https://xshieldai.com)

package/dist/credentials/AegisApi.credentials.d.ts

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

package/dist/credentials/AegisApi.credentials.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AegisApi = void 0;
+class AegisApi {
+    constructor() {
+        this.name = "aegisApi";
+        this.displayName = "Aegis API";
+        this.documentationUrl = "https://kavachos.xshieldai.com";
+        this.properties = [
+            {
+                displayName: "Aegis Base URL",
+                name: "baseUrl",
+                type: "string",
+                default: "http://localhost:4850",
+                placeholder: "http://localhost:4850",
+                description: "URL of the Aegis dashboard server (runs POST /api/v1/kavach/gate)",
+            },
+            {
+                displayName: "API Token (optional)",
+                name: "token",
+                type: "string",
+                typeOptions: { password: true },
+                default: "",
+                description: "Bearer token if Aegis dashboard auth is enabled",
+            },
+        ];
+    }
+}
+exports.AegisApi = AegisApi;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { KavachGate } from "./nodes/KavachGate/KavachGate.node";
+export { KavachRun } from "./nodes/KavachRun/KavachRun.node";
+export { KavachBudget } from "./nodes/KavachBudget/KavachBudget.node";
+export { KavachAudit } from "./nodes/KavachAudit/KavachAudit.node";
+export { AegisApi } from "./credentials/AegisApi.credentials";

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AegisApi = exports.KavachAudit = exports.KavachBudget = exports.KavachRun = exports.KavachGate = void 0;
+// SPDX-License-Identifier: AGPL-3.0-only
+var KavachGate_node_1 = require("./nodes/KavachGate/KavachGate.node");
+Object.defineProperty(exports, "KavachGate", { enumerable: true, get: function () { return KavachGate_node_1.KavachGate; } });
+var KavachRun_node_1 = require("./nodes/KavachRun/KavachRun.node");
+Object.defineProperty(exports, "KavachRun", { enumerable: true, get: function () { return KavachRun_node_1.KavachRun; } });
+var KavachBudget_node_1 = require("./nodes/KavachBudget/KavachBudget.node");
+Object.defineProperty(exports, "KavachBudget", { enumerable: true, get: function () { return KavachBudget_node_1.KavachBudget; } });
+var KavachAudit_node_1 = require("./nodes/KavachAudit/KavachAudit.node");
+Object.defineProperty(exports, "KavachAudit", { enumerable: true, get: function () { return KavachAudit_node_1.KavachAudit; } });
+var AegisApi_credentials_1 = require("./credentials/AegisApi.credentials");
+Object.defineProperty(exports, "AegisApi", { enumerable: true, get: function () { return AegisApi_credentials_1.AegisApi; } });

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

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

package/dist/nodes/KavachAudit/KavachAudit.node.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KavachAudit = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class KavachAudit {
+    constructor() {
+        this.description = {
+            displayName: "Kavach Audit",
+            name: "kavachAudit",
+            icon: "file:kavach-audit.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: "Query DAN gate audit log",
+            description: "Queries the AEGIS audit log (kavach_approvals table). Returns gate decisions filtered by " +
+                "session ID, status, DAN level, or date range. Use for compliance reporting or post-incident review.",
+            defaults: { name: "Kavach Audit" },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "aegisApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Filter by Session ID",
+                    name: "sessionId",
+                    type: "string",
+                    default: "",
+                    placeholder: "exec_abc123",
+                    description: "Return only records for this session. Leave empty for all sessions.",
+                },
+                {
+                    displayName: "Filter by Status",
+                    name: "status",
+                    type: "options",
+                    options: [
+                        { name: "All", value: "all" },
+                        { name: "Pending", value: "pending" },
+                        { name: "Allowed", value: "allow" },
+                        { name: "Stopped", value: "stop" },
+                        { name: "Timed Out", value: "timeout" },
+                    ],
+                    default: "all",
+                    description: "Return only records matching this approval status.",
+                },
+                {
+                    displayName: "Filter by DAN Level",
+                    name: "danLevel",
+                    type: "options",
+                    options: [
+                        { name: "All levels", value: 0 },
+                        { name: "DAN-1 (safe)", value: 1 },
+                        { name: "DAN-2 (elevated)", value: 2 },
+                        { name: "DAN-3 (dangerous)", value: 3 },
+                        { name: "DAN-4 (catastrophic)", value: 4 },
+                    ],
+                    default: 0,
+                    description: "Return only records at this DAN level. 0 = all levels.",
+                },
+                {
+                    displayName: "Limit",
+                    name: "limit",
+                    type: "number",
+                    default: 50,
+                    description: "Maximum number of records to return.",
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        const credentials = await this.getCredentials("aegisApi");
+        const baseUrl = credentials.baseUrl.replace(/\/$/, "");
+        const token = credentials.token;
+        for (let i = 0; i < items.length; i++) {
+            const sessionId = this.getNodeParameter("sessionId", i).trim();
+            const status = this.getNodeParameter("status", i);
+            const danLevel = this.getNodeParameter("danLevel", i);
+            const limit = this.getNodeParameter("limit", i);
+            const params = new URLSearchParams();
+            if (sessionId)
+                params.set("session_id", sessionId);
+            if (status !== "all")
+                params.set("status", status);
+            if (danLevel > 0)
+                params.set("level", danLevel.toString());
+            params.set("limit", limit.toString());
+            const headers = {};
+            if (token)
+                headers["Authorization"] = `Bearer ${token}`;
+            let auditResult;
+            try {
+                const url = `${baseUrl}/api/v1/kavach/audit?${params.toString()}`;
+                const res = await fetch(url, { headers });
+                if (!res.ok) {
+                    const text = await res.text().catch(() => res.status.toString());
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Aegis audit returned HTTP ${res.status}: ${text}`, { itemIndex: i });
+                }
+                auditResult = (await res.json());
+            }
+            catch (err) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot reach Aegis audit at ${baseUrl}: ${err.message}`, { itemIndex: i });
+            }
+            results.push({
+                json: {
+                    ...items[i].json,
+                    kavach_audit: {
+                        records: auditResult.records,
+                        total: auditResult.total,
+                        _meta: auditResult._meta,
+                    },
+                },
+                pairedItem: i,
+            });
+        }
+        return [results];
+    }
+}
+exports.KavachAudit = KavachAudit;

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

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

package/dist/nodes/KavachBudget/KavachBudget.node.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KavachBudget = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class KavachBudget {
+    constructor() {
+        this.description = {
+            displayName: "Kavach Budget",
+            name: "kavachBudget",
+            icon: "file:kavach-budget.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: "Budget + valve state",
+            description: "Reads the current AEGIS budget state (daily spend, limit, remaining, breach flag) and " +
+                "gate-valve status. Use to guard expensive workflows or to surface cost data in dashboards.",
+            defaults: { name: "Kavach Budget" },
+            inputs: ["main"],
+            outputs: ["main", "main"],
+            outputNames: ["within budget", "breached"],
+            credentials: [
+                {
+                    name: "aegisApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Halt on Breach",
+                    name: "haltOnBreach",
+                    type: "boolean",
+                    default: false,
+                    description: "When true and budget is breached, throw an error instead of routing to the 'breached' output.",
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const withinBudget = [];
+        const breachedItems = [];
+        const credentials = await this.getCredentials("aegisApi");
+        const baseUrl = credentials.baseUrl.replace(/\/$/, "");
+        const token = credentials.token;
+        for (let i = 0; i < items.length; i++) {
+            const haltOnBreach = this.getNodeParameter("haltOnBreach", i);
+            const headers = {};
+            if (token)
+                headers["Authorization"] = `Bearer ${token}`;
+            let state;
+            try {
+                const res = await fetch(`${baseUrl}/api/v1/kavach/state`, { headers });
+                if (!res.ok) {
+                    const text = await res.text().catch(() => res.status.toString());
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Aegis state returned HTTP ${res.status}: ${text}`, { itemIndex: i });
+                }
+                state = (await res.json());
+            }
+            catch (err) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot reach Aegis state at ${baseUrl}: ${err.message}`, { itemIndex: i });
+            }
+            const output = {
+                json: {
+                    ...items[i].json,
+                    kavach_budget: {
+                        daily_spent_usd: state.budget.daily_spent_usd,
+                        daily_limit_usd: state.budget.daily_limit_usd,
+                        daily_remaining_usd: state.budget.daily_remaining_usd,
+                        breached: state.budget.breached,
+                        kavach_enabled: state.kavach_enabled,
+                        _meta: state._meta,
+                    },
+                },
+                pairedItem: i,
+            };
+            if (state.budget.breached) {
+                if (haltOnBreach) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `KAVACH budget breached: $${state.budget.daily_spent_usd.toFixed(4)} of $${state.budget.daily_limit_usd} daily limit used`, { itemIndex: i });
+                }
+                breachedItems.push(output);
+            }
+            else {
+                withinBudget.push(output);
+            }
+        }
+        return [withinBudget, breachedItems];
+    }
+}
+exports.KavachBudget = KavachBudget;

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

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

package/dist/nodes/KavachGate/KavachGate.node.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KavachGate = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class KavachGate {
+    constructor() {
+        this.description = {
+            displayName: "Kavach Gate",
+            name: "kavachGate",
+            icon: "file:kavach-gate.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: "Pre-execution DAN gate",
+            description: "Intercepts AI agent actions before execution. Calls the Aegis KAVACH gate to classify danger level (DAN 1-4), notify approvers, and wait for ALLOW/STOP. Blocks the workflow on STOP or timeout.",
+            defaults: { name: "Kavach Gate" },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "aegisApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Command",
+                    name: "command",
+                    type: "string",
+                    default: "={{ $json.command }}",
+                    required: true,
+                    description: "The command or action the agent wants to execute. Accepts an expression referencing upstream node output.",
+                    placeholder: "prisma migrate reset",
+                },
+                {
+                    displayName: "Tool Name",
+                    name: "toolName",
+                    type: "string",
+                    default: "n8n-agent",
+                    description: "Name of the tool/node calling this gate. Appears in audit records.",
+                },
+                {
+                    displayName: "Session ID",
+                    name: "sessionId",
+                    type: "string",
+                    default: "={{ $execution.id }}",
+                    description: "Workflow execution ID used for audit trail grouping.",
+                },
+                {
+                    displayName: "Dry Run",
+                    name: "dryRun",
+                    type: "boolean",
+                    default: false,
+                    description: "Classify danger level only — no notification sent, no polling. Use for testing the gate without blocking.",
+                },
+                {
+                    displayName: "On STOP / Timeout",
+                    name: "onBlock",
+                    type: "options",
+                    options: [
+                        { name: "Throw Error (halt workflow)", value: "throw" },
+                        { name: "Continue with allow=false", value: "continue" },
+                    ],
+                    default: "throw",
+                    description: "What to do when the gate blocks the action. Default: throw error to halt the workflow.",
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        const credentials = await this.getCredentials("aegisApi");
+        const baseUrl = credentials.baseUrl.replace(/\/$/, "");
+        const token = credentials.token;
+        for (let i = 0; i < items.length; i++) {
+            const command = this.getNodeParameter("command", i);
+            const toolName = this.getNodeParameter("toolName", i);
+            const sessionId = this.getNodeParameter("sessionId", i);
+            const dryRun = this.getNodeParameter("dryRun", i);
+            const onBlock = this.getNodeParameter("onBlock", i);
+            if (!command?.trim()) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "command must not be empty", { itemIndex: i });
+            }
+            const headers = { "Content-Type": "application/json" };
+            if (token)
+                headers["Authorization"] = `Bearer ${token}`;
+            let gateResult;
+            try {
+                const res = await fetch(`${baseUrl}/api/v1/kavach/gate`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({ command, tool_name: toolName, session_id: sessionId, dry_run: dryRun }),
+                });
+                if (!res.ok && res.status !== 200) {
+                    const text = await res.text().catch(() => res.status.toString());
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Aegis gate returned HTTP ${res.status}: ${text}`, { itemIndex: i });
+                }
+                gateResult = (await res.json());
+            }
+            catch (err) {
+                // Network error — aegis unreachable
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot reach Aegis gate at ${baseUrl}: ${err.message}`, { itemIndex: i });
+            }
+            if (!gateResult.allow) {
+                if (onBlock === "throw") {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `KAVACH blocked action (DAN ${gateResult.level ?? "?"}): ${gateResult.reason}`, { itemIndex: i });
+                }
+                // continue mode — pass allow=false downstream
+            }
+            results.push({
+                json: {
+                    ...items[i].json,
+                    kavach: {
+                        allow: gateResult.allow,
+                        level: gateResult.level,
+                        reason: gateResult.reason,
+                        decision: gateResult.decision,
+                        approval_id: gateResult.approval_id,
+                        _meta: gateResult._meta,
+                    },
+                },
+                pairedItem: i,
+            });
+        }
+        return [results];
+    }
+}
+exports.KavachGate = KavachGate;

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

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

package/dist/nodes/KavachRun/KavachRun.node.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KavachRun = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+function isLinux() {
+    return process.platform === "linux";
+}
+function kavachosAvailable() {
+    try {
+        (0, child_process_1.execSync)("which kavachos", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class KavachRun {
+    constructor() {
+        this.description = {
+            displayName: "Kavach Run",
+            name: "kavachRun",
+            icon: "file:kavach-run.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: "Kernel-enforced subprocess (Linux)",
+            description: "Wraps a subprocess in kavachos kernel enforcement (seccomp-bpf + cgroup BPF egress). " +
+                "Linux only — gracefully degrades on macOS/Windows with a warning. " +
+                "Use after KavachGate for defense in depth: policy gate + kernel enforcement.",
+            defaults: { name: "Kavach Run" },
+            inputs: ["main"],
+            outputs: ["main"],
+            properties: [
+                {
+                    displayName: "Binary",
+                    name: "binary",
+                    type: "string",
+                    default: "",
+                    required: true,
+                    placeholder: "bun",
+                    description: "The binary to execute under kernel enforcement.",
+                },
+                {
+                    displayName: "Arguments",
+                    name: "args",
+                    type: "string",
+                    default: "",
+                    placeholder: "src/my-agent.ts --port 4900",
+                    description: "Space-separated arguments to pass to the binary.",
+                },
+                {
+                    displayName: "Trust Mask (hex)",
+                    name: "trustMask",
+                    type: "string",
+                    default: "0xFF",
+                    description: "Seccomp-bpf trust mask. Controls which syscall groups the process is allowed to call. " +
+                        "0xFF = infrastructure bits. See KavachOS trust_mask docs.",
+                },
+                {
+                    displayName: "Domain",
+                    name: "domain",
+                    type: "options",
+                    options: [
+                        { name: "general", value: "general" },
+                        { name: "maritime", value: "maritime" },
+                        { name: "logistics", value: "logistics" },
+                        { name: "ot", value: "ot" },
+                        { name: "finance", value: "finance" },
+                    ],
+                    default: "general",
+                    description: "Domain profile — controls egress allowlist and Falco rule set.",
+                },
+                {
+                    displayName: "Enable Falco",
+                    name: "falco",
+                    type: "boolean",
+                    default: false,
+                    description: "Enable Falco CRITICAL rule monitoring (requires Falco installed on host).",
+                },
+                {
+                    displayName: "On Non-Linux",
+                    name: "onNonLinux",
+                    type: "options",
+                    options: [
+                        { name: "Warn and run unwrapped", value: "warn" },
+                        { name: "Skip execution entirely", value: "skip" },
+                        { name: "Throw error", value: "throw" },
+                    ],
+                    default: "warn",
+                    description: "Behavior when running on macOS or Windows where kernel enforcement is unavailable.",
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        for (let i = 0; i < items.length; i++) {
+            const binary = this.getNodeParameter("binary", i);
+            const args = this.getNodeParameter("args", i).trim();
+            const trustMask = this.getNodeParameter("trustMask", i);
+            const domain = this.getNodeParameter("domain", i);
+            const falco = this.getNodeParameter("falco", i);
+            const onNonLinux = this.getNodeParameter("onNonLinux", i);
+            if (!binary?.trim()) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "binary must not be empty", { itemIndex: i });
+            }
+            const linux = isLinux();
+            const hasKavachos = linux && kavachosAvailable();
+            if (!linux || !hasKavachos) {
+                const platform = process.platform;
+                const reason = !linux
+                    ? `KavachRun kernel enforcement not available on ${platform} — requires Linux with seccomp-bpf`
+                    : "kavachos CLI not found — install with: npm install -g @rocketlang/kavachos";
+                if (onNonLinux === "throw") {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), reason, { itemIndex: i });
+                }
+                if (onNonLinux === "skip") {
+                    results.push({
+                        json: { ...items[i].json, kavach_run: { skipped: true, reason } },
+                        pairedItem: i,
+                    });
+                    continue;
+                }
+                // warn: run unwrapped with a flag in output
+                process.stderr.write(`[KavachRun] WARNING: ${reason} — running ${binary} unwrapped\n`);
+                const argList = args ? args.split(/\s+/) : [];
+                const proc = (0, child_process_1.spawnSync)(binary, argList, { encoding: "utf8" });
+                results.push({
+                    json: {
+                        ...items[i].json,
+                        kavach_run: {
+                            enforced: false,
+                            reason,
+                            stdout: proc.stdout,
+                            stderr: proc.stderr,
+                            exit_code: proc.status,
+                        },
+                    },
+                    pairedItem: i,
+                });
+                continue;
+            }
+            // Linux + kavachos available — build command
+            const kavachArgs = [
+                "run",
+                `--trust-mask=${trustMask}`,
+                `--domain=${domain}`,
+                ...(falco ? ["--falco"] : []),
+                binary,
+                ...(args ? args.split(/\s+/) : []),
+            ];
+            const proc = (0, child_process_1.spawnSync)("kavachos", kavachArgs, { encoding: "utf8" });
+            if (proc.error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `kavachos run failed: ${proc.error.message}`, { itemIndex: i });
+            }
+            results.push({
+                json: {
+                    ...items[i].json,
+                    kavach_run: {
+                        enforced: true,
+                        trust_mask: trustMask,
+                        domain,
+                        falco_enabled: falco,
+                        stdout: proc.stdout,
+                        stderr: proc.stderr,
+                        exit_code: proc.status,
+                    },
+                },
+                pairedItem: i,
+            });
+        }
+        return [results];
+    }
+}
+exports.KavachRun = KavachRun;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@xshieldai/n8n-nodes",
+  "version": "1.1.0",
+  "description": "xShieldAI n8n community nodes — DAN gate, kernel enforcement, budget check, and audit log for AI agents.",
+  "license": "AGPL-3.0",
+  "author": "Capt. Anil Sharma <capt.anil.sharma@powerpbox.org>",
+  "homepage": "https://kavachos.xshieldai.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rocketlang/aegis.git",
+    "directory": "packages/n8n-nodes-kavachos"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "kavachos",
+    "xshieldai",
+    "ai-governance",
+    "seccomp",
+    "agent-safety"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/AegisApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/KavachGate/KavachGate.node.js",
+      "dist/nodes/KavachRun/KavachRun.node.js",
+      "dist/nodes/KavachBudget/KavachBudget.node.js",
+      "dist/nodes/KavachAudit/KavachAudit.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "n8n-workflow": "^1.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}