┌─────────────────────────────────────────────────────────────────────────┐
│           WEB SCRAPING แบบดั้งเดิม vs AI BROWSER AGENTS                 │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Web Scraping แบบดั้งเดิม:              AI Browser Agent:              │
│  ┌──────────────────┐                    ┌──────────────────┐            │
│  │ fetch(URL)       │                    │ "ค้นหาและจอง     │            │
│  │ parse(HTML)      │                    │ เที่ยวบินที่ถูก   │            │
│  │ extract(CSS)     │                    │ ที่สุดไปปารีส    │            │
│  │ → เปราะบาง      │                    │ วันศุกร์หน้า"   │            │
│  └──────────────────┘                    └──────────────────┘            │
│          │                                      │                      │
│          ▼                                      ▼                      │
│  ┌──────────────────┐                  ┌──────────────────┐            │
│  │ พังเมื่อมี       │                  │ เข้าใจบริบท    │            │
│  │ การเปลี่ยนแปลง   │                  │ ปรับตัวตาม      │            │
│  │ เลย์เอาต์       │                  │ การเปลี่ยนแปลง  │            │
│  │ ต้องบำรุงรักษา   │                  │ จัดการ auth     │            │
│  │ ต่อเนื่อง         │                  │ ได้              │            │
│  └──────────────────┘                  └──────────────────┘            │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                  สถาปัตยกรรม AI BROWSER AGENT                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌──────────────┐     คำสั่ง          ┌──────────────┐                │
│  │   มนุษย์      │──────────────────────►│   Agent      │                │
│  │   ผู้ดำเนิน  │                       │   Controller │                │
│  └──────────────┘                       └──────┬───────┘                │
│                                                 │                      │
│                    ┌────────────────────────────┼────────────┐       │
│                    │                            │            │       │
│                    ▼                            ▼            ▼       │
│           ┌──────────────┐              ┌──────────────┐ ┌──────────┐  │
│           │   โมดูล      │              │   เครื่อง     │ │ ระบบ    │  │
│           │   วางแผน     │◄────────────►│   มือ        │ │ หน่วย    │  │
│           │  (LLM)       │   สถานะ       │   (Playwright)│ │ ความจำ  │  │
│           └──────────────┘              └──────┬───────┘ └──────────┘  │
│                                                 │                      │
│                                                 ▼                      │
│                                        ┌──────────────┐               │
│                                        │   เว็บไซต์   │               │
│                                        │   เป้าหมาย   │               │
│                                        └──────────────┘               │
│                                                                         │
│  ส่วนประกอบหลัก:                                                        │
│  • โมดูลวางแผน: การตัดสินใจที่ขับเคลื่อนด้วย LLM                       │
│  • เครื่องมือเบราว์เซอร์: Playwright สำหรับการโต้ตอบ                   │
│  • ระบบหน่วยความจำ: การรักษาบริบทข้ามขั้นตอน                             │
│  • รีจิสทรีเครื่องมือ: การดำเนินการที่มีอยู่ (คลิก พิมพ์ เลื่อน)        │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

const PLANNING_PROMPT = `
คุณเป็น Agent การนำทางเว็บที่ชาญฉลาด งานของคุณคือโต้ตอบกับเว็บไซต์เพื่อบรรลุเป้าหมายของผู้ใช้

สถานะปัจจุบัน:
- URL: {{ currentUrl }}
- ชื่อหน้า: {{ pageTitle }}
- Screenshot: [รูปภาพเข้ารหัส Base64]
- การดำเนินการที่มีอยู่: {{ availableActions }}
- การดำเนินการก่อนหน้า: {{ actionHistory }}

เป้าหมาย: {{ userGoal }}

คำแนะนำ:
1. วิเคราะห์สถานะหน้าปัจจุบันจาก screenshot
2. ตรวจสอบความคืบหน้าของคุณต่อเป้าหมาย
3. เลือกการดำเนินการหนึ่งรายการจากตัวเลือกที่มีอยู่
4. หากเป้าหมายเสร็จสมบูรณ์ ตอบกลับด้วย "เสร็จสิ้น" และผลลัพธ์
5. หากติดขัด อธิบายว่าทำไมและขอความช่วยเหลือจากมนุษย์

ตอบกลับในรูปแบบ JSON:
{
  "reasoning": "กระบวนการคิดแบบลำดับขั้นของคุณ",
  "action": "การดำเนินการที่จะดำเนินการ",
  "parameters": { /* พารามิเตอร์เฉพาะการดำเนินการ */ },
  "confidence": 0.95
}
`;

# SSH เข้าเซิร์ฟเวอร์หรือคอนเทนเนอร์ n8n ของคุณ
ssh user@your-n8n-server

# นำทางไปยังไดเรกทอรีการติดตั้ง n8n
cd /opt/n8n

# ติดตั้ง Playwright และเบราว์เซอร์
npm install playwright

# ติดตั้งไบนารีเบราว์เซอร์
npx playwright install chromium
npx playwright install firefox

# ติดตั้งการพึ่งพาระบบ (Ubuntu/Debian)
npx playwright install-deps chromium

// n8n Function Node - LLM Agent Controller พร้อม Vision
const { OpenAI } = require('openai');

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

async function planNextAction(goal, screenshot, history, pageInfo) {
  const messages = [
    {
      role: 'system',
      content: `คุณเป็น Agent การทำงานอัตโนมัติเว็บเชี่ยวชาญ งานของคุณคือนำทางเว็บไซต์และดึงข้อมูล

การดำเนินการที่มีอยู่:
1. navigate({ url }) - ไปยัง URL ที่ระบุ
2. click({ selector }) - คลิกองค์ประกอบ
3. type({ selector, text }) - พิมพ์ข้อความลงในช่องป้อนข้อมูล
4. scroll({ direction, amount }) - เลื่อนหน้า
5. extract({ selector }) - แยกข้อความจากองค์ประกอบ
6. screenshot({ fullPage }) - ถ่ายภาพหน้าจอ
7. done({ result }) - งานเสร็จสมบูรณ์ ส่งคืนผลลัพธ์

กฎ:
- วิเคราะห์ screenshot อย่างระมัดระวังเพื่อเข้าใจโครงสร้างหน้า
- ใช้ CSS selectors ที่เฉพาะเจาะจงและเชื่อถือได้
- หากการดำเนินการล้มเหลว ลองใช้วิธีการทางเลือก
- ให้เหตุผลสำหรับการดำเนินการแต่ละครั้ง
- ส่งคืนเฉพาะ JSON ที่ถูกต้องเท่านั้น`
    },
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: `เป้าหมาย: ${goal}

ข้อมูลหน้า:
- URL: ${pageInfo.url}
- ชื่อเรื่อง: ${pageInfo.title}

การดำเนินการก่อนหน้า:
${history.map((h, i) => `${i + 1}. ${h.action}: ${h.reasoning}`).join('\n')}

Screenshot ปัจจุบัน:`
        },
        {
          type: 'image_url',
          image_url: {
            url: screenshot,
            detail: 'high'
          }
        }
      ]
    }
  ];
  
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages,
    max_tokens: 1000,
    temperature: 0.2,
    response_format: { type: 'json_object' }
  });
  
  try {
    const result = JSON.parse(response.choices[0].message.content);
    return result;
  } catch (error) {
    return {
      action: 'done',
      parameters: { 
        result: 'ข้อผิดพลาดในการแยกวิเคราะห์การตอบกลับ LLM',
        rawResponse: response.choices[0].message.content 
      },
      reasoning: 'ไม่สามารถแยกวิเคราะห์การตอบกลับ JSON'
    };
  }
}

// ตัวจัดการการยืนยันตัวตน
class AuthHandler {
  async handleLogin(sessionId, credentials, browserService) {
    const { page } = browserService.browsers.get(sessionId);
    
    // ขั้นตอนที่ 1: นำทางไปยังหน้าเข้าสู่ระบบ
    await browserService.navigate(sessionId, credentials.loginUrl);
    await page.waitForTimeout(2000);
    
    // ขั้นตอนที่ 2: กรอกข้อมูลรับรอง
    await browserService.type(sessionId, credentials.usernameSelector, credentials.username);
    await browserService.type(sessionId, credentials.passwordSelector, credentials.password);
    
    // ขั้นตอนที่ 3: ส่งเข้าสู่ระบบ
    await browserService.click(sessionId, credentials.submitSelector);
    
    // ขั้นตอนที่ 4: จัดการ 2FA หากมีอยู่
    const has2FA = await this.detect2FA(page);
    if (has2FA) {
      const code = await this.get2FACode(credentials.twoFactorMethod);
      await browserService.type(sessionId, credentials.twoFASelector, code);
      await browserService.click(sessionId, credentials.twoFASubmitSelector);
    }
    
    // ขั้นตอนที่ 5: รอสถานะแดชบอร์ด/หลังเข้าสู่ระบบ
    await page.waitForSelector(credentials.postLoginSelector, { timeout: 30000 });
    
    // ขั้นตอนที่ 6: บันทึกสถานะเซสชัน
    const storageState = await page.context().storageState();
    await this.saveSession(sessionId, storageState);
    
    return { success: true, authenticated: true };
  }
  
  async detect2FA(page) {
    const twoFAIndicators = [
      'text=input[type="tel"]',  // ช่องป้อน OTP
      'input[name*="code"]',
      'input[placeholder*="code" i]',
      'text=สองปัจจัย',
      'text=รหัสยืนยัน'
    ];
    
    for (const indicator of twoFAIndicators) {
      const visible = await page.locator(indicator).isVisible().catch(() => false);
      if (visible) return true;
    }
    return false;
  }
  
  async get2FACode(method) {
    switch (method.type) {
      case 'totp':
        // สร้างรหัส TOTP
        const speakeasy = require('speakeasy');
        return speakeasy.totp({
          secret: method.secret,
          encoding: 'base32'
        });
        
      case 'email':
        // สำรวจอีเมลหารหัส
        return await this.pollEmailForCode(method.emailConfig);
        
      case 'sms':
        // ดึงจาก SMS API
        return await this.getSMSCode(method.phoneNumber);
        
      default:
        throw new Error('วิธี 2FA ที่ไม่รองรับ');
    }
  }
  
  async saveSession(sessionId, storageState) {
    // บันทึกลงใน Redis หรือฐานข้อมูลเพื่อใช้ซ้ำ
    const redis = require('redis');
    const client = redis.createClient();
    await client.set(`session:${sessionId}:storage`, JSON.stringify(storageState));
    await client.expire(`session:${sessionId}:storage`, 86400); // 24 ชั่วโมง
  }
  
  async restoreSession(sessionId, browserService) {
    const redis = require('redis');
    const client = redis.createClient();
    const storageState = await client.get(`session:${sessionId}:storage`);
    
    if (storageState) {
      // เปิดเบราว์เซอร์ด้วยสถานะที่บันทึกไว้
      const browser = await chromium.launch({ headless: true });
      const context = await browser.newContext({
        storageState: JSON.parse(storageState)
      });
      const page = await context.newPage();
      
      browserService.browsers.set(sessionId, { browser, context, page });
      return { success: true, restored: true };
    }
    
    return { success: false, restored: false };
  }
}

// การผสมผสาน Firecrawl
class FirecrawlService {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.firecrawl.dev/v1';
  }
  
  async scrapeUrl(url, options = {}) {
    const axios = require('axios');
    
    const response = await axios.post(`${this.baseUrl}/scrape`, {
      url,
      formats: options.formats || ['markdown', 'html'],
      onlyMainContent: options.onlyMainContent !== false,
      includeTags: options.includeTags || [],
      excludeTags: options.excludeTags || [],
      waitFor: options.waitFor || 0,
      timeout: options.timeout || 30000,
      actions: options.actions || [] // การดำเนินการก่อน scrape
    }, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });
    
    return response.data;
  }
  
  async crawlWebsite(url, options = {}) {
    const axios = require('axios');
    
    const response = await axios.post(`${this.baseUrl}/crawl`, {
      url,
      excludePaths: options.excludePaths || [],
      includePaths: options.includePaths || [],
      maxDepth: options.maxDepth || 2,
      limit: options.limit || 100,
      allowBackwardLinks: options.allowBackwardLinks || false,
      allowExternalLinks: options.allowExternalLinks || false,
      scrapeOptions: {
        formats: options.formats || ['markdown'],
        onlyMainContent: true
      }
    }, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });
    
    // ส่งคืน Job ID สำหรับการประมวลผลแบบ async
    return response.data;
  }
  
  async getCrawlStatus(jobId) {
    const axios = require('axios');
    
    const response = await axios.get(`${this.baseUrl}/crawl/${jobId}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });
    
    return response.data;
  }
  
  async searchAndExtract(query, options = {}) {
    const axios = require('axios');
    
    const response = await axios.post(`${this.baseUrl}/search`, {
      query,
      limit: options.limit || 5,
      lang: options.lang || 'th',
      country: options.country || 'th',
      scrapeOptions: {
        formats: ['markdown']
      }
    }, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });
    
    return response.data;
  }
  
  // การใช้งาน n8n Function Node
  async n8nScrapeNode(input) {
    const result = await this.scrapeUrl(
      input.json.url,
      input.json.options || {}
    );
    
    return [{ json: result }];
  }
}

// การใช้งาน n8n
const firecrawl = new FirecrawlService(process.env.FIRECRAWL_API_KEY);
return await firecrawl.n8nScrapeNode($input.first());

┌─────────────────────────────────────────────────────────────────────────┐
│                   MODEL CONTEXT PROTOCOL (MCP)                         │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────┐                    ┌─────────────┐                    │
│  │    AI       │◄──────────────────►│    MCP      │                    │
│  │   โมเดล     │    JSON-RPC         │   Server    │                    │
│  │  (Claude)   │   โปรโตคอล         │             │                    │
│  └─────────────┘                    └──────┬──────┘                    │
│                                           │                            │
│                              การเรียกใช้เครื่องมือ │                    │
│                                           ▼                            │
│                                    ┌─────────────┐                     │
│                                    │   เครื่อง     │                     │
│                                    │  อัตโนมัติ   │                     │
│                                    │ (Playwright)│                     │
│                                    └─────────────┘                     │
│                                                                         │
│  ความสามารถของ MCP:                                                     │
│  • tools/list - ค้นพบการดำเนินการเบราว์เซอร์ที่มีอยู่                    │
│  • tools/call - ดำเนินการ navigate, click, type, screenshot           │
│  • resources/read - รับเนื้อหาหน้า, screenshots                         │
│  • prompts/get - รับเทมเพลตเวิร์กโฟลว์                                │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// MCP Server สำหรับการทำงานอัตโนมัติเบราว์เซอร์ Playwright
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const { chromium } = require('playwright');

class PlaywrightMCPService {
  constructor() {
    this.server = new Server({
      name: 'playwright-browser-server',
      version: '1.0.0'
    }, {
      capabilities: {
        tools: {},
        resources: {}
      }
    });
    
    this.sessions = new Map();
    this.setupHandlers();
  }
  
  setupHandlers() {
    // แสดงรายการเครื่องมือที่มีอยู่
    this.server.setRequestHandler('tools/list', async () => ({
      tools: [
        {
          name: 'browser_launch',
          description: 'เริ่มเซสชันเบราว์เซอร์ใหม่',
          inputSchema: {
            type: 'object',
            properties: {
              headless: { type: 'boolean', default: true },
              browser: { type: 'string', enum: ['chromium', 'firefox', 'webkit'], default: 'chromium' }
            }
          }
        },
        {
          name: 'browser_navigate',
          description: 'นำทางไปยัง URL',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' },
              url: { type: 'string' }
            },
            required: ['sessionId', 'url']
          }
        },
        {
          name: 'browser_screenshot',
          description: 'ถ่ายภาพหน้าจอของหน้าปัจจุบัน',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' },
              fullPage: { type: 'boolean', default: false }
            },
            required: ['sessionId']
          }
        },
        {
          name: 'browser_click',
          description: 'คลิกองค์ประกอบบนหน้า',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' },
              selector: { type: 'string' },
              description: { type: 'string' }
            },
            required: ['sessionId', 'selector']
          }
        },
        {
          name: 'browser_type',
          description: 'พิมพ์ข้อความลงในช่องป้อนข้อมูล',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' },
              selector: { type: 'string' },
              text: { type: 'string' },
              description: { type: 'string' }
            },
            required: ['sessionId', 'selector', 'text']
          }
        },
        {
          name: 'browser_extract',
          description: 'ดึงข้อมูลจากหน้า',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' },
              selector: { type: 'string' },
              attributes: { type: 'array', items: { type: 'string' } }
            },
            required: ['sessionId', 'selector']
          }
        },
        {
          name: 'browser_close',
          description: 'ปิดเซสชันเบราว์เซอร์',
          inputSchema: {
            type: 'object',
            properties: {
              sessionId: { type: 'string' }
            },
            required: ['sessionId']
          }
        }
      ]
    }));
    
    // จัดการการเรียกใช้เครื่องมือ
    this.server.setRequestHandler('tools/call', async (request) => {
      const { name, arguments: args } = request.params;
      
      switch (name) {
        case 'browser_launch':
          return await this.handleLaunch(args);
        case 'browser_navigate':
          return await this.handleNavigate(args);
        case 'browser_screenshot':
          return await this.handleScreenshot(args);
        case 'browser_click':
          return await this.handleClick(args);
        case 'browser_type':
          return await this.handleType(args);
        case 'browser_extract':
          return await this.handleExtract(args);
        case 'browser_close':
          return await this.handleClose(args);
        default:
          throw new Error(`เครื่องมือที่ไม่รู้จัก: ${name}`);
      }
    });
  }
  
  async handleLaunch(args) {
    const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    
    const browser = await chromium.launch({
      headless: args.headless !== false
    });
    
    const context = await browser.newContext({
      viewport: { width: 1920, height: 1080 }
    });
    
    const page = await context.newPage();
    
    this.sessions.set(sessionId, { browser, context, page });
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          sessionId,
          status: 'เริ่มต้น',
          browser: args.browser || 'chromium'
        })
      }]
    };
  }
  
  async handleNavigate(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    await session.page.goto(args.url, { waitUntil: 'networkidle' });
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          url: session.page.url(),
          title: await session.page.title()
        })
      }]
    };
  }
  
  async handleScreenshot(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    const screenshot = await session.page.screenshot({
      fullPage: args.fullPage,
      encoding: 'base64',
      type: 'jpeg',
      quality: 80
    });
    
    return {
      content: [{
        type: 'image',
        data: screenshot,
        mimeType: 'image/jpeg'
      }, {
        type: 'text',
        text: `จับภาพหน้าจอแล้ว URL หน้า: ${session.page.url()}`
      }]
    };
  }
  
  async handleClick(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    await session.page.click(args.selector);
    await session.page.waitForTimeout(500);
    
    return {
      content: [{
        type: 'text',
        text: `คลิกองค์ประกอบ: ${args.description || args.selector}`
      }]
    };
  }
  
  async handleType(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    await session.page.fill(args.selector, args.text);
    
    return {
      content: [{
        type: 'text',
        text: `พิมพ์ "${args.text}" ลงใน ${args.description || args.selector}`
      }]
    };
  }
  
  async handleExtract(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    const elements = await session.page.locator(args.selector).all();
    const data = [];
    
    for (const element of elements) {
      const item = { text: await element.textContent() };
      
      if (args.attributes) {
        for (const attr of args.attributes) {
          item[attr] = await element.getAttribute(attr);
        }
      }
      
      data.push(item);
    }
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ count: data.length, data }, null, 2)
      }]
    };
  }
  
  async handleClose(args) {
    const session = this.sessions.get(args.sessionId);
    if (!session) throw new Error('ไม่พบเซสชัน');
    
    await session.browser.close();
    this.sessions.delete(args.sessionId);
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ sessionId: args.sessionId, status: 'ปิดแล้ว' })
      }]
    };
  }
  
  async start() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('เซิร์ฟเวอร์ Playwright MCP กำลังทำงานบน stdio');
  }
}

// เริ่มเซิร์ฟเวอร์
const service = new PlaywrightMCPService();
service.start().catch(console.error);

# playwright-agent-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: n8n-playwright-agent
  namespace: automation
spec:
  replicas: 3
  selector:
    matchLabels:
      app: n8n-playwright
  template:
    metadata:
      labels:
        app: n8n-playwright
    spec:
      containers:
      - name: n8n
        image: your-registry/n8n-playwright:latest
        ports:
        - containerPort: 5678
        env:
        - name: N8N_BASIC_AUTH_ACTIVE
          value: "true"
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: n8n-secrets
              key: openai-api-key
        - name: ANTHROPIC_API_KEY
          valueFrom:
            secretKeyRef:
              name: n8n-secrets
              key: anthropic-api-key
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        volumeMounts:
        - name: n8n-data
          mountPath: /home/node/.n8n
        - name: tmp
          mountPath: /tmp
      volumes:
      - name: n8n-data
        persistentVolumeClaim:
          claimName: n8n-pvc
      - name: tmp
        emptyDir: {}
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000

// Session Pool สำหรับการจัดการเบราว์เซอร์อย่างมีประสิทธิภาพ
class BrowserSessionPool {
  constructor(maxSessions = 10) {
    this.maxSessions = maxSessions;
    this.available = [];
    this.inUse = new Map();
    this.waiting = [];
    
    // ล้างเซสชันที่ค้างอยู่ทุก 5 นาที
    setInterval(() => this.cleanup(), 300000);
  }
  
  async acquire(sessionId, options = {}) {
    // ตรวจสอบว่ามีเซสชันอยู่แล้วหรือไม่และพร้อมใช้งาน
    const existingIndex = this.available.findIndex(s => s.sessionId === sessionId);
    if (existingIndex !== -1) {
      const session = this.available.splice(existingIndex, 1)[0];
      this.inUse.set(sessionId, session);
      return session;
    }
    
    // หากถึงความจุแล้ว รอเซสชัน
    if (this.inUse.size >= this.maxSessions) {
      return new Promise((resolve) => {
        this.waiting.push({ sessionId, options, resolve });
      });
    }
    
    // สร้างเซสชันใหม่
    const session = await this.createSession(sessionId, options);
    this.inUse.set(sessionId, session);
    return session;
  }
  
  async createSession(sessionId, options) {
    const { chromium } = require('playwright');
    
    const browser = await chromium.launch({
      headless: options.headless !== false,
      args: [
        '--no-sandbox',
        '--disable-setuid-sandbox',
        '--disable-dev-shm-usage',
        '--disable-gpu',
        '--disable-blink-features=AutomationControlled'
      ]
    });
    
    const context = await browser.newContext({
      viewport: { width: 1920, height: 1080 },
      userAgent: this.getRandomUserAgent()
    });
    
    // เพิ่มสคริปต์ต้านการตรวจจับ
    await context.addInitScript(() => {
      Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
    });
    
    const page = await context.newPage();
    
    return {
      sessionId,
      browser,
      context,
      page,
      createdAt: new Date(),
      lastUsed: new Date(),
      requestCount: 0
    };
  }
  
  release(sessionId) {
    const session = this.inUse.get(sessionId);
    if (!session) return;
    
    session.lastUsed = new Date();
    session.requestCount++;
    
    this.inUse.delete(sessionId);
    
    // รีไซเคิลหรือทำลายตามการใช้งาน
    if (session.requestCount > 100) {
      // ถึงการใช้งานสูงสุดแล้ว ปิดเบราว์เซอร์
      this.destroySession(session);
    } else {
      this.available.push(session);
    }
    
    // ประมวลผลคิวรอ
    if (this.waiting.length > 0) {
      const next = this.waiting.shift();
      this.acquire(next.sessionId, next.options).then(next.resolve);
    }
  }
  
  async destroySession(session) {
    try {
      await session.browser.close();
    } catch (e) {
      console.error('ข้อผิดพลาดในการปิดเบราว์เซอร์:', e);
    }
  }
  
  async cleanup() {
    const now = new Date();
    const maxIdleTime = 600000; // 10 นาที
    
    // ลบเซสชันที่ไม่ได้ใช้งาน
    this.available = this.available.filter(session => {
      const idleTime = now - session.lastUsed;
      if (idleTime > maxIdleTime) {
        this.destroySession(session);
        return false;
      }
      return true;
    });
    
    // บันทึกสถิติ pool
    console.log(`เซสชัน pool: ${this.available.length} พร้อมใช้, ${this.inUse.size} กำลังใช้งาน, ${this.waiting.length} กำลังรอ`);
  }
  
  getRandomUserAgent() {
    const agents = [
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
    ];
    return agents[Math.floor(Math.random() * agents.length)];
  }
  
  getStats() {
    return {
      available: this.available.length,
      inUse: this.inUse.size,
      waiting: this.waiting.length,
      maxSessions: this.maxSessions
    };
  }
}

module.exports = BrowserSessionPool;

┌─────────────────────────────────────────────────────────────────────────┐
│                    เช็คลิสต์แนวทางปฏิบัติที่ดีที่สุด                    │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  สถาปัตยกรรม:                                                           │
│  □ ใช้ session pools เพื่อจัดการอินสแตนซ์เบราว์เซอร์อย่างมีประสิทธิภาพ   │
│  □ ใช้ circuit breakers สำหรับการเรียกใช้บริการภายนอก                   │
│  □ ออกแบบให้สามารถปรับขนาดแนวนอนด้วย workers แบบไม่มีสถานะ               │
│  □ แยกความกังวล: การวางแผน การดำเนินการ และการดึงข้อมูล                 │
│                                                                         │
│  ความปลอดภัย:                                                           │
│  □ เก็บข้อมูลรับรองในตัวแปรสภาพแวดล้อม ไม่ใช่ในโค้ด                      │
│  □ ใช้ rate limiting เพื่อหลีกเลี่ยงการถูกบล็อก                          │
│  □ ใช้มาตรการป้องกันการตรวจจับเพื่อลดการตรวจจับ                          │
│  □ หมุนเวียน user agents และที่อยู่ IP                                   │
│                                                                         │
│  ความน่าเชื่อถือ:                                                       │
│  □ ใช้ retry logic ที่ครอบคลุมพร้อม exponential backoff                  │
│  □ ใช้ dead letter queues สำหรับงานที่ล้มเหลว                             │
│  □ รักษา audit trails ที่สมบูรณ์เพื่อการปฏิบัติตามกฎระเบียบ              │
│  □ ตั้งค่าขีดจำกัดทรัพยากรเพื่อป้องกันกระบวนการที่ควบคุมไม่ได้         │
│                                                                         │
│  ประสิทธิภาพ:                                                           │
│  □ แคชสถานะเซสชันเมื่อเป็นไปได้                                          │
│  □ ใช้โหมด headless สำหรับการผลิต                                       │
│  □ ใช้ connection pooling สำหรับฐานข้อมูล                               │
│  □ วิเคราะห์และปรับปรุง selectors ที่ช้า                                │
│                                                                         │
│  การตรวจสอบ:                                                            │
│  □ ติดตามอัตราความสำเร็จ ความล่าช้า และรูปแบบข้อผิดพลาด                │
│  □ ตั้งค่าการแจ้งเตือนสำหรับกิจกรรมที่ผิดปกติ                           │
│  □ รวบรวม screenshots ของความล้มเหลวสำหรับการดีบัก                      │
│  □ ตรวจสอบการใช้ทรัพยากร (CPU, หน่วยความจำ, ดิสก์)                      │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘