ஆல் Claude Code hooks என்றால் என்ன? முழுமையான விளக்கம்
Claude Code hooks எவ்வாறு செயல்படுகின்றன என்பதை அறியுங்கள். Model-ன் முடிவை மீறி இவை இயங்கும் விதம், exit code 2-ன் தாக்கம் மற்றும் பாதுகாப்பு அம்சங்கள் குறித்த விரிவான தகவல்கள் இங்கே.
Claude Code hook என்றால் என்ன
Claude Code hooks என்பவை, Claude Code தனது வாழ்க்கைச் சுழற்சியின் குறிப்பிட்ட புள்ளிகளில் தானாகவே இயக்கும் shell commands ஆகும். ஒரு hook-க்கும் rules file-க்கும் உள்ள அடிப்படை வேறுபாடு இதுதான். CLAUDE.md-ல் உள்ள ஒரு அறிவுரை என்பது ஒரு ஆலோசனையாகும்; அதை model தனது சூழலில் உள்ள மற்ற தகவல்களுடன் ஒப்பிட்டுப் பார்க்கும். ஆனால், ஒரு hook என்பது code ஆகும்; model ஒப்புக்கொண்டாலும் இல்லாவிட்டாலும் அது இயங்கும். நீங்கள் இரண்டு முறை சொல்லியும் உங்கள் agent formatter-ஐத் தவிர்க்கிறது என்றால், அதற்கு இன்னும் கடுமையான அறிவுரை தேவையில்லை. உங்களுக்கு ஒரு hook தேவை.
இதன் செயல்முறை எளிமையானது. ஒரு settings file-ல் event பெயர் ஒன்றின் கீழ் நீங்கள் ஒரு command-ஐப் பதிவு செய்ய வேண்டும். அந்த event நிகழும்போது, Claude Code உங்கள் command-ஐ இயக்கி, event தரவுகளை அதன் standard input (stdin)-க்கு JSON (JavaScript object notation) வடிவில் எழுதும். உங்கள் command அந்தத் தரவைப் படித்து, தனது வேலையைச் செய்து, ஒரு exit status-ஐ வழங்கும். ஒரு PreToolUse hook-லிருந்து வரும் exit 2, tool call இயங்குவதற்கு முன்பே அதை ரத்து செய்யும்; உங்கள் script standard error (stderr)-ல் எதை எழுதுகிறதோ, அதுவே காரணமான model-க்குத் தெரிவிக்கப்படும்.
இங்குள்ள event பெயர்கள் மற்றும் field பெயர்கள் Claude Code hooks reference-லிருந்து எடுக்கப்பட்டவை. இவை ஆகஸ்ட் 2026-ல் release 2.1.232-க்குச் சரிபார்க்கப்பட்டன. இந்த அமைப்பு விரைவாக மாறக்கூடியது என்பதால், எந்தவொரு blog post-லிருந்தும் JSON-ஐ நகலெடுக்கும் முன், உங்கள் பதிப்பிற்கான reference-ஐச் சரிபார்க்கவும். உங்களுடையதை claude --version மூலம் print செய்யவும்.
Hook configuration எங்கு சேமிக்கப்படுகிறது
Hook என்பது settings file-ல் உள்ள ஒரு JSON block ஆகும். இதை ஆறு இடங்களில் சேமிக்கலாம்; அந்த file-ன் scope-தான் அந்த hook-ன் scope-ஆகவும் இருக்கும்.
~/.claude/settings.json: உங்கள் கணினியில் உள்ள அனைத்து project-களுக்கும் பொருந்தும், மற்றவர்களுக்குப் பொருந்தாது..claude/settings.json: ஒரு குறிப்பிட்ட project-க்கு மட்டும் பொருந்தும், இது repository-ல் commit செய்யப்படுவதால், அதை clone செய்யும் அனைவருக்கும் இந்த hook கிடைக்கும்..claude/settings.local.json: ஒரு குறிப்பிட்ட project-க்கு மட்டும் பொருந்தும், உங்கள் கணினியில் மட்டுமே இருக்கும்.- Managed policy settings: நிறுவனம் முழுவதும் பொருந்தும், இதை administrator அமைப்பார்.
hooks/hooks.json: ஒரு plugin-க்குள் இருக்கும், அந்த plugin enabled நிலையில் இருக்கும்போது மட்டும் செயல்படும்.- Skill அல்லது subagent frontmatter: அந்த component active நிலையில் இருக்கும்போது மட்டும் செயல்படும்.
இந்த file-களில் உள்ள hook பதிவுகள் ஒன்றையொன்று override செய்வதற்குப் பதிலாக ஒன்றிணைகின்றன (merge). ஒரு project settings file, உங்கள் user settings-ல் உள்ள hook-களை நீக்காமல், அவற்றுடன் புதிய hook-களைச் சேர்க்கிறது. எனவே, ஒரு நிகழ்வு (event) பல file-களில் இருந்து வரும் பல hook-களைக் கொண்டிருக்க முடியும். "disableAllHooks": true அமைப்பைச் செயல்படுத்துவதன் மூலம் இவற்றை முடக்கலாம்; இதற்கு ஒரு விதிவிலக்கு உண்டு: managed policy settings-ல் இருந்து வரும் hook-கள், அந்த அமைப்பும் managed settings-ல் பயன்படுத்தப்பட்டால் ஒழிய, தொடர்ந்து இயங்கும்.
தற்போது பதிவு செய்யப்பட்டுள்ள அனைத்து hook-களையும் பட்டியலிட, ஒரு session-க்குள் /hooks கட்டளையை இயக்கவும். இவை நிகழ்வுகளின் அடிப்படையில் வகைப்படுத்தப்பட்டு, ஒவ்வொன்றின் source file மற்றும் matcher விவரங்களுடன் காட்டப்படும். இந்த menu-வில் மாற்றங்களைச் செய்ய முடியாது (read only); எனவே, settings file-ஐத் திருத்துவதன் மூலமே hook-ஐ மாற்ற முடியும். File watcher பொதுவாக restart செய்யாமலேயே மாற்றங்களைப் புரிந்துகொண்டு செயல்படும்.
Claude Code hook நிகழ்வுகள் எவை
Release 2.1.232 பதிப்பில் முப்பத்தொன்று நிகழ்வுகள் பட்டியலிடப்பட்டுள்ளன. இவை SessionStart முதல் SessionEnd வரை உள்ளன; இவை compaction, subagents, worktrees மற்றும் configuration கோப்புகளை உள்ளடக்கியவை. Server பணிகளுக்கு இவற்றில் சில மட்டுமே பயன்படுகின்றன.
PreToolUse: ஒரு tool call இயங்குவதற்கு முன்பு. இதுவே தடுக்கக்கூடிய (block) நிகழ்வாகும்.PostToolUse: ஒரு tool call வெற்றிகரமாக முடிந்த பிறகு. அது தோல்வியுற்றால்PostToolUseFailureதூண்டப்படும், எனவே அனைத்து முடிவுகளையும் கண்காணிக்க வேண்டிய hook-க்கு இவை இரண்டும் தேவை.PermissionRequest: ஒரு tool call-க்கு அனுமதி தேவைப்படும்போது, அதாவது approval prompt தோன்றும் தருணம்.UserPromptSubmit: நீங்கள் ஒரு prompt-ஐ சமர்ப்பிக்கும்போது, Claude அதைச் செயலாக்குவதற்கு முன்பு. இந்த hook stdout-ல் எதை அச்சிடுகிறதோ, அது model-ன் context-ல் சேர்க்கப்படும்.SessionStartமற்றும்SessionEnd: ஒரு session-ன் தொடக்கத்திலும் முடிவிலும்.SessionStartஎன்பது compaction முடிந்த பிறகும்,compactஎன்ற matcher மதிப்பிற்கு உட்பட்டும் தூண்டப்படும்.Stop: Claude தனது பதிலை முடிக்கும்போது. இது ஒரு turn-க்கு ஒருமுறை மட்டுமே நிகழும், ஒரு பணி முழுமையாக முடிந்தவுடன் அல்ல.
ஒவ்வொரு குழுவும் ஒரு matcher-ஐக் கொண்டுள்ளது, இது எந்த நிகழ்வுகள் hook-ஐ இயக்க வேண்டும் என்பதைத் தீர்மானிக்கிறது. Tool நிகழ்வுகளில், இது tool பெயரால் வடிகட்டுகிறது; எனவே "Edit|Write" கோப்பு திருத்தங்களின்போது (file edits) மட்டுமே தூண்டப்படும். Matcher-கள் case sensitive ஆனவை. காலியான matcher அனைத்து நிகழ்வுகளிலும் தூண்டப்படும். MCP (model context protocol) server-லிருந்து வரும் கருவிகள் mcp__<server>__<tool> என்று பெயரிடப்பட்டுள்ளன, எனவே "mcp__github__.*" என்ற matcher ஒரு குறிப்பிட்ட server-ன் கருவிகளை மட்டும் பிடித்து மற்றவற்றைத் தவிர்க்கும்.
Stop hook-களை எழுதும் முன் கவனிக்க வேண்டிய ஒரு சிக்கல் உள்ளது. தடுக்கும் (blocking) திறன் கொண்ட ஒரு Stop hook, model-ஐ மீண்டும் பணிக்கு அனுப்பும். தொடர்ந்து எட்டு முறை தடுக்கும்போது, Claude Code அந்த hook-ஐ மீறிச் செயல்படும் (override). Hook உள்ளீட்டிலிருந்து stop_hook_active புலத்தைப் படித்து, அது true ஆக இருக்கும்போது exit 0 கொடுக்கவும்; இல்லையெனில், அந்த வரம்பை எட்டும் வரை உங்கள் hook மீண்டும் மீண்டும் இயங்கிக்கொண்டே இருக்கும்.
stdin-ல் ஒரு hook பெறுவது என்ன
Claude npm test-ஐ இயக்கத் தயாராகும்போது, Bash-ல் உள்ள ஒரு PreToolUse hook, stdin-ல் இதைப் படிக்கிறது:
{
"session_id": "abc123",
"cwd": "/home/deploy/myproject",
"hook_event_name": "PreToolUse",
"tool_name": "Bash",
"tool_input": {
"command": "npm test"
}
}ஒவ்வொரு நிகழ்வும் session_id, cwd, permission_mode, transcript_path மற்றும் hook_event_name ஆகியவற்றைக் கொண்டிருக்கும். கருவி நிகழ்வுகள் (tool events) tool_name, tool_input மற்றும் tool_use_id ஆகியவற்றைச் சேர்க்கின்றன. பிற நிகழ்வுகள் அவற்றின் சொந்த புலங்களைக் கொண்டுள்ளன: UserPromptSubmit ஆனது prompt உரையையும், SessionStart ஆனது startup, resume, clear, compact அல்லது fork ஆகியவற்றின் source-ஐயும் பெறுகிறது.
shell script-க்குள் இதைப் படிப்பதற்கு jq வழக்கமான வழியாகும், ஆனால் ஒரு குறைந்தபட்ச server image-ல் இது இருக்காது. Ubuntu மற்றும் Debian-ல் sudo apt install -y jq மூலம் முதலில் இதை நிறுவவும்.
செயல்பாட்டில் உள்ள tool call-க்கு exit status என்ன செய்கிறது
மூன்று முடிவுகள் உள்ளன.
- Exit 0 என்பது உங்கள் hook எந்த ஆட்சேபனையும் தெரிவிக்கவில்லை என்று பொருள்.
PreToolUse-ல் இது ஒப்புதல் என்று அர்த்தமல்ல, வழக்கமான அனுமதி ஓட்டம் (permission flow) தொடர்ந்து நடைபெறும்.UserPromptSubmitமற்றும்SessionStart-ல், stdout என்பது model-ன் context-ல் சேர்க்கப்படும். - Exit 2 என்பது தடுக்கக்கூடிய நிகழ்வுகளில் செயலைத் தடுக்கும்,
PreToolUseஅவற்றில் ஒன்று, மேலும் stderr என்பது model-க்குக் காட்டப்படும் காரணமாக மாறும்.PostToolUseபோன்ற தடுக்க முடியாத நிகழ்வுகளில், இந்தத் தடுப்பு புறக்கணிக்கப்படும், இருப்பினும் stderr பின்னூட்டமாக (feedback) model-ஐச் சென்றடையும். - பிற exit code-கள் தடுக்காத பிழைகளாகக் கருதப்படும். செயல் தொடரும்.
Failed with non-blocking status code:என்ற உரைக்குப் பிறகு, stderr-ன் முதல் வரியைக் கொண்ட hook பிழை அறிவிப்பு transcript-ல் காட்டப்படும்.
தடுத்தல் அல்லது அமைதியாக இருத்தல் என்பதைத் தாண்டி, exit 0-ஐப் பயன்படுத்தி stdout-ல் ஒரு JSON object-ஐ அச்சிடுங்கள். ஒரு PreToolUse hook, permissionDecision மூலம் முடிவெடுக்கும்:
{
"hookSpecificOutput": {
"hookEventName": "PreToolUse",
"permissionDecision": "deny",
"permissionDecisionReason": "Database drops go through a migration, not through the agent."
}
}"allow" என்பது interactive prompt-ஐத் தவிர்க்கும், "deny" என்பது அழைப்பை ரத்து செய்து அதற்கான காரணத்தை model-க்கு அனுப்பும், மற்றும் "ask" என்பது prompt-ஐ வழக்கம்போலக் காட்டும். ஒவ்வொரு hook-க்கும் ஒரு பாணியைத் தேர்ந்தெடுக்கவும். Exit 2-ஐயும் stdout-ல் உள்ள JSON முடிவையும் ஒன்றாகப் பயன்படுத்துவது, நீங்கள் சரிபார்க்க வேண்டிய ஒரு முடிவைத் தரும்.
ஒரே நிகழ்வுக்குப் பல hooks பொருந்தும்போது, அவை இணையாக (parallel) இயங்கும் மற்றும் ஒவ்வொன்றும் முழுமையாக முடிவடையும். ஒரு hook-லிருந்து வரும் deny அதன் பிற hooks-ஐ நிறுத்தாது, எனவே ஒரு guardrail hook அதே அழைப்பை மறுக்கும்போதும், ஒரு logging hook அதன் வரியை எழுதும். Claude Code பின்னர் பதில்களை ஒருங்கிணைத்து, deny, defer, ask, allow என்ற வரிசையில் மிகவும் கட்டுப்படுத்தப்பட்ட முடிவைத் தக்கவைக்கும்.
உதாரணம் 1: ஒரு அழிவுகரமான கட்டளையை அது இயங்குவதற்கு முன்பே தடுத்தல்
இதை உங்கள் திட்டத்தில் .claude/hooks/block-destructive.sh ஆகச் சேமிக்கவும்:
#!/bin/bash
# Deny a Bash tool call whose command matches a banned pattern.
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
for pattern in 'rm -rf /' 'mkfs' 'dd if=' 'DROP TABLE'; do
if printf '%s' "$COMMAND" | grep -qiF -- "$pattern"; then
echo "Blocked by policy: the command matches '$pattern'. A human runs this one." >&2
exit 2
fi
done
exit 0இதை executable ஆக மாற்றவும், பின்னர் .claude/settings.json-ல் உள்ள PreToolUse-ல் பதிவு செய்யவும்:
chmod +x .claude/hooks/block-destructive.sh{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-destructive.sh",
"timeout": 10,
"statusMessage": "Checking the command against policy"
}
]
}
]
}
}ஸ்கிரிப்டை நம்புவதற்கு முன் அதை நீங்களே கைமுறையாகச் சோதிக்கவும், ஏனெனில் அதன் சொந்த உள்ளீட்டிலேயே செயலிழக்கும் ஒரு hook, பாதுகாப்பற்ற நிலையில் (fails open) முடிந்துவிடும்:
echo '{"tool_name":"Bash","tool_input":{"command":"rm -rf /var/lib/postgresql"}}' \
| .claude/hooks/block-destructive.sh
echo $?நீங்கள் stderr-ல் Blocked by policy: வரியையும், 2 என்ற exit code-ஐயும் பார்க்க வேண்டும். ls -la போன்ற பாதிப்பில்லாத கட்டளையை உள்ளீடாகக் கொடுத்தால், எந்த வெளியீடும் இருக்கக்கூடாது மற்றும் exit code 0 ஆக இருக்க வேண்டும். ஒரு session-ல், மறுக்கப்பட்ட அழைப்பு உங்கள் காரணத்துடன் transcript-ல் தோன்றும், அதை model படித்து அதற்கேற்ப தன்னை மாற்றிக்கொள்ளும்.
ஒரு சிறப்பம்சம் இதைச் செய்வதற்கு உரியதாக்குகிறது: PreToolUse hook-கள் permission-mode சரிபார்ப்புக்கு முன்பே இயங்குகின்றன, அதுவும் அனைத்து permission mode-களிலும். எனவே, bypassPermissions-ன் கீழும் இந்தத் தடை நீடிக்கும். இதுவே, Claude Code auto mode மற்றும் அதன் permission அமைப்புகள் போன்றவற்றுடன் இந்த hook-ஐப் பயனுள்ளதாக்குகிறது; அங்கு prompts குறைக்கப்பட்டாலும், hook தொடர்ந்து இயங்கும்.
இது என்ன என்பதைப் பற்றி வெளிப்படையாக இருங்கள். ஒரு கட்டளைச் சரத்தில் (command string) pattern matching செய்வது, ஒரு agent கவனக்குறைவாகச் செயல்படுவதைத் தடுக்கும் ஒரு பாதுகாப்பு அரணே தவிர, அது ஒரு agent தந்திரமாகச் செயல்படுவதைத் தடுக்கும் எல்லையல்ல. ஏனெனில், உங்கள் grep-க்குத் தெரியாத வடிவத்தில் அதே கட்டளையை எழுத முடியும். கடுமையான விதிகள் permission system-லும், அந்த process இயங்கும் account-லும் மட்டுமே இருக்க வேண்டும்.
உதாரணம் 2: ஒவ்வொரு திருத்தத்திற்குப் பிறகும் format மற்றும் lint செய்தல்
PostToolUse மற்றும் Edit|Write matcher-ஐப் பயன்படுத்தி, ஏதேனும் ஒரு கோப்பு திருத்தும் கருவி (file-editing tool) இயங்கிய பிறகு இதை இயக்கலாம். இதை .claude/hooks/after-edit.sh என்ற பெயரில் சேமிக்கவும்:
#!/bin/bash
# Format the edited file, then report lint failures back to the model.
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
[ -z "$FILE" ] && exit 0
case "$FILE" in
*.py)
ruff format "$FILE" >/dev/null 2>&1
if ! ruff check "$FILE" >&2; then
exit 2
fi
;;
*.sh)
if ! shellcheck "$FILE" >&2; then
exit 2
fi
;;
esac
exit 0{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/after-edit.sh",
"timeout": 60
}
]
}
]
}
}Python கோப்பு ஒன்றில் தவறான indentation கொண்ட function-ஐச் சேர்க்குமாறு Claude-இடம் கேட்கவும், பின் அந்தக் கோப்பைத் திறக்கவும். அது தானாகவே format செய்யப்பட்டுவிடும். hook சரியாக இயங்கியதை இது உறுதிப்படுத்துகிறது, ஏனெனில் hook வெற்றிகரமாக இயங்கினால் உரையாடலில் எந்தத் தகவலும் காட்டப்படாது.
இங்குள்ள exit 2 எதையும் மாற்றாது. PostToolUse என்பது கருவி இயங்கி முடித்த பிறகுதான் செயல்படும், எனவே திருத்தம் ஏற்கனவே வட்டில் (disk) சேமிக்கப்பட்டிருக்கும். exit 2-ஐப் பயன்படுத்துவதன் மூலம், ruff check வெளியீடு model-க்கு பின்னூட்டமாக (feedback) சென்றடையும்; இதனால் அது செய்த பிழையைத் தானே சரிசெய்து கொள்ளும். commit செய்யும் நேரத்தில் கண்டறியப்படும் lint பிழைக்கும், agent அதே தருணத்தில் சரிசெய்யும் பிழைக்கும் இதுவே வித்தியாசம்.
இங்கு இரண்டு matcher வரம்புகள் முக்கியம். Edit|Write என்பது shell command மூலம் மாற்றப்படும் கோப்புகளைக் கவனிக்காது, மேலும் Claude அடிக்கடி Bash மூலமே கோப்புகளை எழுதுவதால் இந்த இடைவெளி உண்மையானது. ஒவ்வொரு அழைப்பிற்கும் (per-call) பாதுகாப்பு கிடைக்க, Bash-ஐயும் match செய்து, git status --porcelain மூலம் மாற்றப்பட்ட கோப்புகளை script-ல் பட்டியலிடவும். ஒவ்வொரு முறைக்கும் (per-turn) ஒருமுறை மட்டும் ஸ்கேன் செய்ய, அதை Stop hook-ல் வைக்கவும்.
உதாரணம் 3: தணிக்கைக்காக ஒவ்வொரு tool அழைப்பையும் log செய்தல்
PostToolUse-ல் உள்ள ஒரு காலி matcher ஒவ்வொரு tool-க்கும் செயல்படும். பதிவை home directory-ல் உள்ள கோப்பிற்கு அனுப்புவதற்குப் பதிலாக system journal-க்கு அனுப்புவது, அதை agent-ன் சொந்த shell-ன் அணுகலுக்கு அப்பாற்பட்டு வைத்திருக்கும்:
{
"hooks": {
"PostToolUse": [
{
"matcher": "",
"hooks": [
{
"type": "command",
"command": "jq -c '{time: now|todate, session: .session_id, cwd: .cwd, tool: .tool_name, input: .tool_input}' | logger -t claude-code -p local0.info"
}
]
}
]
}
}journalctl -t claude-code -o cat | tail -n 5 மூலம் அதை மீண்டும் வாசிக்கவும். ஒவ்வொரு tool அழைப்பிற்கும் ஒரு JSON வரி இருக்க வேண்டும், புதியது கடைசியாக இருக்கும். எதுவும் தோன்றவில்லை என்றால், hook இயங்கவில்லை என்று அர்த்தம்; அதற்கான தீர்வுகள் கீழே உள்ள troubleshooting பகுதியில் உள்ளன.
தோல்வியடைந்த அழைப்புகளைப் பிடிக்க PostToolUseFailure-ன் கீழ் அதே தொகுப்பைச் சேர்க்கவும், ஏனெனில் PostToolUse வெற்றிகரமாக முடிந்தால் மட்டுமே செயல்படும், ஆனால் தோல்வியடைந்த கட்டளைகளே பெரும்பாலும் முக்கியமானவை. உங்கள் home directory-ல் உள்ள கோப்பில் சேர்ப்பதற்குப் பதிலாக logger-ஐப் பயன்படுத்துவதற்கான காரணம் உரிமை (ownership) ஆகும்: ஒரு hook, agent-ன் shell இயங்கும் அதே பயனர் கணக்கில்தான் இயங்கும், எனவே அந்தப் பயனர் எதில் எழுத முடியுமோ, அதை அவர்களால் அழிக்கவும் (truncate) முடியும். Journal, systemd-journald-ஆல் அதன் சொந்த கணக்கின் கீழ் எழுதப்படுகிறது.
ஒரு hook எவ்வளவு காலம் இயங்கலாம்
The data behind this chart
[
{
"label": "command, http or mcp_tool hook",
"default_timeout_seconds": 600
},
{
"label": "agent hook",
"default_timeout_seconds": 60
},
{
"label": "prompt hook",
"default_timeout_seconds": 30
},
{
"label": "command hook on UserPromptSubmit",
"default_timeout_seconds": 30
},
{
"label": "command hook on MessageDisplay",
"default_timeout_seconds": 10
},
{
"label": "any hook on SessionEnd",
"default_timeout_seconds": 1.5
}
]ஒரு command hook இயல்பாக 600 வினாடிகள் வரை இயங்கும், இது பத்து நிமிடங்களுக்குச் சமம். சில நிகழ்வுகள் இந்த கால அளவை வெகுவாகக் குறைக்கின்றன. அனைத்து SessionEnd hook-களும் சேர்ந்து 1.5 வினாடிகள் என்ற பொதுவான கால வரம்பையே பகிர்ந்து கொள்கின்றன. எனவே, session முடிவில் செய்யப்படும் cleanup பணிகள் விரைவாக இருக்க வேண்டும். இருப்பினும், hook-ல் நீண்ட timeout மதிப்பை அமைப்பதன் மூலம், அந்தப் பொதுவான கால வரம்பை 60 வினாடிகள் வரை அதிகரிக்க முடியும்.
தனது கால வரம்பை எட்டும் ஒரு hook ரத்து செய்யப்படும், அது எந்த முடிவையும் வழங்காது. ஒரு PreToolUse guardrail-ஐப் பொறுத்தவரை, இது எதையும் தடுக்காது என்று பொருள்: அந்த tool call வழக்கமான அனுமதி ஓட்டத்திலேயே (permission flow) தொடரும். இதனாலேயே guardrail script-களைச் சிறியதாக வைத்திருக்க வேண்டும். log-களை ஓரிடத்திற்கு அனுப்புவது போன்ற, எவரும் காத்திருக்கத் தேவையில்லாத மெதுவான பணிகளுக்கு, "async": true என்பதை அமைக்கவும். அப்போது அந்த hook பின்னணியில் இயங்கும், அது tool call-ஐத் தடுத்து நிறுத்தாது.
Hooks, rules files, skills மற்றும் MCP servers
ஏஜென்ட் (agent) செயல்படும் விதத்தை மாற்றக்கூடிய நான்கு விஷயங்கள் அடிக்கடி குழப்பத்தை ஏற்படுத்துகின்றன. அவற்றில் ஒன்று மட்டுமே பரிந்துரை என்பதைத் தாண்டி கட்டாயமாகச் செயல்படுகிறது.
ஒரு rules file (CLAUDE.md, அல்லது .claude/rules/-ன் கீழ் உள்ள ஒரு கோப்பு) என்பது model-ன் context-ல் ஏற்றப்படும் உரை ஆகும். இது நடத்தையை வடிவமைக்குமே தவிர, எதையும் கட்டாயப்படுத்தாது. நீண்ட உரையாடல், பெரிய diff மற்றும் புதிய பயனர் கோரிக்கை ஆகியவற்றிற்கு மத்தியில், இதில் உள்ள ஒரு வரி கவனிக்கப்படாமல் போகலாம். நீங்கள் எழுதிய அறிவுறுத்தல்களை ஏஜென்ட்கள் புறக்கணிப்பதற்கான சாதாரண காரணம் இதுதான்.
ஒரு skill என்பது model-க்குத் தேவைப்படும்போது அது ஏற்றிக்கொள்ளும் அறிவுறுத்தல்கள் மற்றும் scripts அடங்கிய கோப்புறை (folder) ஆகும். அந்தத் தேவையைக் கண்டறிவதே ஒரு skill-ன் நோக்கம், அதுவே அதன் எல்லையும் கூட: முடிவெடுப்பது இன்னும் model-தான். Ponytail, இது ஒரு ஏஜென்ட்டை மிகச்சிறிய மாற்றத்தை நோக்கித் தள்ளுகிறது போன்ற ஒரு skill-ல் இதை நீங்கள் காணலாம். இது ஒரு பணியை அணுகும் முறையை வடிவமைக்கிறது, ஆனால் model அதைத் தேர்ந்தெடுக்காத வரை இது செயல்படாது.
ஒரு MCP (model context protocol) server, model-க்கு அழைப்பதற்கான புதிய கருவிகளை வழங்குகிறது. இது ஏஜென்ட் அணுகக்கூடிய எல்லையை விரிவுபடுத்துகிறது. இது ஏஜென்ட்டை எதையும் செய்யத் தூண்டாது, மேலும் இதை நீங்கள் தனியாக இயக்க வேண்டும், இது ஒரு தனிப் பணி: VPS-ல் MCP servers-ஐ இயக்குவது என்பதைப் பார்க்கவும்.
இந்த நான்கில், model-ன் தேர்வு இல்லாமலேயே இயங்கக்கூடிய ஒரே விஷயம் hook ஆகும். ஒரு விருப்பத்திற்கு rules file-ஐயும், ஒரு செயல்முறைக்கு skill-ஐயும் பயன்படுத்தவும். ஒவ்வொரு முறையும் நடக்க வேண்டிய அல்லது ஒருபோதும் நடக்கக்கூடாத ஒரு செயலுக்கு hook-ஐப் பயன்படுத்தவும். ஒரு skill எப்போது rules file-ஐ விடச் சிறந்தது என்பது உட்பட விரிவான ஒப்பீட்டிற்கு, skills, MCP மற்றும் rules files ஒப்பீடு என்பதைப் பார்க்கவும்.
Plugin என்பது ஐந்தாவது வழிமுறை அல்ல, அது ஒரு தொகுப்பு முறை மட்டுமே. இது hooks மற்றும் skills-ஐ ஒரே install செய்யக்கூடிய அலகாக மாற்றுகிறது. இதன் மூலம் ஒரு குழு ஒரே guardrail-ஐ அனைத்து கணினிகளிலும் பயன்படுத்த முடியும்: Claude Code plugins எவ்வாறு செயல்படுகின்றன என்பதைப் பார்க்கவும்.
பகிரப்பட்ட VPS-ல் பாதுகாப்பு குறித்த முடிவு
Hook என்பது agent-ஆல் தூண்டப்படும் ஒரு code ஆகும்; இது Claude Code-ஐத் தொடங்கிய பயனரின் உரிமைகளுடன் இயங்கும். இது அந்தப் பயனரின் environment மற்றும் file permissions-ஐப் பெறும். ஒரு laptop-ல் இது ஒரு workflow சார்ந்த கேள்வி. ஆனால், ஒரு agent கவனிக்கப்படாமல் இயங்கும் VPS-ல், இது நான்கு நடைமுறைப் பகுதிகளைக் கொண்ட ஒரு பாதுகாப்புச் சிக்கலாகும்.
Repository-ல் உள்ள ஒரு hook நீங்கள் எழுதாத code ஆகும். .claude/settings.json commit செய்யப்படுவதால், ஒரு repository-ஐ clone செய்து அதற்குள் session-ஐத் தொடங்குவது, அந்த repository-உடன் வந்த hooks-ஐப் பதிவு செய்யக்கூடும். Claude Code அந்த folder-க்கான workspace trust dialog மூலம் project hooks-ஐக் கட்டுப்படுத்துகிறது; அதாவது, நீங்கள் trust-ஐ ஏற்றுக்கொள்வது என்பது அவற்றை இயக்க முடிவெடுக்கும் தருணமாகும். முதலில் hooks தொகுப்பைப் படிக்கவும்.
Hook ஒன்று tool-ன் முழு உள்ளீட்டையும் (input) காணும். tool_input-ஐ log செய்யும் ஒரு audit hook, ஒவ்வொரு command-ன் அனைத்து argument-களையும் ஒரு கோப்பில் எழுதும்; இதில் command line-ல் தற்செயலாக இருக்கும் எந்தவொரு token-ம் அடங்கும். அந்த log-க்கு, secret-க்குத் தேவைப்படும் அதே பாதுகாப்பு தேவைப்படுகிறது; இது AI agent-ன் அணுகலுக்கு வெளியே ரகசியங்களை வைத்திருத்தல் என்ற பரந்த சிக்கலின் ஒரு பகுதியாகும்.
Hook ஒன்று model-ன் context-க்குள் எழுத முடியும். ஒரு SessionStart அல்லது UserPromptSubmit hook எதை stdout-க்கு அனுப்புகிறதோ, அது உரையாடலில் சேர்க்கப்படும். வெளியிலிருந்து, அதாவது issue tracker அல்லது log file-லிருந்து text-ஐ pipe செய்யும் ஒரு hook, நம்பகத்தன்மையற்ற text-ஐ நீங்கள் நீங்களே தட்டச்சு செய்தது போல model-க்கு வழங்குகிறது. அந்த stdout-ஐ வெளியீடாகக் கருதாமல், உள்ளீடாகக் கருதவும்.
அதிகாரமே (Privilege) உண்மையான கட்டுப்பாடு. Agent-ஐ அதற்குத் தேவையான sudo விதிகள் மட்டுமே கொண்ட, பிரத்யேகமான, குறைந்த அதிகாரம் கொண்ட பயனராக (unprivileged user) இயக்கவும். ஒரு PreToolUse deny இருப்பது நல்லது, ஆனால் அது வடிவமைப்பிலேயே சிறந்த முயற்சியாகவே (best effort) இருக்கும்: if filter-ஐப் பற்றியும் reference இதையே கூறுகிறது; உங்களுக்குக் கடுமையான தடை (hard deny) தேவைப்படும்போது permission system-ஐப் பயன்படுத்த அறிவுறுத்துகிறது. Permission விதிகள் மற்றும் எந்தக் கணக்கின் கீழ் process இயங்குகிறதோ, அதுவே அழுத்தமான சூழலிலும் நிலைத்து நிற்கும் பகுதிகள்.
ஒவ்வொரு configuration-லும் ஒரு பண்பு மாறாமல் இருக்கும். PreToolUse hooks, ஒவ்வொரு permission mode-லும் permission-mode check-க்கு முன்பே இயங்கும்; எனவே, ஒரு hook deny-ஐத் திரும்ப அளித்தால், அது bypassPermissions-ன் கீழும் tool-ஐத் தடுக்கும். Hooks, permission விதிகள் அனுமதிப்பதை மேலும் இறுக்கமாக்க முடியுமே தவிர, அதைத் தளர்த்த முடியாது.
எனது hook ஏன் செயல்படவில்லை?
இதை வரிசையாகச் சரிபார்க்கவும். ஒவ்வொரு படியும் நீங்கள் காணும் அறிகுறியைக் குறிப்பிடுகிறது.
/hooks-ஐ இயக்கி, நீங்கள் எதிர்பார்த்த நிகழ்வின் கீழ் hook தோன்றுகிறதா என்று பார்க்கவும். மெனுவில் ஒரு hook இல்லை என்றால், settings கோப்பில் JSON syntax பிழை இருப்பதாக அர்த்தம். trailing commas மற்றும் comments அனுமதிக்கப்படாது, அல்லது கோப்பு மேலே உள்ள ஆறு இடங்களில் ஒன்றில் இல்லை என்று பொருள்.- Matcher-ஐ tool பெயருடன் துல்லியமாக ஒப்பிடவும். Matchers case sensitive என்பதால்,
"bash"என்பது ஒருபோதும்Bashtool-உடன் பொருந்தாது. - மேலே உள்ள உதாரணம் 1-ல் உள்ளது போல, sample input-ஐக் கொண்டு script-ஐ நீங்களே நேரடியாக இயக்கவும். நீங்கள் எதிர்பாராத exit code வருவது உங்கள் script-ல் உள்ள பிழை; இதை Claude Code ஒரு decision-ஆகக் கருதாமல், hook பிழையாகவே தெரிவிக்கும்.
jq: command not foundஎன்ற அறிவிப்பு வந்தால், அந்த machine-ல்jqஇல்லை என்று பொருள். உங்கள் சொந்த script-க்குcommand not foundவந்தால், path சரியாகக் கிடைக்கவில்லை என்று பொருள்; எனவே${CLAUDE_PROJECT_DIR}அல்லது absolute path-ஐப் பயன்படுத்தவும். script இயங்கவே இல்லை என்றால், அது executable நிலையில் இல்லை என்று அர்த்தம்.- hook சரியான JSON-ஐ வெளியிடுகிறது, ஆனால் எதுவும் நடக்கவில்லை. shell-form hook
sh -cவழியாக இயங்குகிறது. உங்கள் shell profile ஏதேனும் banner-ஐ அச்சிட்டால், அது உங்கள் JSON-க்கு முன்னால் சேர்க்கப்படும். Stdout இப்போது{-ல் தொடங்காது, எனவே Claude Code முழுவதையும் plain text-ஆகக் கருதி, முடிவை நிராகரிக்கும். exit 0 நிலையில், debug log-ஐத் தவிர வேறு எங்கும் தகவல் இருக்காது. உங்கள் profile-ல் உள்ள ஏதேனும்echo-ஐ interactive shells-ல் மட்டும் இயங்குமாறு மாற்றவும். - இன்னும் சிக்கல் நீடித்தால்:
claude --debug-file /tmp/claude.logமூலம் session-ஐத் தொடங்கி, இரண்டாவது terminal-ல்tail -f /tmp/claude.log-ஐ இயக்கவும். எந்தெந்த hooks பொருந்தின, ஒவ்வொன்றும் என்ன exit code-ஐத் தந்தன, மற்றும் அவை stdout/stderr-ல் என்ன எழுதின என்பதை debug log பதிவு செய்யும்.
FAQ
Claude Code hook மற்றும் CLAUDE.md instruction ஆகியவற்றிற்கு இடையே உள்ள வேறுபாடு என்ன?
CLAUDE.md instruction என்பது model-ன் context-ல் உள்ள உரையாகும். எனவே, இது உரையாடல் மற்றும் தற்போதைய கோரிக்கையுடன் கவனத்தைப் பெற போட்டியிடுகிறது; model இதை மற்றவற்றுடன் ஒப்பிட்டு எடைபோட முடியும். Hook என்பது Claude Code அதன் lifecycle-ல் ஒரு குறிப்பிட்ட புள்ளியில் இயக்கும் shell command ஆகும். எனவே, model என்ன முடிவெடுத்தாலும், அந்த நிகழ்வு நடக்கும்போதெல்லாம் இது இயங்கும். ஒரு விருப்பத்தை (preference) தெரிவிக்க instruction-ஐப் பயன்படுத்தவும். எப்போதும் நடக்க வேண்டிய ஒரு படி அல்லது ஒருபோதும் நடக்கக்கூடாத ஒரு செயலுக்கு hook-ஐப் பயன்படுத்தவும்.
ஒரு குறிப்பிட்ட shell command-ஐ Claude Code இயக்குவதைத் தடுப்பது எப்படி?
PreToolUse hook-ஐ ஒரு Bash matcher உடன் பதிவு செய்யவும். இது .tool_input.command-லிருந்து command-ஐப் படித்து, stderr-ல் ஒரு காரணத்தை எழுதி, 2 என்ற exit code-ஐத் தரும். Claude Code அந்த அழைப்பை ரத்து செய்து, உங்கள் காரணத்தை model-க்குக் காட்டும். இது permission-mode சரிபார்ப்பிற்கு முன்பே நடப்பதால், bypassPermissions mode-ல் கூட இந்தத் தடை செல்லும். ஒரு command string-ஐ pattern matching செய்வது ஒரு பாதுகாப்பு அரணே தவிர, அது ஒரு முழுமையான security boundary அல்ல. ஏனெனில், அதே command-ஐ pattern கண்டறிய முடியாத வடிவத்தில் எழுத முடியும். எனவே, இதை permission rules மற்றும் unprivileged account மூலம் உறுதிப்படுத்தவும்.
எனது hook சரியான JSON-ஐ வெளியிடுகிறது, ஆனால் எதுவும் நடக்கவில்லை. ஏன்?
இதற்கு மிக முக்கியமான காரணம் உங்கள் shell profile ஆகும். args field இல்லாத ஒரு hook, sh -c வழியாக இயங்குகிறது. சில profiles ஒவ்வொரு shell-லும் ஒரு banner-ஐ அச்சிடும், இது உங்கள் JSON-க்கு முன்னால் stdout-ல் பதிவாகும். வெளியீடு {-ல் தொடங்காததால், Claude Code அதை வெறும் உரையாகக் கருதி முடிவைப் புறக்கணிக்கும். exit 0 நிலையில், transcript-ல் எதுவும் காட்டப்படாது. உங்கள் profile-ல் உள்ள ஏதேனும் echo-ஐ interactive-shell test மூலம் பாதுகாக்கவும், பின்னர் claude --debug-file /tmp/claude.log-லிருந்து debug log-ஐப் படித்து தீர்வை உறுதிப்படுத்தவும்.
பகிரப்பட்ட server-ல் Claude Code hooks-ஐ இயக்குவது பாதுகாப்பானதா?
Hooks, Claude Code-ஐத் தொடங்கிய பயனரின் உரிமைகளுடன் (file permissions) இயங்கும். எனவே, அந்த account-ஆல் என்ன செய்ய முடியுமோ, அதை hook-ஆலும் செய்ய முடியும். இரண்டு பழக்கங்கள் பெரும்பாலான அபாயங்களைக் குறைக்கும்: agent-ஐ ஒரு பிரத்யேக unprivileged account-ல், குறுகிய sudo கொள்கையுடன் இயக்கவும். மேலும், workspace trust dialog-ஐ ஏற்றுக்கொள்வதற்கு முன், எந்தவொரு repository-ன் hooks பகுதியையும் படிக்கவும். ஏனெனில் project hooks, .claude/settings.json-க்குள் வருகின்றன. எதையும் இயக்கக்கூடாது என விரும்பினால், உங்கள் settings file-ல் "disableAllHooks": true-ஐ அமைக்கவும்.