┌─────────────────────────────────────────────────────────────────┐
│                    MCP ARCHITECTURE                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│   ┌─────────────┐         ┌─────────────┐         ┌───────────┐  │
│   │   MCP       │         │   MCP       │         │   Tools   │  │
│   │   Client    │◄───────►│   Server    │◄───────►│   (n8n)   │  │
│   │             │         │             │         │           │  │
│   │  OpenClaw   │         │  Protocol   │         │ Workflows │  │
│   │  Claude     │         │  Bridge     │         │ APIs      │  │
│   │  Cursor     │         │             │         │ Services  │  │
│   └─────────────┘         └─────────────┘         └───────────┘  │
│                                                                   │
│   การค้นหาเครื่องมือ การเรียกใช้ และการแชร์ Context แบบมาตรฐาน      │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────┐
│                     MCP REQUEST FLOW                            │
├──────────────────────────────────────────────────────────────────┤
│                                                                    │
│  1. DISCOVERY                                                      │
│     ┌─────────┐  แสดง Tools/Resources   ┌─────────┐               │
│     │ Client  │ ──────────────────────► │ Server  │               │
│     │         │ ◄────────────────────── │         │               │
│     └─────────┘   คำนิยาม Tools          └─────────┘               │
│                                                                    │
│  2. INVOCATION                                                     │
│     ┌─────────┐  เรียก Tool (พารามิเตอร์) ┌─────────┐             │
│     │ Client  │ ──────────────────────► │ Server  │               │
│     │         │ ◄────────────────────── │         │               │
│     └─────────┘   ผลลัพธ์/ข้อผิดพลาด     └─────────┘               │
│                                                                    │
│  3. CONTEXT SHARING                                                │
│     • คำนิยาม Schema                                               │
│     • ข้อมูลข้อผิดพลาด                                               │
│     • การอัปเดตความคืบหน้า                                             │
│     • การสมัครสมาชิก Resources                                       │
│                                                                    │
└──────────────────────────────────────────────────────────────────┘

# การกำหนดค่า MCP ของ OpenClaw (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}"
      
  # 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 INTEGRATION FLOW                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ข้อความจากผู้ใช้                                                  │
│       │                                                           │
│       ▼                                                           │
│  ┌─────────────────┐                                              │
│  │  OpenClaw       │  1. แยกเจตนา ระบุเป้าหมาย                      │
│  │  Gateway        │  2. โหลด Context การสนทนา                   │
│  │                 │  3. กำหนดความสามารถที่ต้องการ                │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  Tool Selection │  วิเคราะห์เครื่องมือ MCP ที่มี               │
│  │  (LLM Reasoning)│  เลือกลำดับเครื่องมือที่เหมาะสมที่สุด       │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  MCP Client     │  จัดรูปแบบคำขอ MCP                           │
│  │  Layer          │  เรียกใช้เครื่องมือ                           │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  MCP Server     │  ประมวลผลคำขอ                               │
│  │  (n8n/Make/etc)│  ดำเนินการ Workflow/API Call                │
│  └────────┬────────┘                                              │
│           │                                                       │
│           ▼                                                       │
│  ┌─────────────────┐                                              │
│  │  Result         │  แยกวิเคราะห์ Response                       │
│  │  Processing     │  อัปเดต Context                             │
│  │                 │  สร้างการตอบสนองผู้ใช้                       │
│  └─────────────────┘                                              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

// Tool Capabilities กำหนดการดำเนินการที่อนุญาต
interface ToolCapabilities {
  read: boolean;      // อ่านข้อมูลได้
  write: boolean;     // แก้ไขข้อมูลได้
  execute: boolean;   // กระตุ้นการกระทำได้
  admin: boolean;     // ฟังก์ชันการดูแลระบบ
}

// แต่ละ MCP Server ลงทะเบียนด้วย Capabilities เฉพาะ
const n8nServer = {
  name: "n8n-automation",
  capabilities: ["read", "write", "execute"],
  restrictedWorkflows: ["production-deployments"] // ยกเว้น Workflows ที่ละเอียดอ่อน
};

# การกำหนดค่าการอนุมัติของ OpenClaw
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                               │ │   │
│   │  │  • การจัดการ Execution                           │ │   │
│   │  │  • การจัดการ Credentials                         │ │   │
│   │  │  • การจัดการ Webhook                             │ │   │
│   │  └───────────────────────┬─────────────────────────────┘ │   │
│   │                          │                               │   │
│   │  ┌───────────────────────▼─────────────────────────────┐ │   │
│   │  │              Authentication Layer                   │ │   │
│   │  │  • การตรวจสอบ API Key                            │ │   │
│   │  │  • การสนับสนุน OAuth 2.0                        │ │   │
│   │  │  • การตรวจสอบ JWT Token                         │ │   │
│   │  └───────────────────────────────────────────────────┘ │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│   Transport: stdio | SSE | WebSocket                               │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

# สร้างไดเรกทอรีโปรเจกต์
mkdir n8n-mcp-server
cd n8n-mcp-server
npm init -y

# ติดตั้ง Dependencies
npm install @modelcontextprotocol/sdk zod dotenv winston
npm install -D @types/node typescript

# เริ่มต้น TypeScript
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() {
    // แสดงรายการเครื่องมือที่มีอยู่
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      const tools = await this.toolRegistry.getTools();
      return { tools };
    });

    // ดำเนินการเครื่องมือ
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
      
      logger.info(`กำลังดำเนินการเครื่องมือ: ${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(`การดำเนินการเครื่องมือล้มเหลว: ${name}`, { error });
        throw error;
      }
    });

    // แสดงรายการ Resources ที่มีอยู่
    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
      const resources = await this.toolRegistry.getResources();
      return { resources };
    });

    // อ่าน Resource
    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 กำลังทำงานบน stdio");
  }
}

// เริ่มต้น Server
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 ข้อผิดพลาด: ${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(`กำลังกระตุ้นการดำเนินการ Workflow: ${workflowId}`);

    // ใช้ Webhook ถ้ามี มิฉะนั้นใช้การดำเนินการโดยตรง
    try {
      const response = await this.request<ExecutionResult>(
        `/workflows/${workflowId}/execute`,
        {
          method: "POST",
          body: JSON.stringify(data),
        }
      );
      return response;
    } catch (error) {
      // Fallback ไปยังการดำเนินการ Webhook
      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 ล้มเหลว: ${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("กำลังค้นหา Workflows ของ n8n...");
    
    try {
      const workflows = await this.n8nClient.getWorkflows();
      
      for (const workflow of workflows) {
        // เปิดเผยเฉพาะ Workflows ที่ Active และมี Tag MCP
        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: `ดำเนินการ n8n Workflow: ${workflow.name}`,
          inputSchema: z.object({
            data: z.record(z.any()).optional().describe("ข้อมูล Input ของ Workflow"),
            waitForCompletion: z
              .boolean()
              .optional()
              .default(true)
              .describe("รอให้ Workflow เสร็จสิ้น"),
          }),
          workflowId: workflow.id,
          tags: ["n8n", "workflow", ...(workflow.tags?.map((t) => t.name) || [])],
        });

        // ลงทะเบียนเป็น Resource สำหรับประวัติการดำเนินการ
        this.resources.set(`execution-history://${workflow.id}`, {
          uri: `execution-history://${workflow.id}`,
          name: `${toolName}-history`,
          mimeType: "application/json",
          description: `ประวัติการดำเนินการสำหรับ Workflow: ${workflow.name}`,
        });
      }

      logger.info(`ค้นพบ ${this.tools.size} Workflows ที่รองรับ MCP`);
    } catch (error) {
      logger.error("การค้นหา Workflows ล้มเหลว", { error });
    }
  }

  private registerStaticTools() {
    // เครื่องมือ: แสดงรายการ Workflows ทั้งหมด
    this.tools.set("list_workflows", {
      name: "list_workflows",
      description: "แสดงรายการ Workflows ของ n8n ที่มี Tag MCP ทั้งหมด",
      inputSchema: z.object({
        includeInactive: z.boolean().optional().default(false),
      }),
      tags: ["discovery", "metadata"],
    });

    // เครื่องมือ: รับสถานะ Workflow
    this.tools.set("get_workflow_status", {
      name: "get_workflow_status",
      description: "รับสถานะปัจจุบันและการดำเนินการล่าสุดของ Workflow",
      inputSchema: z.object({
        workflowId: z.string().describe("ID ของ Workflow ที่ต้องการตรวจสอบ"),
      }),
      tags: ["monitoring", "status"],
    });

    // เครื่องมือ: ค้นหา Executions
    this.tools.set("search_executions", {
      name: "search_executions",
      description: "ค้นหาประวัติการดำเนินการของ Workflow ด้วยตัวกรอง",
      inputSchema: z.object({
        workflowId: z.string().optional().describe("กรองตาม Workflow ID"),
        status: z.enum(["success", "error", "running"]).optional(),
        since: z.string().optional().describe("สตริงวันที่ ISO"),
        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(`ไม่พบเครื่องมือ: ${name}`);
    }

    // ตรวจสอบ Input
    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(`เครื่องมือที่ไม่รู้จัก: ${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);
    }
    // ใช้งานการค้นหาที่กว้างขึ้นหากจำเป็น
    return [];
  }

  private async handleWorkflowExecution(tool: Tool, args: any) {
    if (!tool.workflowId) {
      throw new Error(`ไม่มีการกำหนดค่า Workflow ID สำหรับเครื่องมือ: ${tool.name}`);
    }

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

    if (args.waitForCompletion && result.executionId) {
      // รอการสำรวจให้เสร็จสิ้น
      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(`หมดเวลาการดำเนินการ: ${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(`ไม่พบ Resource: ${uri}`);
    }

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

// Helper: แปลง Zod Schema เป็น JSON Schema
function zodToJsonSchema(schema: z.ZodType<any>): any {
  return {
    type: "object",
    properties: {},
    // แบบง่าย — ใช้ไลบรารี zod-to-json-schema สำหรับการแปลงเต็มรูปแบบ
  };
}

# ~/.config/openclaw/mcp.yml
servers:
  # 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: []  # ต้องได้รับการอนุมัติสำหรับการดำเนินการทั้งหมด
    
  # n8n Instance สำหรับ Development
  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"  # ปลอดภัยสำหรับ Auto-Approve
      - "get_workflow_status"

  # Composio ภายนอก (สำหรับเครื่องมือเพิ่มเติม)
  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

# ตรวจสอบว่า MCP Servers ถูกโหลดแล้ว
openclaw mcp status

# ผลลัพธ์ที่คาดหวัง:
# ┌─────────────────┬─────────┬────────────┬─────────────────────────┐
# │ 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 │
# └─────────────────┴─────────┴────────────┴─────────────────────────┘

# ทดสอบการเรียกใช้เครื่องมือ
openclaw mcp test n8n-enterprise list_workflows

┌─────────────────────────────────────────────────────────────────┐
│              ระบบอัตโนมัติการสนับสนุนลูกค้า                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  1. ข้อความจากลูกค้า (WhatsApp)                                    │
│     "สวัสดี ฉันถูกเรียกเก็บเงินสองครั้งสำหรับคำสั่งซื้อ #12345" │
│                          │                                        │
│                          ▼                                        │
│  2. การวิเคราะห์ของ OpenClaw                                      │
│     • Intent: billing_issue                                       │
│     • Entities: order_id=12345, issue=duplicate_charge            │
│     • Sentiment: กังวล                                               │
│     • Priority: สูง (billing)                                     │
│                          │                                        │
│                          ▼                                        │
│  3. การเรียกใช้ MCP Tool                                           │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ Tool: lookup_order                                    │   │
│     │ Params: { order_id: "12345" }                         │   │
│     └─────────────────────────────────────────────────────────┘   │
│                          │                                        │
│                          ▼                                        │
│  4. การดำเนินการ n8n Workflow                                     │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ • คิวรีข้อมูลคำสั่งซื้อจาก Shopify                        │   │
│     │ • ตรวจสอบบันทึกการชำระเงินจาก Stripe                     │   │
│     │ • ยืนยันการเรียกเก็บเงินซ้ำ                               │   │
│     │ • สร้าง Ticket ใน Zendesk                                │   │
│     │ • คำนวณจำนวนเงินคืน                                       │   │
│     └─────────────────────────────────────────────────────────┘   │
│                          │                                        │
│                          ▼                                        │
│  5. การตอบสนองของ OpenClaw                                        │
│     "ฉันพบคำสั่งซื้อ #12345 ของคุณแล้ว คุณถูกเรียกเก็บเงินจริง   │
│      ($89.99 x 2) ฉันได้สร้าง Ticket #Z-4567 และเริ่มต้น       │
│      การคืนเงินสำหรับการเรียกเก็บเงินซ้ำแล้ว คุณควรจะเห็น       │
│      การคืนเงินภายใน 3-5 วันทำการ มีอะไรอีกไหมที่ฉันช่วยได้?"  │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              WORKFLOW SALES INTELLIGENCE                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ข้อความ Slack:                                                  │
│  "คุยกับ Acme Corp สัปดาห์หน้า มีใครรู้จักพวกเขาบ้างไหม?"        │
│                                                                   │
│  การดำเนินการของ OpenClaw:                                        │
│  1. แยก: prospect="Acme Corp"                                    │
│  2. เรียกใช้ MCP Tools:                                          │
│     • enrich_company_data                                         │
│     • find_similar_customers                                      │
│     • get_competitive_intel                                       │
│     • check_existing_opportunity                                  │
│                                                                   │
│  การดำเนินการ n8n แบบขนาน:                                        │
│  ┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐     │
│  │ Clearbit API    │ │ LinkedIn        │ │ Salesforce       │     │
│  │ • Company size  │ │ • Key contacts  │ │ • Opp history    │     │
│  │ • Industry      │ │ • Mutual conns  │ │ • Similar wins   │     │
│  │ • Technologies  │ │ • Recent posts  │ │ • Win rate       │     │
│  └─────────────────┘ └─────────────────┘ └──────────────────┘     │
│                                                                   │
│  การตอบสนองของ OpenClaw (Slack):                                   │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ 🎯 รายงานข้อมูล Acme Corp                                  ││
│  │                                                              ││
│  │ **บริษัท**: พนักงาน 500 คน, Series C, SaaS/FinTech          ││
│  │ **Tech Stack**: AWS, Salesforce, Segment, Zendesk          ││
│  │ **ดีลที่คล้ายกัน**: TechCorp ($250K), InnovateLtd          ││
│  │                                                              ││
│  │ **Key Contacts**:                                             ││
│  │ • Sarah Chen (CTO) - อดีตเพื่อนร่วมงานของเรา!              ││
│  │ • Mike Ross (VP Sales) - โพสต์เกี่ยวกับความต้องการ Automation││
│  │                                                              ││
│  │ **โอกาส**: ศักยภาพ $150K ARR, อัตราชนะ 85%                 ││
│  │ สำหรับโปรไฟล์ที่คล้ายกัน ไม่มี Opp ที่มีอยู่ใน Salesforce    ││
│  │                                                              ││
│  │ [ดูรายงานฉบับเต็ม] [สร้าง Opportunity] [นัดหมาย]          ││
│  └─────────────────────────────────────────────────────────────┘│
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              DEVOPS AUTOMATION พร้อมการอนุมัติ                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  นักพัฒนา (Discord):                                              │
│  "@Claw กรุณา deploy hotfix สำหรับ bug การชำระเงินไปยัง production"│
│                                                                   │
│  การประมวลผลของ OpenClaw:                                         │
│  1. การวิเคราะห์ Intent: deploy_hotfix                          │
│  2. การรวบรวม Context:                                            │
│     • Branch ปัจจุบัน: hotfix/payment-gateway-fix                │
│     • Commit ล่าสุด: 2 ชั่วโมงที่แล้ว                              │
│     • CI Status: ✅ passed                                        │
│     • Tests: ✅ 247/247 ผ่าน                                        │
│                                                                   │
│  3. การประเมินความเสี่ยง: สูง (Production Deployment)            │
│                                                                   │
│  4. คำขอการอนุมัติ (Slack #deployments):                          │
│     ┌─────────────────────────────────────────────────────────┐   │
│     │ 🚀 คำขอ Deploy Hotfix Production                        │   │
│     │                                                          │   │
│     │ Branch: hotfix/payment-gateway-fix                      │   │
│     │ Commit: abc1234 - แก้ไข bug การประมวลผลการชำระเงินวิกฤต  │   │
│     │ Tests: ✅ ทั้งหมดผ่าน                                      │   │
│     │ Rollback: พร้อม (image ก่อนหน้า: prod-v2.3.1)           │   │
│     │                                                          │   │
│     │ ขอโดย: @developer ผ่าน OpenClaw                         │   │
│     │                                                          │   │
│     │ [อนุมัติ] [ปฏิเสธ] [กำหนดเวลา ตี 2]                     │   │
│     └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│  5. เมื่อได้รับการอนุมัติ → n8n Workflow:                         │
│     • Tag release: v2.3.2-hotfix                                 │
│     • สร้าง Docker Image                                          │
│     • Push ไปยัง Registry                                         │
│     • อัปเดต Kubernetes Deployment                                 │
│     • รัน Smoke Tests                                              │
│     • แจ้งเตือน #general channel                                  │
│     • อัปเดต Status Page                                          │
│                                                                   │
│  6. การยืนยันของ OpenClaw:                                         │
│     "✅ Hotfix deploy สำเร็จไปยัง production (v2.3.2) แล้ว       │
│      Smoke Tests ผ่าน บันทึกการ Deploy: [ลิงก์]"                 │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

// การจัดเก็บ Credentials อย่างปลอดภัยพร้อมการหมุนเวียน
interface CredentialManager {
  // จัดเก็บ Credentials ที่เข้ารหัส
  store(key: string, value: string, metadata: CredentialMetadata): Promise<void>;
  
  // ดึงข้อมูลพร้อม Audit Logging
  retrieve(key: string, requestContext: RequestContext): Promise<string>;
  
  // การหมุนเวียนอัตโนมัติ
  rotate(key: string): Promise<void>;
  
  // การเพิกถอน
  revoke(key: string): Promise<void>;
}

// การใช้งานด้วย 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,
      },
    });
  }
}

# ตารางสิทธิ์
permissions:
  # การดำเนินการอ่านอย่างเดียว
  viewer:
    tools:
      - list_workflows
      - get_workflow_status
      - search_executions
    resources:
      - "execution-history://*"
      
  # การดำเนินการของผู้ใช้มาตรฐาน
  operator:
    extends: viewer
    tools:
      - execute_workflow
    workflows:
      - "*"
    exclude_workflows:
      - "production-deployments"
      - "finance-reports"
      
  # การดำเนินการของผู้ดูแลระบบ
  admin:
    tools:
      - "*"
    workflows:
      - "*"
    resources:
      - "*"

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) {
    // เขียนไปยัง Log Store ที่ไม่สามารถเปลี่ยนแปลงได้
    await this.writeToLogStore(event);
    
    // แจ้งเตือน Real-time สำหรับความผิดปกติ
    if (this.isAnomalous(event)) {
      await this.sendSecurityAlert(event);
    }
    
    // การผสานรวม SIEM
    await this.forwardToSIEM(event);
    
    // การส่งออก Compliance
    await this.updateComplianceIndex(event);
  }

  private isAnomalous(event: AuditEvent): boolean {
    // ตรวจจับรูปแบบที่ผิดปกติ
    const rules = [
      // การเรียกใช้งานความถี่สูง
      () => this.checkRateAnomaly(event),
      // การเข้าถึง Workflow ที่ละเอียดอ่อน
      () => this.checkSensitiveAccess(event),
      // กิจกรรมนอกเวลาทำการ
      () => this.checkTimeAnomaly(event),
      // รูปแบบการตรวจสอบสิทธิ์ที่ล้มเหลว
      () => this.checkAuthFailures(event),
    ];
    
    return rules.some((rule) => rule());
  }
}