@purplesquirrel/guardrails-mcp-server 1.0.0 → 1.0.1

package/index.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+
+/**
+ * AI Agent Guardrails MCP Server
+ * Security layer for Claude Code and AI agents
+ *
+ * Provides input validation, output filtering, policy enforcement, and audit logging
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { GuardrailsEngine } from './src/engine/GuardrailsEngine.js';
+import { InputValidator } from './src/validators/InputValidator.js';
+import { OutputFilter } from './src/filters/OutputFilter.js';
+import { PolicyEngine } from './src/policies/PolicyEngine.js';
+import { AuditLogger } from './src/audit/AuditLogger.js';
+
+// Initialize components
+const config = {
+  enableInputValidation: true,
+  enableOutputFiltering: true,
+  enablePolicyEnforcement: true,
+  enableAuditLogging: true,
+  enableRateLimiting: true,
+  maxRequestsPerMinute: parseInt(process.env.GUARDRAILS_RATE_LIMIT || '60'),
+};
+
+const engine = new GuardrailsEngine(config);
+const validator = new InputValidator();
+const filter = new OutputFilter();
+const policyEngine = new PolicyEngine();
+const logger = new AuditLogger({ enableConsoleLog: false });
+
+// Create server
+const server = new Server(
+  {
+    name: "guardrails-mcp-server",
+    version: "1.0.1",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Tool definitions
+const tools = [
+  {
+    name: "validate_input",
+    description: "Validate and sanitize user input for prompt injection, malicious patterns, and sensitive data",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The input content to validate"
+        },
+        context: {
+          type: "string",
+          description: "Optional context about the input source"
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "filter_output",
+    description: "Filter and redact sensitive information from AI output",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The output content to filter"
+        },
+        redactPII: {
+          type: "boolean",
+          description: "Whether to redact personally identifiable information",
+          default: true
+        },
+        redactSecrets: {
+          type: "boolean",
+          description: "Whether to redact secrets and credentials",
+          default: true
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "check_policy",
+    description: "Check if an action is allowed by security policies",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "The action to check (e.g., 'file_read', 'network_access')"
+        },
+        resource: {
+          type: "string",
+          description: "The resource being accessed"
+        },
+        user: {
+          type: "string",
+          description: "The user or agent performing the action"
+        }
+      },
+      required: ["action", "resource"]
+    }
+  },
+  {
+    name: "get_audit_logs",
+    description: "Retrieve audit logs for guardrails events",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of logs to return",
+          default: 100
+        },
+        type: {
+          type: "string",
+          description: "Filter by event type"
+        },
+        since: {
+          type: "string",
+          description: "ISO timestamp to filter logs after"
+        }
+      }
+    }
+  },
+  {
+    name: "get_metrics",
+    description: "Get guardrails metrics and statistics",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "add_policy",
+    description: "Add a custom security policy",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Unique policy identifier"
+        },
+        name: {
+          type: "string",
+          description: "Human-readable policy name"
+        },
+        description: {
+          type: "string",
+          description: "Policy description"
+        },
+        pattern: {
+          type: "string",
+          description: "Regex pattern to match"
+        },
+        action: {
+          type: "string",
+          enum: ["deny", "warn"],
+          description: "Action when pattern matches"
+        }
+      },
+      required: ["id", "name", "pattern"]
+    }
+  },
+  {
+    name: "add_blocked_pattern",
+    description: "Add a pattern to block in inputs",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Regex pattern to block"
+        },
+        name: {
+          type: "string",
+          description: "Name for this pattern"
+        },
+        severity: {
+          type: "string",
+          enum: ["low", "medium", "high", "critical"],
+          description: "Severity level when pattern is matched"
+        }
+      },
+      required: ["pattern", "name"]
+    }
+  },
+  {
+    name: "get_summary",
+    description: "Get a summary report of guardrails activity",
+    inputSchema: {
+      type: "object",
+      properties: {
+        hours: {
+          type: "number",
+          description: "Number of hours to include in summary",
+          default: 24
+        }
+      }
+    }
+  }
+];
+
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "validate_input": {
+        const result = await validator.validate(args.content, { source: args.context });
+        await logger.log({
+          type: result.valid ? 'INPUT_VALIDATED' : 'INPUT_VALIDATION_FAILED',
+          input: args.content?.substring(0, 100),
+          violations: result.violations
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              isValid: result.valid,
+              issues: result.violations,
+              stats: result.stats
+            }, null, 2)
+          }]
+        };
+      }
+
+      case "filter_output": {
+        const result = await filter.filter(args.content, {
+          redactPII: args.redactPII !== false,
+          redactSecrets: args.redactSecrets !== false
+        });
+        await logger.log({
+          type: 'OUTPUT_FILTERED',
+          redactionsApplied: result.redactions?.length || 0
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              filtered: result.response,
+              modified: result.modified,
+              blocked: result.blocked,
+              redactions: result.redactions
+            }, null, 2)
+          }]
+        };
+      }
+
+      case "check_policy": {
+        const result = await policyEngine.evaluate({
+          name: args.action,
+          resource: args.resource
+        }, {
+          userId: args.user || 'anonymous'
+        });
+        await logger.log({
+          type: result.allowed ? 'POLICY_CHECK_PASSED' : 'POLICY_VIOLATION',
+          action: args.action,
+          resource: args.resource,
+          allowed: result.allowed,
+          policy: result.violatedPolicy
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+
+      case "get_audit_logs": {
+        const logs = logger.getLogs({
+          limit: args.limit || 100,
+          type: args.type,
+          startTime: args.since
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(logs, null, 2)
+          }]
+        };
+      }
+
+      case "get_metrics": {
+        const metrics = logger.getMetrics();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(metrics, null, 2)
+          }]
+        };
+      }
+
+      case "add_policy": {
+        policyEngine.createSimplePolicy({
+          id: args.id,
+          name: args.name,
+          description: args.description || '',
+          pattern: args.pattern,
+          action: args.action || 'deny',
+          message: `Policy ${args.name} violated`
+        });
+        await logger.log({
+          type: 'POLICY_ADDED',
+          policyId: args.id,
+          policyName: args.name
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, message: `Policy '${args.name}' added` })
+          }]
+        };
+      }
+
+      case "add_blocked_pattern": {
+        validator.addInjectionPattern(args.pattern);
+        await logger.log({
+          type: 'PATTERN_ADDED',
+          patternName: args.name,
+          severity: args.severity || 'medium'
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, message: `Pattern '${args.name}' added to blocked list` })
+          }]
+        };
+      }
+
+      case "get_summary": {
+        const summary = logger.getSummary(args.hours || 24);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(summary, null, 2)
+          }]
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    await logger.log({
+      type: 'ERROR',
+      level: 'error',
+      tool: name,
+      error: error.message
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ error: error.message })
+      }],
+      isError: true
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Guardrails MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@purplesquirrel/guardrails-mcp-server",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI Agent Guardrails MCP Server - Security layer for Claude Code and AI agents",
   "main": "index.js",
   "type": "module",
+  "bin": {
+    "guardrails-mcp-server": "./index.js"
+  },
   "scripts": {
     "start": "node index.js",
     "test": "node --test tests/",