สรุปโดยย่อ: Claude Code hooks คือสคริปต์อัตโนมัติที่ทำงานในจุดต่างๆ ของวงจรชีวิตของการเขียนโค้ด AI ทำให้ นักพัฒนาสามารถเรียกใช้คำสั่งที่กำหนดเอง ตรวจสอบการดำเนินการ จัดรูปแบบโค้ด ส่งการแจ้งเตือน และบังคับใช้กฎของโปรเจกต์ Hooks เหล่านี้ผสานรวมกับขั้นตอนการทำงานของ Claude ผ่านเหตุการณ์ต่างๆ เช่น SessionStart, PreToolUse และ PostToolUse รองรับรูปแบบการทำงานแบบอิงคำสั่ง แบบอิง HTTP และแบบอิงพรอมต์ พร้อมการตั้งค่าการหมดเวลาและพฤติกรรมรหัสการออกที่กำหนดค่าได้
ระบบ hook ของ Claude Code เปลี่ยนผู้ช่วยเขียนโค้ด AI จากเครื่องมือที่มีประโยชน์ ให้กลายเป็นสภาพแวดล้อมการพัฒนาที่ทำงานอัตโนมัติได้อย่างเต็มที่ นักพัฒนาส่วนใหญ่ไม่ทราบถึงระดับการควบคุมที่มีอยู่ผ่าน hooks
แต่ประเด็นสำคัญคือ hooks ไม่ได้มีไว้เพียงแค่การรันสคริปต์หลังจากการแก้ไขไฟล์เท่านั้น พวกมันมีจุดสกัดกั้นตลอดกระบวนการตัดสินใจทั้งหมดของ Claude ก่อนที่จะเรียกใช้คำสั่ง หลังจากที่การเรียกใช้เครื่องมือล้มเหลว เมื่อต้องการสิทธิ์ แม้กระทั่งก่อนประมวลผลพรอมต์ของผู้ใช้
คู่มือฉบับนี้ครอบคลุมทุกสิ่งที่เอกสารอย่างเป็นทางการมีให้ พร้อมด้วยรูปแบบการใช้งานจริงที่การสนทนาในชุมชนเปิดเผยว่าสามารถใช้งานได้จริงในสภาพแวดล้อมการผลิต
Claude Code Hooks ทำงานจริงอย่างไร
ตามเอกสารอย่างเป็นทางการของ Claude Code hooks คือคำสั่งเชลล์แบบที่ผู้ใช้กำหนด จุดปลาย HTTP หรือการแทรกพรอมต์ ที่ทำงานในจุดที่เฉพาะเจาะจงของวงจรชีวิต Claude Code พวกมันรับข้อมูล JSON ที่มีโครงสร้างผ่าน stdin และควบคุมขั้นตอนการทำงานผ่านรหัสการออกหรือการตอบสนอง HTTP
ระบบอัตโนมัติมีความลึกซึ้งกว่าคู่มือส่วนใหญ่ที่แนะนำ Hooks สามารถบล็อกการดำเนินการเครื่องมือทั้งหมด แทรกบริบทเพิ่มเติมในการให้เหตุผลของ Claude กระตุ้นบริการภายนอก และบังคับใช้กฎการตรวจสอบที่ Claude ต้องปฏิบัติตาม
มี hooks ประเภทหลักสามประเภท:
- Command hooks: สคริปต์เชลล์ที่สื่อสารผ่าน stdout, stderr และรหัสการออก
- HTTP hooks: จุดปลายระยะไกลที่รับคำขอ POST และส่งคืนการตอบสนอง JSON
- Prompt hooks: คำแนะนำแบบไดนามิกที่แทรกเข้าไปในบริบทของ Claude ในเหตุการณ์เฉพาะ
แต่ละประเภทให้บริการรูปแบบอัตโนมัติที่แตกต่างกัน Command hooks จัดการการตรวจสอบและจัดรูปแบบภายใน เครื่องมือ HTTP ผสานรวมกับบริการภายนอกและฐานข้อมูล Prompt hooks ปรับเปลี่ยนพฤติกรรมของ Claude โดยไม่ต้องใช้กระบวนการภายนอก
วงจรชีวิต Hook และระบบเหตุการณ์
เอกสารอย่างเป็นทางการกำหนดเหตุการณ์ hook หลายอย่าง (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification และอื่นๆ) ที่ทำงานในช่วงการไหลของการดำเนินการของ Claude Code การทำความเข้าใจว่าแต่ละเหตุการณ์ทำงานเมื่อใดจะเป็นตัวกำหนดว่าระบบอัตโนมัติใดที่เป็นไปได้
| เหตุการณ์ | ทำงานเมื่อใด | สามารถบล็อก |
|---|---|---|
| SessionStart | เมื่อเซสชันเริ่มขึ้นหรือกลับมาทำงานต่อ | ไม่ |
| UserPromptSubmit | เมื่อคุณส่งพรอมต์ ก่อนที่ Claude จะประมวลผล | ใช่ |
| PreToolUse | ก่อนที่การเรียกใช้เครื่องมือจะทำงาน | ใช่ |
| PermissionRequest | เมื่อกล่องโต้ตอบการขอสิทธิ์ปรากฏขึ้น | ใช่ |
| PostToolUse | หลังจากการเรียกใช้เครื่องมือสำเร็จ | ไม่ |
| PostToolUseFailure | หลังจากการเรียกใช้เครื่องมือล้มเหลว | ไม่ |
| Notification | เมื่อ Claude Code ส่งการแจ้งเตือน | ไม่ |
| SubmitMessage | เมื่อ Claude ส่งข้อความถึงผู้ใช้ | ไม่ |
| ContextCompaction | เมื่อหน้าต่างบริบทใกล้ถึงขีดจำกัด | ไม่ |
ความสามารถในการบล็อกเป็นสิ่งสำคัญที่สุด PreToolUse hooks สามารถป้องกันการดำเนินการที่อันตรายก่อนที่จะทำงาน รหัสการออก 1 บล็อกการดำเนินการ รหัสการออก 0 อนุญาต รหัสการออก 2 กระตุ้นให้ Claude พิจารณาใหม่
แต่เดี๋ยวก่อน! PostToolUse hooks ไม่สามารถย้อนกลับการดำเนินการได้ เนื่องจากเครื่องมือได้ทำงานไปแล้ว ข้อจำกัดนี้กำหนดโครงสร้างตรรกะการตรวจสอบ การตรวจสอบที่สำคัญควรอยู่ใน PreToolUse การทำความสะอาดและการจัดรูปแบบควรอยู่ใน PostToolUse
เลือกดู AI Tool Perks ขณะตั้งค่า Claude Code
หากคุณกำลังทำงานกับ Claude Code hooks คุณอาจกำลังเลือกใช้เครื่องมือ AI อื่นๆ รอบๆ ขั้นตอนการทำงานของคุณ Get AI Perks รวบรวมเครดิตสตาร์ทอัพและส่วนลดซอฟต์แวร์สำหรับเครื่องมือ AI และคลาวด์ในที่เดียว แพลตฟอร์มนี้มีข้อเสนอมากกว่า 200 รายการ พร้อมเงื่อนไข perks และคำแนะนำในการรับสำหรับแต่ละรายการ
กำลังมองหา Claude หรือ AI Tool Perks อื่นๆ อยู่ใช่ไหม
ตรวจสอบ Get AI Perks เพื่อ:
- เรียกดูข้อเสนอของ Claude และเครื่องมือ AI อื่นๆ
- เปรียบเทียบเงื่อนไข perks ก่อนสมัคร
- ค้นหาส่วนลดสตาร์ทอัพทั่วทั้งเครื่องมือของคุณ
👉 เยี่ยมชม Get AI Perks เพื่อสำรวจ AI software perks ปัจจุบัน
การกำหนดค่าและโครงสร้างไฟล์
Hooks ถูกกำหนดในไฟล์ .claude/settings.json ภายในโปรเจกต์ สคีมาการกำหนดค่ารองรับ global hooks และ matchers เฉพาะเครื่องมือที่กรองเมื่อ hooks ทำงาน
โครงสร้าง command hook พื้นฐาน:
| { “hooks”: [ { “event”: “PostToolUse”, “command”: “prettier –write”, “args”: [“${file}”] } ] } |
ตัวแปร ${file} จะขยายไปยังเส้นทางไฟล์จริงจากอินพุตของเครื่องมือ ตามเอกสารอย่างเป็นทางการ hooks รองรับการขยายตัวแปรเหล่านี้ในฟิลด์ command และ args
ลำดับชั้นตำแหน่ง Hook
Claude Code ตรวจสอบตำแหน่งหลายแห่งสำหรับคำจำกัดความ hook โดยมีลำดับความสำคัญที่ชัดเจน:
- ระดับโปรเจกต์: .claude/settings.json ในพื้นที่ทำงานปัจจุบัน
- ระดับผู้ใช้: ~/.claude/settings.json สำหรับเซสชันทั้งหมด
- ให้โดยปลั๊กอิน: Hooks ที่มาพร้อมกับปลั๊กอินที่ติดตั้ง
Project hooks จะเขียนทับ user hooks สำหรับเหตุการณ์เดียวกัน สิ่งนี้ช่วยให้มีกฎการจัดรูปแบบเฉพาะโปรเจกต์ในขณะที่ยังคงรักษาตัวจัดการการแจ้งเตือนทั่วโลก
รูปแบบ Matcher สำหรับการดำเนินการแบบเลือก
ระบบ Matcher จะกรอง hooks ไปยังเครื่องมือหรือเงื่อนไขเฉพาะ หากไม่มี matchers hooks จะทำงานทุกครั้งที่เกิดเหตุการณ์ของตน
| { “hooks”: [ { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “src/**/*.ts” }, “command”: “./scripts/validate-typescript.sh” } ] } |
ฟิลด์ pathPattern รับไวยากรณ์ glob ฟิลด์ toolName ตรงกับเครื่องมือในตัวของ Claude เช่น edit_file, execute_command, read_file และ create_directory
การสนทนาในชุมชนเปิดเผยว่าการผสมผสาน matcher ทำงานด้วยตรรกะ AND ตัว matchers ที่ระบุทั้งหมดต้องตรงกันเพื่อให้ hook ทำงาน
Command Hooks: การผสานรวมสคริปต์เชลล์
Command hooks เรียกใช้คำสั่งเชลล์หรือสคริปต์ด้วยอินพุต JSON ที่มีโครงสร้าง พวกมันเป็นประเภท hook ที่พบได้บ่อยที่สุดสำหรับระบบอัตโนมัติภายใน
เอกสารอย่างเป็นทางการระบุว่า command hooks รับ JSON ผ่าน stdin ด้วยโครงสร้างนี้:
| { “event”: “PreToolUse”, “toolName”: “edit_file”, “toolInput”: { “path”: “src/app.ts”, “content”: “…” }, “sessionId”: “abc123”, “turnId”: “turn-456” }Scripts แยกวิเคราะห์อินพุตนี้เพื่อทำการตัดสินใจ Hook การตรวจสอบ Python อาจมีลักษณะดังนี้:#!/usr/bin/env python3 import sys import json input_data = json.load(sys.stdin) tool_input = input_data.get(‘toolInput’, {}) file_path = tool_input.get(‘path’, ”) if file_path.startswith(‘protected/’): print(“Cannot edit protected files”, file=sys.stderr) sys.exit(1) sys.exit(0) |
รหัสการออก 0 อนุญาตการดำเนินการ รหัสการออก 1 บล็อกการดำเนินการและแสดงข้อความ stderr ให้ Claude เห็น รหัสการออก 2 ทริกเกอร์พฤติกรรมพิเศษขึ้นอยู่กับเหตุการณ์
พฤติกรรมของรหัสการออก 2
ตามเอกสารอ้างอิง hook อย่างเป็นทางการ รหัสการออก 2 มีความหมายเฉพาะเหตุการณ์ (PreToolUse: บล็อกและกระตุ้นให้พิจารณาใหม่; UserPromptSubmit: ให้บริบทโดยไม่บล็อก; PermissionRequest: บล็อกการอนุญาต):
- PreToolUse: บล็อกเครื่องมือและกระตุ้นให้ Claude พิจารณาใหม่โดยใช้ข้อความ stderr เป็นบริบท
- UserPromptSubmit: ให้ผลลัพธ์ stderr เป็นบริบทเพิ่มเติมโดยไม่บล็อก
- PermissionRequest: บล็อกการให้สิทธิ์
สิ่งนี้สร้างจุดกึ่งกลางระหว่างการบล็อกอย่างสมบูรณ์และการอนุญาต Claude ได้รับข้อเสนอแนะเกี่ยวกับเหตุผลที่การดำเนินการอาจมีปัญหาและสามารถปรับวิธีการได้
Asynchronous Command Hooks
แฟล็ก async: true จะรัน hooks ในพื้นหลังโดยไม่บล็อกขั้นตอนการทำงานของ Claude สิ่งนี้มีความสำคัญสำหรับ การดำเนินการที่ช้า เช่น การแจ้งเตือนการปรับใช้ หรือการรวบรวมเมตริก
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “execute_command” }, “command”: “./scripts/log-to-analytics.sh”, “async”: true, “timeout”: 30 } |
เมื่อ async hook ทำงาน Claude Code จะเริ่มกระบวนการและดำเนินการต่อทันที ฟิลด์ timeout จะตั้งค่าเวลาดำเนินการสูงสุดเป็นวินาที หากไม่ได้ระบุ async hooks จะใช้ค่าเริ่มต้น 10 นาที
พูดตามตรง: async hooks ไม่สามารถบล็อกการดำเนินการได้ เนื่องจากจะทำงานหลังจากที่ Claude ดำเนินการต่อ พวกมันทำงานสำหรับการบันทึก การแจ้งเตือน และการล้างข้อมูล ไม่ใช่สำหรับการตรวจสอบ
HTTP Hooks: การผสานรวมบริการภายนอก
HTTP hooks ส่ง payload JSON ไปยังจุดปลายระยะไกลและแยกวิเคราะห์การตอบสนองเพื่อควบคุมการตัดสินใจ สิ่งนี้ช่วยให้สามารถผสานรวมกับบริการตรวจสอบ ฐานข้อมูล และเครื่องมือบุคคลที่สาม
การกำหนดค่า HTTP hook พื้นฐาน:
| { “event”: “PreToolUse”, “url”: “api.example.com/validate”, “headers”: { “Authorization”: “Bearer ${API_TOKEN}” }, “timeout”: 5 } |
โครงสร้าง payload ตรงกับอินพุตของ command hook แต่จะมาถึงเป็นส่วนเนื้อหา POST ของ HTTP การตอบสนองจะกำหนดการดำเนินการต่อไปของ Claude
การจัดการการตอบสนอง HTTP
ตามเอกสารอย่างเป็นทางการ HTTP hooks จะตีความการตอบสนองตามรหัสสถานะและเนื้อหาของส่วนเนื้อหา:
| รหัสสถานะ | ผลกระทบ | แหล่งที่มาของข้อความ |
|---|---|---|
| 200 | อนุญาตการดำเนินการ | ส่วนเนื้อหาของการตอบสนอง (ไม่บังคับ) |
| 400 | บล็อกการดำเนินการ | ส่วนเนื้อหาของการตอบสนองที่แสดงให้ Claude เห็น |
| 500 | ข้อผิดพลาด Hook, อนุญาตการดำเนินการ | ถูกบันทึก แต่ไม่ได้แสดงให้ Claude เห็น |
| อื่นๆ | อนุญาตการดำเนินการ | ความล้มเหลวของ Hook ไม่ได้บล็อกขั้นตอนการทำงาน |
ส่วนเนื้อหาของการตอบสนองสามารถมีฟิลด์ข้อความที่ Claude มองเห็นเป็นบริบท สิ่งนี้ช่วยให้บริการตรวจสอบสามารถอธิบายได้ว่าเหตุใดจึงมีการบล็อกการดำเนินการ
การแทรกตัวแปรสภาพแวดล้อม
HTTP hooks รองรับไวยากรณ์ ${VAR} ใน url, headers และฟิลด์สตริงอื่นๆ ตัวแปรจะขยายจากสภาพแวดล้อมที่ Claude Code ทำงาน
ตามเอกสาร MCP อย่างเป็นทางการ การขยายตัวแปรสภาพแวดล้อมรวมถึงไวยากรณ์ fallback เริ่มต้น: ${VAR:-default} จะขยายเป็น VAR หากตั้งค่าไว้ มิฉะนั้นจะใช้ค่าเริ่มต้น
ข้อจำกัดด้านความปลอดภัย: ตาม GitHub issue #28044, HTTP hooks สามารถเข้าถึงตัวแปรสภาพแวดล้อมที่ระบุไว้อย่างชัดเจนในฟิลด์การกำหนดค่า allowedEnvVars เท่านั้น สิ่งนี้ป้องกันการเปิดเผยข้อมูลรับรองโดยไม่ตั้งใจ
Prompt Hooks: การแทรกบริบท
Prompt hooks แทรกคำแนะนำแบบไดนามิกเข้าไปในบริบทของ Claude ในเหตุการณ์เฉพาะ พวกมันปรับเปลี่ยนพฤติกรรมโดยไม่ต้องใช้กระบวนการภายนอกหรือการเรียก API
| { “event”: “SessionStart”, “prompt”: “คุณกำลังทำงานกับโปรเจกต์ TypeScript เสมอ ใช้ strict null checks และชอบ async/await มากกว่า promises” } |
ข้อความที่แทรกจะกลายเป็นส่วนหนึ่งของคำแนะนำระบบของ Claude สำหรับเซสชันนั้น Prompt hooks ยังสามารถใช้ตัวแปรเทมเพลตที่ขยายตามข้อมูลเหตุการณ์
การสร้างพรอมต์แบบไดนามิก
ตามเอกสารอย่างเป็นทางการ prompt hooks รองรับฟิลด์ command ที่สร้างพรอมต์แบบไดนามิก:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “./scripts/generate-context-summary.sh” } |
Command จะรับอินพุต JSON มาตรฐานผ่าน stdin และส่งออกข้อความพรอมต์ไปยัง stdout สิ่งนี้ช่วยให้สามารถสร้างคำแนะนำที่คำนึงถึงบริบทตามสถานะของโปรเจกต์
Agent-Based Hooks
Agent hooks ระบุ subagent ที่จัดการเหตุการณ์แทนการแทรกพรอมต์โดยตรง Subagent จะได้รับบริบทเกี่ยวกับเหตุการณ์และสามารถทำการให้เหตุผลแบบหลายขั้นตอนได้
| { “event”: “PostToolUseFailure”, “agent”: “debugger”, “agentPrompt”: “การเรียกใช้เครื่องมือล้มเหลว วิเคราะห์ข้อผิดพลาดและเสนอแนะวิธีการแก้ไข” } |
Subagent ที่มีชื่อจะต้องถูกกำหนดค่าในไฟล์กำหนดค่าโปรเจกต์ Agent hooks ช่วยให้สามารถใช้ตรรกะการตัดสินใจที่ซับซ้อนซึ่งการแทรกพรอมต์แบบง่ายไม่สามารถให้ได้
รูปแบบการใช้งานจริง
การสนทนาในชุมชนและตัวอย่างอย่างเป็นทางการเปิดเผยรูปแบบอัตโนมัติเฉพาะที่ทำงานได้อย่างน่าเชื่อถือในสภาพแวดล้อมการผลิต
จัดรูปแบบโค้ดอัตโนมัติหลังจากการแก้ไข
รูปแบบที่พบมากที่สุดคือการจัดรูปแบบโค้ดอัตโนมัติหลังจาก Claude แก้ไขไฟล์:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/*.{js,ts,jsx,tsx}” }, “command”: “prettier”, “args”: [“–write”, “${toolInput.path}”] } |
ตัวแปร ${toolInput.path} จะขยายไปยังเส้นทางไฟล์ที่แก้ไข PostToolUse ช่วยให้มั่นใจได้ว่าการจัดรูปแบบจะเกิดขึ้นหลังจากการแก้ไขสำเร็จ แต่ไม่บล็อกขั้นตอนการทำงานของ Claude
บล็อกการแก้ไขไฟล์ที่ได้รับการคุ้มครอง
PreToolUse hooks บังคับใช้กฎการคุ้มครองไฟล์:
| { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file” }, “command”: “./scripts/check-protected.sh” } |
สคริปต์จะตรวจสอบเส้นทางเป้าหมายกับรูปแบบที่ได้รับการคุ้มครอง และออกด้วยรหัส 1 เพื่อบล็อกการแก้ไขที่ถูกห้าม
รับการแจ้งเตือนเมื่อ Claude ต้องการข้อมูล
ตามคู่มือขั้นตอนการทำงานอย่างเป็นทางการ Notification hooks สามารถกระตุ้นการแจ้งเตือนบนเดสก์ท็อปหรือส่งข้อความไปยังบริการภายนอก:
| { “event”: “Notification”, “command”: “osascript”, “args”: [“-e”, “display notification \”${message}\” with title \”Claude Code\””] } |
สิ่งนี้จะทำงานทุกครั้งที่ Claude Code ส่งการแจ้งเตือน รวมถึงเมื่อรออินพุตจากผู้ใช้หรือหลังจากการทำงานเสร็จสิ้น
แทรกบริบทอีกครั้งหลังจากการบีบอัด
ContextCompaction hooks จะคืนค่าบริบทที่สำคัญเมื่อหน้าต่างสนทนาเต็ม:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “cat .claude/critical-context.md” } |
ผลลัพธ์ของคำสั่งจะถูกแทรกลงในบริบทของ Claude อีกครั้งหลังจากการบีบอัดลบข้อความเก่าออก สิ่งนี้ป้องกันการสูญเสียคำแนะนำเฉพาะโปรเจกต์ที่สำคัญ
ตรวจสอบการเปลี่ยนแปลงการกำหนดค่า
ติดตามเมื่อ Claude แก้ไขไฟล์การกำหนดค่า:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/{package.json,.env,*.config.*}” }, “command”: “git”, “args”: [“add”, “${toolInput.path}”], “async”: true } |
การดำเนินการแบบอะซิงโครนัสป้องกันการบล็อก Claude ในขณะที่การดำเนินการ git เสร็จสมบูรณ์ สิ่งนี้สร้างบันทึกการตรวจสอบการเปลี่ยนแปลงการกำหนดค่าโดยไม่ต้องมีการจัดเตรียมด้วยตนเอง
เอาต์พุต JSON และการควบคุมการตัดสินใจ
Command hooks สามารถส่งออก JSON ที่มีโครงสร้างเพื่อให้ข้อเสนอแนะโดยละเอียดนอกเหนือจากรหัสการออกธรรมดา ตามข้อมูลอ้างอิงอย่างเป็นทางการ เอาต์พุต JSON ช่วยให้สามารถตอบสนองแบบหลายฟิลด์ที่ Claude ตีความสำหรับการตัดสินใจ
| { “allowed”: false, “message”: “ไฟล์นี้ได้รับการคุ้มครองตามนโยบายของทีม”, “suggestion”: “สร้างไฟล์ใหม่ใน src/features/ แทน” } |
ฟิลด์ allowed ควบคุมว่าการดำเนินการจะดำเนินการต่อไปหรือไม่ ข้อความจะปรากฏแก่ Claude เป็นบริบท ฟิลด์ suggestion ให้แนวทางอื่น
เพื่อให้ hooks ส่งออก JSON พวกมันต้อง:
- เขียน JSON ที่ถูกต้องไปยัง stdout
- ออกด้วยรหัส 0 (สำหรับอนุญาต) หรือ 1 (สำหรับบล็อก)
- รวมฟิลด์ boolean allowed อย่างน้อย
Claude Code แยกวิเคราะห์ JSON และใช้เพื่อปรับปรุงวงจรข้อเสนอแนะ รหัสการออกยังคงกำหนดการตัดสินใจหลัก แต่ JSON ให้บริบทที่เข้มข้นกว่า
เอกสารอ้างอิงฟิลด์อินพุต Hook
Hooks ทั้งหมดจะได้รับออบเจกต์ JSON ผ่าน stdin พร้อมฟิลด์ทั่วไปและข้อมูลเฉพาะเหตุการณ์ การทำความเข้าใจสคีมาทั้งหมดช่วยให้สามารถใช้ตรรกะ hook ที่ซับซ้อนยิ่งขึ้น
ฟิลด์อินพุตทั่วไป
Hooks ทุกตัวจะได้รับฟิลด์พื้นฐานเหล่านี้:
- event: ชื่อเหตุการณ์ hook (เช่น “PreToolUse”)
- sessionId: ตัวระบุที่ไม่ซ้ำกันสำหรับเซสชัน Claude ปัจจุบัน
- turnId: ตัวระบุสำหรับเทิร์นการสนทนาปัจจุบัน
- timestamp: การประทับเวลา ISO 8601 เมื่อเหตุการณ์ทำงาน
ฟิลด์เหตุการณ์เครื่องมือ
เหตุการณ์ PreToolUse, PostToolUse และ PostToolUseFailure จะรวมถึง:
- toolName: ชื่อของเครื่องมือที่กำลังเรียกใช้ (edit_file, execute_command, etc.)
- toolInput: ออบเจกต์ที่รวมพารามิเตอร์อินพุตของเครื่องมือ
- toolResponse: ข้อมูลผลลัพธ์ของเครื่องมือ (เฉพาะ PostToolUse)
- error: รายละเอียดข้อผิดพลาดรวมถึงข้อความและรหัส (เฉพาะ PostToolUseFailure)
โครงสร้าง toolInput แตกต่างกันไปตามเครื่องมือ สำหรับ edit_file จะมี path และ content สำหรับ execute_command จะมี command และ args
ฟิลด์เหตุการณ์การอนุญาต
เหตุการณ์ PermissionRequest จะรวมถึง:
- permissionType: ประเภทของการอนุญาตที่ร้องขอ (file_write, command_execute, etc.)
- requestedAction: การดำเนินการเฉพาะที่ต้องการการอนุญาต
- resourcePath: เส้นทางไฟล์หรือตัวระบุทรัพยากรที่ได้รับผลกระทบ
MCP Tool Hooks
ตามเอกสารอ้างอิง hook อย่างเป็นทางการ hooks สามารถจับคู่กับเครื่องมือ Model Context Protocol (MCP) ได้โดยใช้ฟิลด์ matcher mcpTool สิ่งนี้ช่วยให้ hook ทำงานได้เมื่อ Claude ใช้เครื่องมือภายนอกที่จัดเตรียมโดยเซิร์ฟเวอร์ MCP
| { “event”: “PreToolUse”, “matcher”: { “mcpTool”: “database/query” }, “command”: “./scripts/validate-sql.sh” } |
ค่า mcpTool จะตรงกับชื่อเครื่องมือในรูปแบบ server-name/tool-name สิ่งนี้ช่วยให้มีตรรกะการตรวจสอบสำหรับการสอบถามฐานข้อมูล การเรียก API หรือการดำเนินการภายนอกอื่นๆ
คำขอคุณสมบัติบน GitHub บ่งชี้ถึงความสนใจที่เพิ่มขึ้นในการผสานรวม MCP ที่ลึกซึ้งยิ่งขึ้น รวมถึง hooks ที่สามารถตรวจสอบการแจ้งเตือนของเซิร์ฟเวอร์ MCP และตอบสนองต่อเหตุการณ์ภายนอก
ข้อควรพิจารณาด้านความปลอดภัย
Hooks ทำงานด้วยสิทธิ์เดียวกับ Claude Code เอง สิ่งนี้สร้างผลกระทบด้านความปลอดภัยสำหรับสภาพแวดล้อมแบบหลายผู้ใช้และการกำหนดค่าที่แชร์
Sandbox การดำเนินการคำสั่ง
ตาม GitHub issue #28044, HTTP hooks จะถูกส่งผ่าน sandbox proxy ที่จำกัดการเข้าถึงเครือข่ายและกรองตัวแปรสภาพแวดล้อม Command hooks ไม่มีข้อจำกัดดังกล่าว—พวกมันทำงานด้วยสิทธิ์เชลล์เต็มรูปแบบ
เอกสารแนะนำแนวทางปฏิบัติเหล่านี้:
- ห้ามเก็บข้อมูลรับรองในคำสั่ง hook
- ใช้ตัวแปรสภาพแวดล้อมสำหรับข้อมูลที่ละเอียดอ่อน
- ตรวจสอบอินพุตทั้งหมดจากการขยาย ${…}
- ใช้ขีดจำกัดเวลาสำหรับการบริการภายนอก
- ใช้ async hooks สำหรับการดำเนินการที่ไม่สำคัญเพื่อป้องกันการบล็อกเมื่อเกิดข้อผิดพลาด
การแยกการดำเนินการ Hook
User-level hooks ใน ~/.claude/settings.json จะนำไปใช้กับทุกโปรเจกต์ สิ่งนี้สร้างความเสี่ยงเมื่อทำงานกับขอบเขตความน่าเชื่อถือที่แตกต่างกัน Project-level hooks จะเขียนทับ user hooks แต่ไม่สามารถปิดใช้งานได้อย่างสมบูรณ์
เมนู /hooks ใน Claude Code จะแสดง hooks ที่ใช้งานอยู่ทั้งหมดสำหรับเซสชันปัจจุบัน การตรวจสอบรายการนี้ก่อนทำงานกับโปรเจกต์ที่ละเอียดอ่อนจะช่วยระบุข้อกังวลด้านความปลอดภัยที่อาจเกิดขึ้น
การดีบักและการแก้ไขปัญหา
ความล้มเหลวของ Hook ไม่ได้แสดงให้เห็นอย่างชัดเจนเสมอไปในการสนทนาของ Claude เอกสารอย่างเป็นทางการมีแนวทางการดีบักหลายวิธี
บันทึกการดำเนินการ Hook
Claude Code บันทึกการดำเนินการ hook ไปยังเอาต์พุตการดีบักเซสชัน ตามคู่มือการแก้ไขปัญหา การเปิดใช้งานการบันทึกการดีบักจะเปิดเผย:
- Hooks ใดที่ตรงกันสำหรับแต่ละเหตุการณ์
- อินพุต JSON ที่ส่งไปยังแต่ละ hook
- เอาต์พุต stdout และ stderr จากกระบวนการ hook
- รหัสการออกและเวลาดำเนินการ
- รหัสสถานะและส่วนเนื้อหาของการตอบสนองสำหรับ HTTP hooks
เปิดใช้งานการบันทึกการดีบักโดยตั้งค่า CLAUDE_DEBUG=1 ในสภาพแวดล้อมก่อนเริ่ม Claude Code
การทดสอบ Hooks แบบแยก
Command hooks สามารถทดสอบนอก Claude Code ได้โดยการสร้างอินพุต JSON ด้วยตนเอง:
| echo ‘{“event”:”PreToolUse”,”toolName”:”edit_file”,”toolInput”:{“path”:”test.txt”}}’ | ./scripts/my-hook.sh |
สิ่งนี้จะตรวจสอบตรรกะของ hook โดยไม่ต้องเรียกใช้การดำเนินการของ Claude จริงๆ รหัสการออกและเอาต์พุต stdout/stderr ควรตรงกับพฤติกรรมที่คาดหวัง
ความล้มเหลวของ Hook ทั่วไป
การสนทนาในชุมชนระบุปัญหาที่พบบ่อยเหล่านี้:
- ข้อผิดพลาดหมดเวลา: ค่าเริ่มต้น 10 นาทีสั้นเกินไปสำหรับ การดำเนินการที่ช้า—เพิ่มด้วยฟิลด์ timeout
- ความล้มเหลวในการขยายพาธ: ตัวแปรเช่น ${file} ไม่ได้ถูกกำหนดสำหรับ เหตุการณ์ที่ไม่มีบริบทไฟล์
- ข้อผิดพลาดด้านสิทธิ์: สคริปต์ Hook ขาดสิทธิ์การดำเนินการ—รัน chmod +x script.sh
- ข้อผิดพลาดในการแยกวิเคราะห์ JSON: เอาต์พุต JSON ที่ผิดรูปแบบจาก hooks—ตรวจสอบด้วย jq ก่อนส่งคืน
- ตัวแปรสภาพแวดล้อมไม่พร้อมใช้งาน: ตัวแปรไม่ได้ถูกส่งไปยังกระบวนการ hook—ตรวจสอบ สภาพแวดล้อมของ Claude Code
ผลกระทบต่อประสิทธิภาพของ Hook
Synchronous hooks จะบล็อกขั้นตอนการทำงานของ Claude จนกว่าจะเสร็จสมบูรณ์ ค่าเริ่มต้น 10 นาทีป้องกันการค้างเป็นเวลานาน แต่แม้แต่ความล่าช้าสั้นๆ ก็สะสมจากการดำเนินการหลายรายการ
ผู้ปฏิบัติงานรายงานว่า hooks การตรวจสอบอย่างง่ายมีผลกระทบต่อประสิทธิภาพน้อย Hooks การจัดรูปแบบไฟล์ทำให้เกิดผลกระทบต่อประสิทธิภาพที่สังเกตได้แต่ยอมรับได้ การเรียก API ภายนอกอาจสร้างความติดขัดในขั้นตอนการทำงาน การดำเนินการคำนวณหนักๆ ได้รับประโยชน์จากการดำเนินการแบบอะซิงโครนัส
การรวมกลุ่ม Hook
Hooks หลายรายการสามารถจับคู่เหตุการณ์เดียวกันได้ ตามเอกสารอ้างอิง hooks จะทำงานตามลำดับในลำดับการกำหนดค่า หาก hook ใดบล็อกการดำเนินการ hooks ที่เหลือจะไม่ทำงาน
สิ่งนี้สำคัญต่อประสิทธิภาพ Synchronous hooks ห้าตัวที่ 200ms ต่อตัว จะเพิ่มหนึ่งวินาทีต่อเหตุการณ์ การรวมการตรวจสอบที่เกี่ยวข้องหลายรายการไว้ใน hook เดียวช่วยลดค่าใช้จ่าย
รูปแบบขั้นสูง
นอกเหนือจากระบบอัตโนมัติพื้นฐานแล้ว hooks ยังช่วยให้สามารถปรับแต่งขั้นตอนการทำงานที่ซับซ้อนได้
Stateful Hook Chains
Hooks สามารถรักษาสถานะระหว่างการดำเนินการได้โดยใช้ไฟล์หรือฐานข้อมูล PostToolUse hook อาจบันทึกการดำเนินการที่สำเร็จ ซึ่ง PreToolUse hook จะตรวจสอบในภายหลัง:
| #!/bin/bash # บันทึกการแก้ไขที่สำเร็จ echo “${toolInput.path}” >> .claude/edit-history.txt |
Hook PreToolUse ที่มาพร้อมกันสามารถตรวจสอบประวัติ นี้เพื่อป้องกันการดำเนินการซ้ำซ้อนหรือบังคับใช้ข้อจำกัดลำดับ
การเปิดใช้งาน Hook แบบมีเงื่อนไข
ตัวแปรสภาพแวดล้อมจะควบคุมพฤติกรรมของ hook ในขณะรันไทม์ การตั้งค่า CLAUDE_SKIP_HOOKS=1 จะปิดใช้งาน hooks สำหรับสถานการณ์ฉุกเฉิน
Hooks เองสามารถตรวจสอบแฟล็กสภาพแวดล้อมได้:
| #!/bin/bash if [ “$STRICT_MODE” = “1” ]; then # ใช้การตรวจสอบที่เข้มงวด exit 1 fi exit 0 |
สิ่งนี้ช่วยให้พฤติกรรมโหมดการพัฒนาเทียบกับโหมดการผลิต โดยไม่ต้องเปลี่ยนแปลงการกำหนดค่า
การตรวจสอบแบบหลายขั้นตอน
PreToolUse hooks สามารถใช้การตรวจสอบหลายระดับ โดยที่รหัสการออก 2 จะอนุญาตให้ Claude ดำเนินการต่อไปพร้อมคำเตือน:
- ความล้มเหลวรุนแรง (รหัสออก 1): บล็อกการดำเนินการที่อันตราย
- คำเตือนอ่อน (รหัสออก 2): แจ้งเตือน Claude ให้พิจารณาใหม่
- ผ่านพร้อมบริบท (รหัสออก 0 + JSON): ให้ข้อมูลเพิ่มเติม
สิ่งนี้สร้างสเปกตรัมการตรวจสอบที่ละเอียดอ่อนกว่าการอนุญาต/ปฏิเสธแบบทวิภาค
การผสานรวมกับ CI/CD
ตามเอกสารการผสานรวมแพลตฟอร์มอย่างเป็นทางการ Claude Code จะทำงานในสภาพแวดล้อม CI/CD สำหรับการตรวจสอบโค้ดและการจัดการปัญหาอัตโนมัติ Hooks จะขยายระบบอัตโนมัตินี้
เวิร์กโฟลว์ GitHub Actions สามารถกำหนด hooks ที่บังคับใช้นโยบายของทีมในระหว่างเซสชันอัตโนมัติ:
| – name: เรียกใช้ Claude Code ด้วย hooks ที่เข้มงวด env: STRICT_MODE: 1 run: | claude “ตรวจสอบ PR นี้และเสนอแนะการปรับปรุง” |
แฟล็ก STRICT_MODE จะเปิดใช้งานตรรกะการตรวจสอบแบบมีเงื่อนไขในสคริปต์ hook สิ่งนี้ช่วยให้มั่นใจได้ว่าเซสชันอัตโนมัติเป็นไปตามกฎที่เข้มงวดกว่าการพัฒนาแบบโต้ตอบ
การสร้าง Audit Trail
PostToolUse hooks ในสภาพแวดล้อม CI จะสร้างบันทึกการตรวจสอบโดยละเอียดของการดำเนินการทั้งหมดของ Claude:
| { “event”: “PostToolUse”, “command”: “./scripts/log-to-database.sh”, “async”: true } |
การบันทึกเบื้องหลังไม่ส่งผลกระทบต่อประสิทธิภาพ แต่ให้ประวัติการดำเนินการที่สมบูรณ์สำหรับการปฏิบัติตามข้อกำหนดและการดีบัก
เมนู /hooks
Claude Code มีคำสั่ง /hooks ที่แสดง hooks ที่ใช้งานอยู่ทั้งหมดสำหรับเซสชันปัจจุบัน ตามเอกสารอย่างเป็นทางการ เมนูนี้แสดง:
- ประเภทเหตุการณ์ Hook
- รูปแบบ Matcher
- จุดปลายคำสั่งหรือ URL
- ว่า hook ทำงานแบบ async หรือไม่
- แหล่งที่มาของการกำหนดค่า (โปรเจกต์, ผู้ใช้ หรือปลั๊กอิน)
การเลือก hook จะแสดงการกำหนดค่าทั้งหมด และอนุญาตให้ปิดใช้งานชั่วคราวสำหรับเซสชันปัจจุบัน
ปิดใช้งานหรือลบ Hooks
Hooks สามารถปิดใช้งานได้โดยไม่ต้องลบการกำหนดค่าโดยการเพิ่ม “enabled”: false ไปยังคำจำกัดความของ hook สิ่งนี้จะรักษาการกำหนดค่าไว้ แต่ป้องกันการดำเนินการ
ในการลบ hook อย่างถาวร ให้ลบรายการออกจากไฟล์ settings.json ที่เกี่ยวข้อง การเปลี่ยนแปลงจะมีผลเมื่อเริ่มเซสชันใหม่ หรือเมื่อรัน /reload
Hooks ใน Skills และ Agents
ตามเอกสารอย่างเป็นทางการ hooks ที่กำหนดไว้ภายในการกำหนดค่า skill หรือ subagent จะใช้ได้เฉพาะเมื่อ skill หรือ agent นั้นทำงาน สิ่งนี้ช่วยให้ระบบอัตโนมัติเฉพาะสำหรับขั้นตอนการทำงานที่เฉพาะเจาะจง
subagent การดีบักอาจรวม hooks ที่บันทึกการเรียกใช้เครื่องมือทั้งหมด:
| { “name”: “debugger”, “hooks”: [ { “event”: “PostToolUse”, “command”: “./scripts/log-debug.sh”, “async”: true } ] } |
Hooks เหล่านี้จะทำงานเฉพาะในช่วงเซสชันของ agent debugger เท่านั้น ไม่ใช่ในช่วงการทำงานปกติของ Claude Code
อ้างอิงสคริปต์ด้วยพาธ
คำสั่ง Hook รองรับทั้งพาธสัมพัทธ์และพาธสัมบูรณ์ พาธสัมพัทธ์จะแก้ไขจากรากของโปรเจกต์ที่ Claude Code ทำงาน
แนวทางปฏิบัติที่ดีที่สุดจากการสนทนาในชุมชน:
- เก็บสคริปต์ hook ไว้ในไดเรกทอรี .claude/hooks/
- ใช้ชื่อที่สื่อความหมาย: validate-typescript.sh ไม่ใช่ hook1.sh
- ทำให้สคริปต์สามารถดำเนินการได้: chmod +x .claude/hooks/*.sh
- ใส่บรรทัด shebang: #!/usr/bin/env bash หรือ #!/usr/bin/env python3
- เพิ่มการจัดการข้อผิดพลาดด้วย set -e ในสคริปต์ bash
ความสามารถของ Hook ในอนาคต
คำขอคุณสมบัติบน GitHub เปิดเผยการปรับปรุง hook ที่วางแผนไว้และร้องขอ:
- Inline script hooks: กำหนดตรรกะ hook โดยตรงใน settings.json โดยไม่ต้องใช้ไฟล์ภายนอก
- MCP tool integration: เรียกใช้เครื่องมือเซิร์ฟเวอร์ MCP จาก hooks แทนคำสั่งเชลล์
- Multi-agent collaboration: Hooks ที่ประสานงานระหว่างอินสแตนซ์ Claude บนเครื่องที่แตกต่างกัน
- Enhanced typing: คำจำกัดความประเภท TypeScript สำหรับสคีมาอินพุต/เอาต์พุตของ hook
ตาม GitHub issue #4274 คำขอสำหรับประเภท hook แบบรวม (MCP tool, inline script, API call) มีเป้าหมายเพื่อทำให้การกำหนดค่าง่ายขึ้นและปรับปรุงประสบการณ์ของนักพัฒนา
คำถามที่พบบ่อย
Hooks สามารถป้องกัน Claude ไม่ให้เรียกใช้คำสั่งอันตรายได้หรือไม่?
ใช่ PreToolUse hooks สามารถบล็อกการดำเนินการเครื่องมือใดๆ ได้โดยการออกด้วยรหัส 1 ซึ่งรวมถึงการแก้ไขไฟล์ การดำเนินการคำสั่ง และการเรียกใช้เครื่องมือ MCP hook จะได้รับอินพุตเครื่องมือที่สมบูรณ์ และสามารถตรวจสอบกับเกณฑ์ใดๆ ก่อนที่จะอนุญาตให้ดำเนินการได้
ฉันจะดีบัก hook ที่ไม่ทำงานได้อย่างไร?
เปิดใช้งานการบันทึกการดีบักด้วย CLAUDE_DEBUG=1 ก่อนเริ่ม Claude Code ตรวจสอบบันทึกเซสชันสำหรับรายละเอียดการดำเนินการ hook รวมถึง hooks ที่ตรงกัน อินพุต JSON ที่ส่ง stdout/stderr ของ hook และรหัสการออก ทดสอบ hook แบบแยกโดยการส่ง JSON ตัวอย่างไปยังสคริปต์ hook
Hooks ทำงานกับทุกแพลตฟอร์ม Claude Code หรือไม่?
Hooks ทำงานใน CLI, แอปเดสก์ท็อป และส่วนขยาย VS Code ตามเอกสารอย่างเป็นทางการ hooks จะทำงานทุกที่ที่ Claude Code ทำงานและสามารถเข้าถึงระบบไฟล์ได้ Claude บนเบราว์เซอร์และแอปมือถือไม่รองรับ hooks เนื่องจากข้อจำกัดด้าน sandboxing
Hooks สามารถแก้ไขการตอบสนองหรือพฤติกรรมของ Claude ได้หรือไม่?
Prompt hooks แทรกคำแนะนำที่ส่งผลต่อพฤติกรรมของ Claude Agent hooks มอบหมายการจัดการเหตุการณ์ให้กับ subagents พิเศษ อย่างไรก็ตาม hooks ไม่สามารถแก้ไขข้อความที่สร้างขึ้นหรือกระบวนการให้เหตุผลของ Claude ได้โดยตรง—พวกมันทำงานโดยการให้บริบทและบล็อกการดำเนินการ
ความแตกต่างระหว่าง async และ sync hooks คืออะไร?
Synchronous hooks จะบล็อกขั้นตอนการทำงานของ Claude จนกว่าจะเสร็จสมบูรณ์หรือหมดเวลา Asynchronous hooks จะทำงานในพื้นหลังโดยไม่บล็อก Sync hooks สามารถป้องกันการดำเนินการผ่านรหัสการออก Async hooks ไม่สามารถบล็อกได้ เนื่องจาก Claude ดำเนินการต่อไปก่อนที่ hook จะเสร็จสิ้น ใช้ async สำหรับการบันทึกและการแจ้งเตือน, sync สำหรับการตรวจสอบ
ฉันจะแชร์ hooks กับทั้งทีมได้อย่างไร?
คอมมิตไฟล์ .claude/settings.json ในระบบควบคุมเวอร์ชัน Project-level hooks จะนำไปใช้กับสมาชิกในทีมทุกคนที่โคลน repository สำหรับนโยบายทั่วทั้งองค์กร ทีมสามารถดูแลไฟล์การตั้งค่าระดับผู้ใช้ที่แชร์ ซึ่งสมาชิกจะคัดลอกไปยัง ~/.claude/settings.json
HTTP hooks สามารถเรียก API ภายในที่อยู่เบื้องหลังไฟร์วอลล์ได้หรือไม่?
ใช่ หาก Claude Code ทำงานในสภาพแวดล้อมที่สามารถเข้าถึงเครือข่าย API เหล่านั้นได้ HTTP hooks จะส่งคำขอ POST มาตรฐานจากเครื่องที่รัน Claude Code ไฟร์วอลล์ขององค์กรและ VPN จะถูกนำมาใช้ตามปกติ Sandbox proxy ที่กล่าวถึงในเอกสารจะควบคุมการเปิดเผยตัวแปรสภาพแวดล้อม ไม่ใช่การกำหนดเส้นทางเครือข่าย
Hooks เพิ่มการใช้โทเค็นของ Claude Code หรือไม่?
Prompt hooks จะแทรกข้อความเข้าไปในบริบทของ Claude ซึ่งจะใช้โทเค็น Command และ HTTP hooks จะไม่ส่งผลกระทบโดยตรงต่อการใช้โทเค็น แต่ผลลัพธ์ของพวกมัน (ข้อความแสดงข้อผิดพลาด, คำแนะนำ) จะกลายเป็นส่วนหนึ่งของบริบทการสนทนา รหัสการออก 2 พร้อมข้อความอธิบายจะเพิ่มบริบทมากขึ้นกว่ารหัสการออก 1 พร้อมการบล็อกแบบง่าย
สรุป
Claude Code hooks เปลี่ยนผู้ช่วย AI จากเครื่องมืออันทรงพลังให้กลายเป็นแพลตฟอร์มการพัฒนาอัตโนมัติอย่างเต็มรูปแบบ ระบบเหตุการณ์มีจุดสกัดกั้นตลอดขั้นตอนการทำงานของ Claude ตั้งแต่การเริ่มต้นเซสชันไปจนถึงการบีบอัดบริบท
Command hooks จัดการการตรวจสอบและจัดรูปแบบภายใน เครื่องมือ HTTP ผสานรวมบริการภายนอกและฐานข้อมูล Prompt hooks ปรับเปลี่ยนพฤติกรรมผ่านการแทรกบริบท ทั้งหมดนี้ช่วยให้รูปแบบอัตโนมัติที่บังคับใช้นโยบายของทีม รักษาคุณภาพโค้ด และผสานรวมกับโครงสร้างพื้นฐานการพัฒนาที่มีอยู่
ระบบ Matcher จะกรอง hooks ให้ตรงกับเครื่องมือและรูปแบบไฟล์เฉพาะ รหัสการออกและเอาต์พุต JSON ควบคุมการไหลของการตัดสินใจ การดำเนินการแบบอะซิงโครนัสป้องกันการบล็อกสำหรับการดำเนินการที่ช้า การกำหนดค่าที่สมบูรณ์รองรับทุกอย่างตั้งแต่การจัดรูปแบบอัตโนมัติอย่างง่ายไปจนถึงการตรวจสอบแบบหลายขั้นตอนที่ซับซ้อน
เริ่มต้นด้วย PostToolUse hooks พื้นฐานสำหรับการจัดรูปแบบโค้ด เพิ่มการตรวจสอบ PreToolUse เมื่อมีนโยบายเกิดขึ้น ลองใช้ prompt hooks สำหรับการปรับเปลี่ยนพฤติกรรม สร้างการผสานรวม HTTP สำหรับการบังคับใช้ทั่วทั้งทีม
ตรวจสอบเอกสารอย่างเป็นทางการของ Claude Code เพื่อดูเอกสารอ้างอิง hooks ที่สมบูรณ์และสคีมาการกำหนดค่าที่อัปเดตเมื่อมีความสามารถใหม่ๆ ออกมา
