┌─────────────────────────────────────────────────────────────────┐
│                    MCP-ARCHITEKTUR                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│   ┌─────────────┐         ┌─────────────┐         ┌───────────┐  │
│   │   MCP       │         │   MCP       │         │   Tools   │  │
│   │   Client    │◄───────►│   Server    │◄───────►│   (n8n)   │  │
│   │             │         │             │         │           │  │
│   │  OpenClaw   │         │  Protocol   │         │ Workflows │  │
│   │  Claude     │         │  Bridge     │         │ APIs      │  │
│   │  Cursor     │         │             │         │ Services  │  │
│   └─────────────┘         └─────────────┘         └───────────┘  │
│                                                                   │
│   Standardisierte Tool-Discovery, Invocation und Context-Sharing │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────┐
│                     MCP-REQUEST-FLOW                            │
├──────────────────────────────────────────────────────────────────┤
│                                                                    │
│  1. DISCOVERY                                                      │
│     ┌─────────┐  List Tools/Resources   ┌─────────┐               │
│     │ Client  │ ──────────────────────► │ Server  │               │
│     │         │ ◄────────────────────── │         │               │
│     └─────────┘   Tool Definitions      └─────────┘               │
│                                                                    │
│  2. INVOCATION                                                     │
│     ┌─────────┐  Call Tool (params)     ┌─────────┐               │
│     │ Client  │ ──────────────────────► │ Server  │               │
│     │         │ ◄────────────────────── │         │               │
│     └─────────┘   Result/Error         └─────────┘               │
│                                                                    │
│  3. CONTEXT SHARING                                                │
│     • Schema-Definitionen                                           │
│     • Fehlerinformationen                                            │
│     • Fortschritts-Updates                                             │
│     • Ressource-Subscriptions                                       │
│                                                                    │
└──────────────────────────────────────────────────────────────────┘

# OpenClaw MCP Konfiguration (mcp.yml)
servers:
  # n8n MCP Server
  n8n-enterprise:
    command: node
    args: ["/path/to/n8n-mcp-server/dist/index.js"]
    env:
      N8N_HOST: "https://n8n.company.internal"
      N8N_API_KEY: "${N8N_API_KEY}"
      
  # Externer Composio MCP
  composio-tools:
    url: "https://connect.composio.dev/mcp"
    headers:
      Authorization: "Bearer ${COMPOSIO_API_KEY}"
      
  # Custom Enterprise MCP
  enterprise-integrations:
    command: python
    args: ["-m", "enterprise_mcp_server"]
    env:
      DATABASE_URL: "${ENTERPRISE_DB_URL}"

┌─────────────────────────────────────────────────────────────────┐
│              OPENCLAW MCP-INTEGRATIONS-FLOW                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  User Message                                                     │
│       │                                                           │
│       ▼                                                           │
│  ┌─────────────────┐                                              │
│  │  OpenClaw       │  1. Parse Intent, identifiziere Ziel        │
│  │  Gateway        │  2. Lade Conversation-Context              │
│  │                 │  3. Bestimme benötigte Capabilities          │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  Tool Selection │  Analysiere verfügbare MCP-Tools            │
│  │  (LLM Reasoning)│  Wähle optimale Tool-Sequenz               │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  MCP Client     │  Formatiere MCP-Request                     │
│  │  Layer          │  Rufe Tool auf                              │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  MCP Server     │  Verarbeite Request                         │
│  │  (n8n/Make/etc)│  Führe Workflow/API-Call aus                │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  Result         │  Parse Response                             │
│  │  Processing     │  Update Context                             │
│  │                 │  Generiere User-Response                    │
│  └─────────────────┘                                              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

// Tool-Capabilities definieren erlaubte Operationen
interface ToolCapabilities {
  read: boolean;      // Kann Daten lesen
  write: boolean;     // Kann Daten modifizieren
  execute: boolean;   // Kann Aktionen auslösen
  admin: boolean;     // Administrative Funktionen
}

// Jeder MCP-Server registriert sich mit spezifischen Capabilities
const n8nServer = {
  name: "n8n-automation",
  capabilities: ["read", "write", "execute"],
  restrictedWorkflows: ["production-deployments"] // Ausschließen sensibler Workflows
};

# OpenClaw Genehmigungs-Konfiguration
approvals:
  high-risk-actions:
    - pattern: "delete.*"
      requires_approval: true
    - pattern: "deploy.*production.*"
      requires_approval: true
    - pattern: "transfer.*funds.*"
      requires_approval: true
      approvers: ["finance-team"]

┌─────────────────────────────────────────────────────────────────┐
│                    N8N MCP SERVER                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    MCP Server Core                      │   │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐ │   │
│   │  │   Tools     │  │ Resources   │  │   Prompts       │ │   │
│   │  │  Registry   │  │  Registry   │  │   Registry      │ │   │
│   │  └──────┬──────┘  └──────┬──────┘  └────────┬────────┘ │   │
│   │         │                │                  │          │   │
│   │  ┌──────▼────────────────▼──────────────────▼────────┐ │   │
│   │  │           n8n API Integration Layer                 │ │   │
│   │  │  • Workflow Discovery                               │ │   │
│   │  │  • Execution Management                             │ │   │
│   │  │  • Credential Handling                              │ │   │
│   │  │  • Webhook Management                               │ │   │
│   │  └───────────────────────┬─────────────────────────────┘ │   │
│   │                          │                               │   │
│   │  ┌───────────────────────▼─────────────────────────────┐ │   │
│   │  │              Authentication Layer                   │ │   │
│   │  │  • API Key Validation                             │ │   │
│   │  │  • OAuth 2.0 Support                              │ │   │
│   │  │  • JWT Token Verification                         │ │   │
│   │  └───────────────────────────────────────────────────┘ │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│   Transport: stdio | SSE | WebSocket                               │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

# Projektverzeichnis erstellen
mkdir n8n-mcp-server
cd n8n-mcp-server
npm init -y

# Abhängigkeiten installieren
npm install @modelcontextprotocol/sdk zod dotenv winston
npm install -D @types/node typescript

# TypeScript initialisieren
npx tsc --init

// src/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { N8nClient } from "./n8n-client.js";
import { ToolRegistry } from "./tool-registry.js";
import { logger } from "./logger.js";

class N8nMcpServer {
  private server: Server;
  private n8nClient: N8nClient;
  private toolRegistry: ToolRegistry;

  constructor() {
    this.n8nClient = new N8nClient({
      baseUrl: process.env.N8N_HOST!,
      apiKey: process.env.N8N_API_KEY!,
    });

    this.toolRegistry = new ToolRegistry(this.n8nClient);

    this.server = new Server(
      {
        name: "n8n-mcp-server",
        version: "1.0.0",
      },
      {
        capabilities: {
          tools: {},
          resources: {},
        },
      }
    );

    this.setupHandlers();
  }

  private setupHandlers() {
    // Verfügbare Tools auflisten
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      const tools = await this.toolRegistry.getTools();
      return { tools };
    });

    // Tool ausführen
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
      
      logger.info(`Führe Tool aus: ${name}`, { args });

      try {
        const result = await this.toolRegistry.executeTool(name, args);
        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(result, null, 2),
            },
          ],
        };
      } catch (error) {
        logger.error(`Tool-Ausführung fehlgeschlagen: ${name}`, { error });
        throw error;
      }
    });

    // Verfügbare Ressourcen auflisten
    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
      const resources = await this.toolRegistry.getResources();
      return { resources };
    });

    // Ressource lesen
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
      const { uri } = request.params;
      const content = await this.toolRegistry.readResource(uri);
      return {
        contents: [
          {
            uri,
            mimeType: "application/json",
            text: JSON.stringify(content, null, 2),
          },
        ],
      };
    });
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    logger.info("n8n MCP Server läuft auf stdio");
  }
}

// Server starten
const server = new N8nMcpServer();
server.run().catch(console.error);

// src/n8n-client.ts
import { logger } from "./logger.js";

interface N8nConfig {
  baseUrl: string;
  apiKey: string;
}

interface Workflow {
  id: string;
  name: string;
  active: boolean;
  tags?: { name: string }[];
  nodes?: any[];
}

interface ExecutionResult {
  executionId: string;
  status: "success" | "error" | "running";
  data?: any;
  error?: string;
}

export class N8nClient {
  private config: N8nConfig;

  constructor(config: N8nConfig) {
    this.config = config;
  }

  private async request<T>(
    endpoint: string,
    options: RequestInit = {}
  ): Promise<T> {
    const url = `${this.config.baseUrl}/api/v1${endpoint}`;
    const response = await fetch(url, {
      ...options,
      headers: {
        "X-N8N-API-KEY": this.config.apiKey,
        "Content-Type": "application/json",
        ...options.headers,
      },
    });

    if (!response.ok) {
      throw new Error(`n8n API Fehler: ${response.status} ${response.statusText}`);
    }

    return response.json();
  }

  async getWorkflows(): Promise<Workflow[]> {
    const response = await this.request<{ data: Workflow[] }>("/workflows");
    return response.data;
  }

  async getWorkflow(id: string): Promise<Workflow> {
    return this.request<Workflow>(`/workflows/${id}`);
  }

  async executeWorkflow(
    workflowId: string,
    data: Record<string, any>
  ): Promise<ExecutionResult> {
    logger.info(`Trigger Workflow-Ausführung: ${workflowId}`);

    // Nutze Webhook wenn verfügbar, sonst direkte Ausführung
    try {
      const response = await this.request<ExecutionResult>(
        `/workflows/${workflowId}/execute`,
        {
          method: "POST",
          body: JSON.stringify(data),
        }
      );
      return response;
    } catch (error) {
      // Fallback zu Webhook-Ausführung
      return this.executeViaWebhook(workflowId, data);
    }
  }

  private async executeViaWebhook(
    workflowId: string,
    data: Record<string, any>
  ): Promise<ExecutionResult> {
    const webhookUrl = `${this.config.baseUrl}/webhook/${workflowId}`;
    
    const response = await fetch(webhookUrl, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      throw new Error(`Webhook-Ausführung fehlgeschlagen: ${response.statusText}`);
    }

    const result = await response.json();
    return {
      executionId: result.executionId || "webhook",
      status: result.status || "success",
      data: result,
    };
  }

  async getExecution(executionId: string): Promise<ExecutionResult> {
    return this.request<ExecutionResult>(`/executions/${executionId}`);
  }

  async getWorkflowExecutions(workflowId: string, limit = 10): Promise<ExecutionResult[]> {
    const response = await this.request<{ data: ExecutionResult[] }>(
      `/executions?filter[workflowId]=${workflowId}&limit=${limit}`
    );
    return response.data;
  }
}

// src/tool-registry.ts
import { z } from "zod";
import { N8nClient } from "./n8n-client.js";
import { logger } from "./logger.js";

interface Tool {
  name: string;
  description: string;
  inputSchema: z.ZodType<any>;
  workflowId?: string;
  tags: string[];
}

interface Resource {
  uri: string;
  name: string;
  mimeType: string;
  description?: string;
}

export class ToolRegistry {
  private n8nClient: N8nClient;
  private tools: Map<string, Tool> = new Map();
  private resources: Map<string, Resource> = new Map();

  constructor(n8nClient: N8nClient) {
    this.n8nClient = n8nClient;
  }

  async initialize() {
    await this.discoverWorkflows();
    await this.registerStaticTools();
  }

  private async discoverWorkflows() {
    logger.info("Entdecke n8n Workflows...");
    
    try {
      const workflows = await this.n8nClient.getWorkflows();
      
      for (const workflow of workflows) {
        // Nur aktive Workflows mit MCP-Tag exposen
        if (!workflow.active) continue;
        if (!workflow.tags?.some((t) => t.name === "mcp")) continue;

        const toolName = this.sanitizeWorkflowName(workflow.name);
        
        this.tools.set(toolName, {
          name: toolName,
          description: `Führe n8n Workflow aus: ${workflow.name}`,
          inputSchema: z.object({
            data: z.record(z.any()).optional().describe("Workflow Input-Daten"),
            waitForCompletion: z
              .boolean()
              .optional()
              .default(true)
              .describe("Warte auf Workflow-Abschluss"),
          }),
          workflowId: workflow.id,
          tags: ["n8n", "workflow", ...(workflow.tags?.map((t) => t.name) || [])],
        });

        // Als Ressource für Execution-History registrieren
        this.resources.set(`execution-history://${workflow.id}`, {
          uri: `execution-history://${workflow.id}`,
          name: `${toolName}-history`,
          mimeType: "application/json",
          description: `Execution-History für Workflow: ${workflow.name}`,
        });
      }

      logger.info(`${this.tools.size} MCP-fähige Workflows entdeckt`);
    } catch (error) {
      logger.error("Workflow-Discovery fehlgeschlagen", { error });
    }
  }

  private registerStaticTools() {
    // Tool: Alle Workflows auflisten
    this.tools.set("list_workflows", {
      name: "list_workflows",
      description: "Liste alle verfügbaren n8n Workflows mit MCP-Tag",
      inputSchema: z.object({
        includeInactive: z.boolean().optional().default(false),
      }),
      tags: ["discovery", "metadata"],
    });

    // Tool: Workflow-Status abfragen
    this.tools.set("get_workflow_status", {
      name: "get_workflow_status",
      description: "Hole aktuellen Status und letzte Executions eines Workflows",
      inputSchema: z.object({
        workflowId: z.string().describe("ID des zu prüfenden Workflows"),
      }),
      tags: ["monitoring", "status"],
    });

    // Tool: Executions suchen
    this.tools.set("search_executions", {
      name: "search_executions",
      description: "Durchsuche Workflow Execution-History mit Filtern",
      inputSchema: z.object({
        workflowId: z.string().optional().describe("Filter nach Workflow ID"),
        status: z.enum(["success", "error", "running"]).optional(),
        since: z.string().optional().describe("ISO Datum-String"),
        limit: z.number().optional().default(10),
      }),
      tags: ["search", "history"],
    });
  }

  private sanitizeWorkflowName(name: string): string {
    return name
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, "_")
      .replace(/^_+|_+$/g, "");
  }

  async getTools(): Promise<any[]> {
    if (this.tools.size === 0) {
      await this.initialize();
    }

    return Array.from(this.tools.values()).map((tool) => ({
      name: tool.name,
      description: tool.description,
      inputSchema: zodToJsonSchema(tool.inputSchema),
    }));
  }

  async executeTool(name: string, args: any): Promise<any> {
    const tool = this.tools.get(name);
    if (!tool) {
      throw new Error(`Tool nicht gefunden: ${name}`);
    }

    // Input validieren
    const validated = tool.inputSchema.parse(args);

    switch (name) {
      case "list_workflows":
        return this.handleListWorkflows(validated);
      case "get_workflow_status":
        return this.handleGetWorkflowStatus(validated);
      case "search_executions":
        return this.handleSearchExecutions(validated);
      default:
        if (tool.workflowId) {
          return this.handleWorkflowExecution(tool, validated);
        }
        throw new Error(`Unbekanntes Tool: ${name}`);
    }
  }

  private async handleListWorkflows(args: any) {
    const workflows = await this.n8nClient.getWorkflows();
    return workflows
      .filter((w) => args.includeInactive || w.active)
      .map((w) => ({
        id: w.id,
        name: w.name,
        active: w.active,
        tags: w.tags?.map((t) => t.name) || [],
      }));
  }

  private async handleGetWorkflowStatus(args: any) {
    const workflow = await this.n8nClient.getWorkflow(args.workflowId);
    const executions = await this.n8nClient.getWorkflowExecutions(
      args.workflowId,
      5
    );

    return {
      workflow: {
        id: workflow.id,
        name: workflow.name,
        active: workflow.active,
      },
      recentExecutions: executions,
    };
  }

  private async handleSearchExecutions(args: any) {
    if (args.workflowId) {
      return this.n8nClient.getWorkflowExecutions(args.workflowId, args.limit);
    }
    // Implementiere breitere Suche bei Bedarf
    return [];
  }

  private async handleWorkflowExecution(tool: Tool, args: any) {
    if (!tool.workflowId) {
      throw new Error(`Workflow ID nicht konfiguriert für Tool: ${tool.name}`);
    }

    const result = await this.n8nClient.executeWorkflow(
      tool.workflowId,
      args.data || {}
    );

    if (args.waitForCompletion && result.executionId) {
      // Polling auf Abschluss
      return this.waitForExecution(result.executionId);
    }

    return result;
  }

  private async waitForExecution(
    executionId: string,
    maxAttempts = 30,
    intervalMs = 1000
  ): Promise<any> {
    for (let attempt = 0; attempt < maxAttempts; attempt++) {
      const execution = await this.n8nClient.getExecution(executionId);
      
      if (execution.status !== "running") {
        return execution;
      }

      await new Promise((resolve) => setTimeout(resolve, intervalMs));
    }

    throw new Error(`Execution Timeout: ${executionId}`);
  }

  async getResources(): Promise<Resource[]> {
    return Array.from(this.resources.values());
  }

  async readResource(uri: string): Promise<any> {
    const resource = this.resources.get(uri);
    if (!resource) {
      throw new Error(`Ressource nicht gefunden: ${uri}`);
    }

    const workflowId = uri.replace("execution-history://", "");
    return this.n8nClient.getWorkflowExecutions(workflowId, 50);
  }
}

// Helper: Konvertiere Zod Schema zu JSON Schema
function zodToJsonSchema(schema: z.ZodType<any>): any {
  return {
    type: "object",
    properties: {},
    // Vereinfacht - nutze zod-to-json-schema Bibliothek für volle Konvertierung
  };
}

// src/logger.ts
import winston from "winston";

export const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || "info",
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: "logs/error.log", level: "error" }),
    new winston.transports.File({ filename: "logs/combined.log" }),
  ],
});

// package.json
{
  "name": "n8n-mcp-server",
  "version": "1.0.0",
  "description": "MCP Server für n8n Workflow-Automatisierung",
  "type": "module",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "tsc --watch & nodemon dist/index.js",
    "lint": "eslint src/**/*.ts",
    "test": "vitest"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "dotenv": "^16.3.1",
    "winston": "^3.11.0",
    "zod": "^3.22.4"
  },
  "devDependencies": {
    "@types/node": "^20.10.0",
    "nodemon": "^3.0.2",
    "typescript": "^5.3.3",
    "vitest": "^1.1.0"
  }
}

# ~/.config/openclaw/mcp.yml
servers:
  # Primärer n8n MCP Server
  n8n-enterprise:
    command: node
    args: 
      - "/opt/n8n-mcp-server/dist/index.js"
    env:
      N8N_HOST: "https://n8n.company.internal"
      N8N_API_KEY: "${N8N_API_KEY}"
      LOG_LEVEL: "info"
    disabled: false
    autoApprove: []  # Genehmigung für alle Aktionen erforderlich
    
  # Development n8n Instanz
  n8n-dev:
    command: node
    args:
      - "/opt/n8n-mcp-server/dist/index.js"
    env:
      N8N_HOST: "https://n8n-dev.company.internal"
      N8N_API_KEY: "${N8N_DEV_API_KEY}"
      LOG_LEVEL: "debug"
    disabled: false
    autoApprove:
      - "list_workflows"  # Sicher zum Auto-Approve
      - "get_workflow_status"

  # Externer Composio (für zusätzliche Tools)
  composio:
    url: "https://connect.composio.dev/mcp"
    headers:
      Authorization: "Bearer ${COMPOSIO_API_KEY}"
    disabled: false

# ~/.config/openclaw/.env
# Production n8n
N8N_HOST=https://n8n.company.internal
N8N_API_KEY=n8n_api_xxxxx

# Development n8n
N8N_DEV_API_KEY=n8n_api_yyyyy

# Composio
COMPOSIO_API_KEY=composio_zzzzz

# Logging
LOG_LEVEL=info

# Verifiziere, dass MCP-Server geladen sind
openclaw mcp status

# Erwartete Ausgabe:
# ┌─────────────────┬─────────┬────────────┬─────────────────────────┐
# │ Server          │ Status  │ Tools      │ Last Health Check       │
# ├─────────────────┼─────────┼────────────┼─────────────────────────┤
# │ n8n-enterprise  │ ● ready │ 12 tools   │ 2026-05-27 09:30:15 UTC │
# │ n8n-dev         │ ● ready │ 8 tools    │ 2026-05-27 09:30:15 UTC │
# │ composio        │ ● ready │ 156 tools  │ 2026-05-27 09:30:14 UTC │
# └─────────────────┴─────────┴────────────┴─────────────────────────┘

# Teste Tool-Invocation
openclaw mcp test n8n-enterprise list_workflows

┌─────────────────────────────────────────────────────────────────┐
│              KUNDENSUPPORT-AUTOMATISIERUNG                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  1. Kunden-Nachricht (WhatsApp)                                   │
│     "Hi, ich wurde doppelt für Bestellung #12345 belastet"       │
│                          │                                        │
│                          ▼                                        │
│  2. OpenClaw-Analyse                                             │
│     • Intent: billing_issue                                       │
│     • Entities: order_id=12345, issue=duplicate_charge            │
│     • Sentiment: besorgt                                           │
│     • Priorität: hoch (Billing)                                   │
│                          │                                        │
│                          ▼                                        │
│  3. MCP Tool-Invocation                                           │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ Tool: lookup_order                                    │   │
│     │ Params: { order_id: "12345" }                         │   │
│     └─────────────────────────────────────────────────────────┘   │
│                          │                                        │
│                          ▼                                        │
│  4. n8n Workflow-Ausführung                                       │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ • Shop-Daten über Shopify abfragen                       │   │
│     │ • Zahlungsdaten über Stripe prüfen                      │   │
│     │ • Doppelte Belastung verifizieren                       │   │
│     │ • Zendesk-Ticket erstellen                               │   │
│     │ • Rückerstattungsbetrag berechnen                         │   │
│     └─────────────────────────────────────────────────────────┘   │
│                          │                                        │
│                          ▼                                        │
│  5. OpenClaw-Response                                               │
│     „Ich habe Ihre Bestellung #12345 gefunden. Sie wurden        │
│      tatsächlich doppelt belastet ($89.99 x 2). Ich habe          │
│      Ticket #Z-4567 erstellt und eine Rückerstattung für die     │
│      Doppelbelastung eingeleitet. Sie sollten die Rückerstattung │
│      in 3-5 Werktagen sehen. Kann ich Ihnen sonst noch helfen?"  │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              SALES INTELLIGENCE WORKFLOW                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  Slack-Nachricht:                                                 │
│  „Sprech mit Acme Corp nächste Woche, kennt die jemand?"         │
│                                                                   │
│  OpenClaw-Aktionen:                                               │
│  1. Parse: prospect="Acme Corp"                                   │
│  2. Rufe MCP-Tools auf:                                           │
│     • enrich_company_data                                         │
│     • find_similar_customers                                      │
│     • get_competitive_intel                                       │
│     • check_existing_opportunity                                  │
│                                                                   │
│  n8n Parallele Ausführung:                                        │
│  ┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐     │
│  │ Clearbit API    │ │ LinkedIn        │ │ Salesforce       │     │
│  │ • Company size  │ │ • Key contacts  │ │ • Opp history    │     │
│  │ • Industry      │ │ • Mutual conns  │ │ • Similar wins   │     │
│  │ • Technologies  │ │ • Recent posts  │ │ • Win rate       │     │
│  └─────────────────┘ └─────────────────┘ └──────────────────┘     │
│                                                                   │
│  OpenClaw-Response (Slack):                                       │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ 🎯 Acme Corp Intelligence Report                           ││
│  │                                                              ││
│  │ **Unternehmen**: 500 Mitarbeiter, Series C, SaaS/FinTech    ││
│  │ **Tech Stack**: AWS, Salesforce, Segment, Zendesk          ││
│  │ **Ähnliche Deals**: TechCorp ($250K), InnovateLtd          ││
│  │                                                              ││
│  │ **Key Contacts**:                                             ││
│  │ • Sarah Chen (CTO) - Ehemalige Kollegin!                    ││
│  │ • Mike Ross (VP Sales) - Post über Automatisierungsbedarf   ││
│  │                                                              ││
│  │ **Opportunity**: $150K ARR Potential, 85% Win-Rate für      ││
│  │ ähnliche Profile. Keine bestehende Opp in Salesforce.       ││
│  │                                                              ││
│  │ [Vollständigen Report anzeigen] [Opportunity erstellen]     ││
│  │ [Meeting planen]                                            ││
│  └─────────────────────────────────────────────────────────────┘│
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              DEVOPS-AUTOMATISIERUNG MIT GENEHMIGUNG             │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  Entwickler (Discord):                                            │
│  „@Claw deploye Hotfix für Payment-Bug in Production"            │
│                                                                   │
│  OpenClaw-Verarbeitung:                                           │
│  1. Intent-Analyse: deploy_hotfix                               │
│  2. Context-Sammlung:                                             │
│     • Aktueller Branch: hotfix/payment-gateway-fix              │
│     • Letzter Commit: vor 2 Stunden                              │
│     • CI-Status: ✅ passed                                        │
│     • Tests: ✅ 247/247 bestanden                                  │
│                                                                   │
│  3. Risiko-Bewertung: HOCH (Production-Deployment)               │
│                                                                   │
│  4. Genehmigungs-Anfrage (Slack #deployments):                  │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ 🚀 Production Hotfix Deployment Request                   │   │
│     │                                                          │   │
│     │ Branch: hotfix/payment-gateway-fix                      │   │
│     │ Commit: abc1234 - Fix kritischer Payment-Verarbeitungsbug│   │
│     │ Tests: ✅ Alle bestanden                                   │   │
│     │ Rollback: Bereit (vorheriges Image: prod-v2.3.1)       │   │
│     │                                                          │   │
│     │ Angefragt von: @developer via OpenClaw                  │   │
│     │                                                          │   │
│     │ [Genehmigen] [Ablehnen] [Für 2AM planen]                │   │
│     └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│  5. Bei Genehmigung → n8n Workflow:                               │
│     • Release taggen: v2.3.2-hotfix                              │
│     • Docker-Image bauen                                          │
│     • In Registry pushen                                          │
│     • Kubernetes-Deployment updaten                             │
│     • Smoke-Tests ausführen                                       │
│     • #general-Channel benachrichtigen                            │
│     • Status-Page updaten                                         │
│                                                                   │
│  6. OpenClaw-Bestätigung:                                         │
│     „✅ Hotfix erfolgreich in Production deployed (v2.3.2).        │
│      Smoke-Tests erfolgreich. Deployment-Log: [Link]"             │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              CONTENT DISTRIBUTION AUTOMATISIERUNG               │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  Content Manager (Telegram):                                    │
│  „Veröffentliche den Blog-Post über MCP-Integration auf allen    │
│   Kanälen und plane Social Media für nächste Woche"              │
│                                                                   │
│  OpenClaw-Aktionen:                                               │
│  1. Content identifizieren: „Blog-Post über MCP-Integration"      │
│     → Gefunden: draft-mcp-openclaw-guide.md                      │
│                                                                   │
│  2. Content-Verbesserung:                                         │
│     • SEO-Metadaten generieren                                    │
│     • Social-Media-Snippets erstellen                             │
│     • Featured Image designen (via DALL-E)                        │
│     • Key-Quotes für Twitter/X-Threads extrahieren               │
│                                                                   │
│  3. MCP Tool-Invocations:                                         │
│     ┌──────────────────────────────────────────────────────────┐  │
│     │ publish_to_cms                                           │  │
│     │  ├── WordPress: blog.tropical-media.work               │  │
│     │  ├── Medium: @tropicalmedia                            │  │
│     │  └── Dev.to: @tropicalmedia                           │  │
│     ├──────────────────────────────────────────────────────────┤  │
│     │ schedule_social_posts                                    │  │
│     │  ├── Twitter: 5 Posts über nächste Woche               │  │
│     │  ├── LinkedIn: 2 Posts (Montag, Donnerstag)           │  │
│     │  └── HackerNews: Einreichen Do 9AM EST                   │  │
│     ├──────────────────────────────────────────────────────────┤  │
│     │ notify_team                                              │  │
│     │  ├── Slack #content: „Veröffentlicht: MCP Guide"       │  │
│     │  ├── E-Mail Newsletter: Für morgen planen               │  │
│     │  └── Analytics: Performance tracken                    │  │
│     └──────────────────────────────────────────────────────────┘  │
│                                                                   │
│  4. Ergebnis-Zusammenfassung:                                     │
│     „✅ Auf 3 CMS-Plattformen veröffentlicht                       │
│      ✅ 7 Social-Media-Posts geplant (28. Mai - 3. Juni)        │
│      ✅ Newsletter für morgen geplant                               │
│      ✅ Analytics-Tracking aktiviert                               │
│      📊 Dashboard: [Link]"                                         │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

// Sichere Credential-Speicherung mit Rotation
interface CredentialManager {
  // Speichere verschlüsselte Credentials
  store(key: string, value: string, metadata: CredentialMetadata): Promise<void>;
  
  // Abruf mit Audit-Logging
  retrieve(key: string, requestContext: RequestContext): Promise<string>;
  
  // Automatische Rotation
  rotate(key: string): Promise<void>;
  
  // Widerruf
  revoke(key: string): Promise<void>;
}

// Implementierung mit HashiCorp Vault
class VaultCredentialManager implements CredentialManager {
  async store(key: string, value: string, metadata: CredentialMetadata) {
    await vault.kv.v2.createOrUpdateSecret({
      path: `n8n-mcp/${key}`,
      secret: { value },
      metadata: {
        rotation_schedule: metadata.rotationSchedule,
        last_rotated: new Date().toISOString(),
        created_by: metadata.createdBy,
      },
    });
  }
}

# Berechtigungs-Matrix
permissions:
  # Nur Lese-Operationen
  viewer:
    tools:
      - list_workflows
      - get_workflow_status
      - search_executions
    resources:
      - "execution-history://*"
      
  # Standard-User-Operationen
  operator:
    extends: viewer
    tools:
      - execute_workflow
    workflows:
      - "*"
    exclude_workflows:
      - "production-deployments"
      - "finance-reports"
      
  # Administrative Operationen
  admin:
    tools:
      - "*"
    workflows:
      - "*"
    resources:
      - "*"

// Input-Sanitierung und Validierung
class RequestValidator {
  private maxPayloadSize = 10 * 1024 * 1024; // 10MB
  private allowedCharacters = /^[\w\s\-\.\@\+\=\{\}\[\]\:\"\'\,]+$/;

  validate(request: ToolRequest): ValidationResult {
    const errors: string[] = [];

    // Größen-Check
    const payloadSize = JSON.stringify(request.arguments).length;
    if (payloadSize > this.maxPayloadSize) {
      errors.push(`Payload überschreitet maximale Größe (${this.maxPayloadSize} Bytes)`);
    }

    // Zeichen-Validierung
    for (const [key, value] of Object.entries(request.arguments)) {
      if (typeof value === "string" && !this.allowedCharacters.test(value)) {
        errors.push(`Ungültige Zeichen in Parameter: ${key}`);
      }
    }

    // SQL-Injection-Prävention
    if (this.containsSQLInjection(request.arguments)) {
      errors.push("Mögliche SQL Injection erkannt");
    }

    // Command-Injection-Prävention
    if (this.containsCommandInjection(request.arguments)) {
      errors.push("Mögliche Command Injection erkannt");
    }

    return {
      valid: errors.length === 0,
      errors,
    };
  }

  private containsSQLInjection(args: any): boolean {
    const sqlPatterns = [
      /(\b(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\b)/i,
      /(\b(UNION|JOIN|WHERE|HAVING|ORDER|GROUP)\b)/i,
      /(--|#|\/\*|\*\/)/,
    ];
    
    const stringified = JSON.stringify(args);
    return sqlPatterns.some((pattern) => pattern.test(stringified));
  }

  private containsCommandInjection(args: any): boolean {
    const cmdPatterns = [
      /[;\u0026|`$()]/,
      /(\b(rm|chmod|sudo|curl|wget|nc|python|bash|sh)\b)/i,
    ];
    
    const stringified = JSON.stringify(args);
    return cmdPatterns.some((pattern) => pattern.test(stringified));
  }
}

interface AuditEvent {
  timestamp: string;
  eventType: "tool_invocation" | "tool_result" | "error" | "approval";
  serverName: string;
  toolName: string;
  userId: string;
  sessionId: string;
  requestId: string;
  arguments: any;
  result?: any;
  error?: string;
  durationMs: number;
  clientInfo: {
    ip: string;
    userAgent: string;
  };
}

class AuditLogger {
  async log(event: AuditEvent) {
    // Schreibe in unveränderlichen Log-Store
    await this.writeToLogStore(event);
    
    // Echtzeit-Alerting bei Anomalien
    if (this.isAnomalous(event)) {
      await this.sendSecurityAlert(event);
    }
    
    // SIEM-Integration
    await this.forwardToSIEM(event);
    
    // Compliance-Export
    await this.updateComplianceIndex(event);
  }

  private isAnomalous(event: AuditEvent): boolean {
    // Erkenne ungewöhnliche Muster
    const rules = [
      // Hochfrequente Invocations
      () => this.checkRateAnomaly(event),
      // Zugriff auf sensible Workflows
      () => this.checkSensitiveAccess(event),
      // Aktivität außerhalb der Geschäftszeiten
      () => this.checkTimeAnomaly(event),
      // Fehlgeschlagene Authentifizierungsmuster
      () => this.checkAuthFailures(event),
    ];
    
    return rules.some((rule) => rule());
  }
}

# mcp.yml mit TLS-Konfiguration
servers:
  n8n-enterprise:
    command: node
    args: ["/opt/n8n-mcp-server/dist/index.js"]
    env:
      N8N_HOST: "https://n8n.company.internal"
      N8N_API_KEY: "${N8N_API_KEY}"
      # TLS-Konfiguration
      NODE_TLS_REJECT_UNAUTHORIZED: "1"
      CA_CERT_PATH: "/etc/ssl/certs/ca.crt"
      
    # Netzwerk-Restriktionen
    network:
      allowedHosts:
        - "n8n.company.internal"
        - "n8n-dev.company.internal"
      deniedHosts:
        - "*.external-service.com"
      maxConnections: 100
      connectionTimeout: 30000

┌─────────────────────────────────────────────────────────────────┐
│                    PRODUKTIONS-DEPLOYMENT                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                   Load Balancer                          │   │
│   │              (nginx / HAProxy / Traefik)                 │   │
│   └─────────────────────────┬───────────────────────────────┘   │
│                             │                                     │
│           ┌─────────────────┼─────────────────┐                   │
│           │                 │                 │                   │
│   ┌───────▼──────┐  ┌──────▼──────┐  ┌───────▼──────┐           │
│   │  OpenClaw    │  │  OpenClaw   │  │  OpenClaw    │           │
│   │  Gateway #1  │  │  Gateway #2 │  │  Gateway #3  │           │
│   │              │  │             │  │              │           │
│   │  Container   │  │  Container  │  │  Container   │           │
│   └───────┬──────┘  └──────┬──────┘  └───────┬──────┘           │
│           │                │                 │                   │
│           └────────────────┼─────────────────┘                   │
│                            │                                      │
│   ┌────────────────────────▼──────────────────────────┐           │
│   │              Redis Cluster                        │           │
│   │         (Session State / Message Queue)         │           │
│   └────────────────────────┬──────────────────────────┘           │
│                          │                                       │
│   ┌──────────────────────▼────────────────────────────┐          │
│   │           MCP Server Pool                         │          │
│   │  ┌──────────────┐  ┌──────────────┐             │          │
│   │  │ MCP Server   │  │ MCP Server   │             │          │
│   │  │ Instance #1  │  │ Instance #2  │  ...        │          │
│   │  └──────────────┘  └──────────────┘             │          │
│   └──────────────────────┬────────────────────────────┘          │
│                          │                                       │
│   ┌──────────────────────▼────────────────────────────┐          │
│   │              n8n Cluster                          │          │
│   │  ┌──────────────┐  ┌──────────────┐              │          │
│   │  │ n8n Worker   │  │ n8n Worker   │              │          │
│   │  │ Instance #1  │  │ Instance #2  │  ...         │          │
│   │  └──────────────┘  └──────────────┘              │          │
│   └───────────────────────────────────────────────────┘          │
│                                                                   │
│   Unterstützende Infrastruktur:                                   │
│   • PostgreSQL (n8n Persistenz)                                  │
│   • Prometheus + Grafana (Monitoring)                            │
│   • Vault (Secrets Management)                                   │
│   • ELK Stack (Log-Aggregation)                                  │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

# docker-compose.yml
version: "3.8"

services:
  # OpenClaw Gateway
  openclaw:
    image: openclaw/openclaw:latest
    container_name: openclaw-gateway
    restart: unless-stopped
    environment:
      - OPENCLAW_CONFIG_PATH=/config
      - N8N_API_KEY=${N8N_API_KEY}
      - REDIS_URL=redis://redis:6379
    volumes:
      - ./config:/config:ro
      - openclaw-data:/data
    depends_on:
      - redis
    networks:
      - openclaw-network
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: "2"
          memory: 4G

  # MCP Server
  n8n-mcp-server:
    image: company/n8n-mcp-server:latest
    container_name: n8n-mcp
    restart: unless-stopped
    environment:
      - N8N_HOST=${N8N_HOST}
      - N8N_API_KEY=${N8N_API_KEY}
      - LOG_LEVEL=info
    networks:
      - openclaw-network
      - n8n-network
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: "1"
          memory: 2G

  # Redis für Session-State
  redis:
    image: redis:7-alpine
    container_name: openclaw-redis
    restart: unless-stopped
    volumes:
      - redis-data:/data
    networks:
      - openclaw-network
    command: redis-server --appendonly yes --maxmemory 2gb --maxmemory-policy allkeys-lru

  # n8n (vereinfacht - externer Cluster oder compose)
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - WEBHOOK_URL=${WEBHOOK_URL}
    volumes:
      - n8n-data:/home/node/.n8n
    depends_on:
      - postgres
    networks:
      - n8n-network

  # PostgreSQL für n8n
  postgres:
    image: postgres:15-alpine
    container_name: n8n-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=n8n
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - n8n-network

  # Monitoring
  prometheus:
    image: prom/prometheus:latest
    container_name: openclaw-prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    networks:
      - openclaw-network

  grafana:
    image: grafana/grafana:latest
    container_name: openclaw-grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
    networks:
      - openclaw-network

networks:
  openclaw-network:
    driver: bridge
  n8n-network:
    driver: bridge

volumes:
  openclaw-data:
  redis-data:
  n8n-data:
  postgres-data:
  prometheus-data:
  grafana-data:

// Prometheus-Metriken
import { Counter, Histogram, Gauge } from "prom-client";

const mcpMetrics = {
  // Tool-Invocation-Metriken
  toolInvocations: new Counter({
    name: "mcp_tool_invocations_total",
    help: "Gesamtzahl der Tool-Invocations",
    labelNames: ["server", "tool", "status"],
  }),

  // Ausführungsdauer
  executionDuration: new Histogram({
    name: "mcp_execution_duration_seconds",
    help: "Dauer der Tool-Ausführungen",
    labelNames: ["server", "tool"],
    buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60],
  }),

  // Aktive Verbindungen
  activeConnections: new Gauge({
    name: "mcp_active_connections",
    help: "Anzahl der aktiven MCP-Verbindungen",
    labelNames: ["server"],
  }),

  // Tool-Discovery-Metriken
  toolDiscoveryTime: new Histogram({
    name: "mcp_tool_discovery_duration_seconds",
    help: "Zeit zur Discovery verfügbarer Tools",
    labelNames: ["server"],
  }),

  // Fehlerraten
  errorRate: new Counter({
    name: "mcp_errors_total",
    help: "Gesamtzahl der MCP-Fehler",
    labelNames: ["server", "error_type"],
  }),
};

// Health-Check-Endpunkt
interface HealthStatus {
  status: "healthy" | "degraded" | "unhealthy";
  checks: {
    mcpConnection: ComponentHealth;
    n8nApi: ComponentHealth;
    database: ComponentHealth;
    memory: ComponentHealth;
  };
  timestamp: string;
}

class HealthChecker {
  async check(): Promise<HealthStatus> {
    const checks = await Promise.all([
      this.checkMcpConnection(),
      this.checkN8nApi(),
      this.checkDatabase(),
      this.checkMemory(),
    ]);

    const overallStatus = this.determineOverallStatus(checks);

    return {
      status: overallStatus,
      checks: {
        mcpConnection: checks[0],
        n8nApi: checks[1],
        database: checks[2],
        memory: checks[3],
      },
      timestamp: new Date().toISOString(),
    };
  }

  private async checkMcpConnection(): Promise<ComponentHealth> {
    try {
      const start = Date.now();
      await this.mcpClient.ping();
      const latency = Date.now() - start;

      return {
        status: latency < 1000 ? "healthy" : "degraded",
        latency: `${latency}ms`,
        message: "MCP-Verbindung aktiv",
      };
    } catch (error) {
      return {
        status: "unhealthy",
        message: `MCP-Verbindung fehlgeschlagen: ${error.message}`,
      };
    }
  }

  private determineOverallStatus(checks: ComponentHealth[]): HealthStatus["status"] {
    if (checks.every((c) => c.status === "healthy")) return "healthy";
    if (checks.some((c) => c.status === "unhealthy")) return "unhealthy";
    return "degraded";
  }
}

# prometheus/alerts.yml
groups:
  - name: mcp_alerts
    rules:
      - alert: MCPHighErrorRate
        expr: rate(mcp_errors_total[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Hohe MCP-Fehlerrate"
          description: "Fehlerrate ist {{ $value }} Fehler/Sekunde für {{ $labels.server }}"

      - alert: MCPHighLatency
        expr: histogram_quantile(0.95, rate(mcp_execution_duration_seconds_bucket[5m])) > 30
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe MCP-Ausführungslatenz"
          description: "95. Perzentil Latenz ist {{ $value }}s"

      - alert: N8NQueueBacklog
        expr: n8n_queue_depth > 100
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "n8n Execution Queue Backlog"
          description: "Queue-Tiefe ist {{ $value }} Executions"

      - alert: MCPConnectionLoss
        expr: mcp_active_connections == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "MCP-Verbindung verloren"
          description: "Keine aktiven MCP-Verbindungen"

// Multi-Layer-Caching
interface CacheStrategy {
  // In-Memory-Cache für Hot Data
  l1: LRUCache<string, any>;
  
  // Redis für verteilten Cache
  l2: Redis;
  
  // Persistenter Cache für Tool-Definitionen
  l3: DatabaseCache;
}

class ToolCache {
  private l1: LRUCache<string, ToolDefinition>;
  private l2: Redis;

  constructor() {
    this.l1 = new LRUCache({
      max: 1000,
      ttl: 1000 * 60 * 5, // 5 Minuten
    });
    this.l2 = new Redis(process.env.REDIS_URL);
  }

  async getToolDefinition(server: string, tool: string): Promise<ToolDefinition | null> {
    const key = `tool:${server}:${tool}`;
    
    // L1: Memory-Cache
    const l1Value = this.l1.get(key);
    if (l1Value) return l1Value;

    // L2: Redis-Cache
    const l2Value = await this.l2.get(key);
    if (l2Value) {
      const parsed = JSON.parse(l2Value);
      this.l1.set(key, parsed);
      return parsed;
    }

    return null;
  }

  async setToolDefinition(
    server: string,
    tool: string,
    definition: ToolDefinition
  ): Promise<void> {
    const key = `tool:${server}:${tool}`;
    const value = JSON.stringify(definition);

    // Beide Caches updaten
    this.l1.set(key, definition);
    await this.l2.setex(key, 3600, value); // 1 Stunde TTL
  }
}

// HTTP-Connection-Pool für n8n API
class N8nConnectionPool {
  private agent: Agent;
  private maxSockets: number;
  private maxFreeSockets: number;
  private timeout: number;

  constructor(config: PoolConfig) {
    this.maxSockets = config.maxSockets || 50;
    this.maxFreeSockets = config.maxFreeSockets || 10;
    this.timeout = config.timeout || 30000;

    this.agent = new Agent({
      keepAlive: true,
      maxSockets: this.maxSockets,
      maxFreeSockets: this.maxFreeSockets,
      timeout: this.timeout,
      freeSocketTimeout: 30000,
    });
  }

  async request(url: string, options: RequestInit): Promise<Response> {
    return fetch(url, {
      ...options,
      agent: this.agent,
    });
  }

  getStats(): PoolStats {
    return {
      activeConnections: this.agent.activeConnections,
      idleConnections: this.agent.idleConnections,
      pendingRequests: this.agent.pendingRequests,
    };
  }
}