Snabb sammanfattning: Claude Code-krokar är automationsskript som körs vid specifika livscykeltillfällen under AI-kodningssessioner, vilket gör det möjligt för utvecklare att köra anpassade kommandon, validera åtgärder, formatera kod, skicka meddelanden och upprätthålla projektregler. Dessa krokar integreras med Claudes arbetsflöde genom händelser som SessionStart, PreToolUse och PostToolUse, och stöder kommandobaserade, HTTP-baserade och promptbaserade exekveringsmönster med konfigurerbara tidsgränser och beteende för avslutningskoder.
Claude Codes kroksystem transformerar AI-kodningsassistenten från ett hjälpsamt verktyg till en fullt automatiserad utvecklingsmiljö. De flesta utvecklare inser inte omfattningen av kontroll som är tillgänglig genom krokar.
Här är poängen – krokar handlar inte bara om att köra skript efter filändringar. De tillhandahåller avlyssningspunkter genom hela Claude beslutsprocess. Innan den exekverar ett kommando. Efter att ett verktygsanrop misslyckas. När den behöver tillstånd. Även innan användarprompter bearbetas.
Den här guiden täcker allt som den officiella dokumentationen tillhandahåller, plus praktiska mönster som communitydiskussioner avslöjar faktiskt fungerar i produktionsmiljöer.
Vad Claude Code-krokar faktiskt gör
Enligt den officiella Claude Code-dokumentationen är krokar användardefinierade skal-kommandon, HTTP-slutpunkter eller promptinjektioner som körs vid specifika punkter i Claude Codes livscykel. De tar emot strukturerad JSON-input via stdin och kontrollerar arbetsflödet genom avslutningskoder eller HTTP-svar.
Automationen går djupare än vad de flesta guider antyder. Krokar kan blockera verktygsanrop helt, injicera ytterligare kontext i Claudes resonemang, utlösa externa tjänster och upprätthålla valideringsregler som Claude måste respektera.
Tre kärnkroktyper finns:
- Kommandokrokar: Skal-skript som kommunicerar via stdout, stderr och avslutningskoder
- HTTP-krokar: Fjärrslutpunkter som tar emot POST-anrop och returnerar JSON-svar
- Promptkrokar: Dynamiska instruktioner som injiceras i Claude kontext vid specifika händelser
Varje typ tjänar olika automationsmönster. Kommandokrokar hanterar lokal validering och formatering. HTTP-krokar integrerar med externa tjänster och databaser. Promptkrokar modifierar Claude beteende utan externa processer.
Krok-livscykel och händelsesystem
Den officiella dokumentationen definierar flera krok-händelser (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification och andra) som avfyras under Claude Codes exekveringsflöde. Att förstå när varje avfyras avgör vilken automation som blir möjlig.
| Händelse | När den avfyras | Kan blockera |
|---|---|---|
| SessionStart | När en session börjar eller återupptas | Nej |
| UserPromptSubmit | När du skickar en prompt, innan Claude bearbetar den | Ja |
| PreToolUse | Innan ett verktygsanrop exekveras | Ja |
| PermissionRequest | När en tillstånds-dialogruta visas | Ja |
| PostToolUse | Efter att ett verktygsanrop lyckats | Nej |
| PostToolUseFailure | Efter att ett verktygsanrop misslyckats | Nej |
| Notification | När Claude Code skickar en avisering | Nej |
| SubmitMessage | När Claude skickar ett meddelande till användaren | Nej |
| ContextCompaction | När kontextfönstret närmar sig gränserna | Nej |
Blocket möjligheten är viktigast. PreToolUse-krokar kan förhindra farliga operationer innan de exekveras. Avslutningskod 1 blockerar åtgärden. Avslutningskod 0 tillåter den. Avslutningskod 2 får Claude att ompröva.
Men vänta. PostToolUse-krokar kan inte ångra åtgärder eftersom verktyget redan har exekverats. Denna begränsning formar hur valideringslogik struktureras. Kritiska kontroller hör hemma i PreToolUse. Städning och formatering hör hemma i PostToolUse.
Bläddra bland AI-verktygsförmåner när du ställer in Claude Code
Om du arbetar med Claude Code-krokar kanske du också väljer andra AI-verktyg runt ditt arbetsflöde. Get AI Perks samlar startup-krediter och mjukvarurabatter för AI- och molnverktyg på ett ställe. Plattformen innehåller över 200 erbjudanden, med förmåns-villkor och ansökningsvägledning för varje.
Letar du efter förmåner för Claude eller andra AI-verktyg?
Kolla Get AI Perks för att:
- bläddra bland erbjudanden för Claude och andra AI-verktyg
- jämföra förmåns-villkor innan du ansöker
- hitta rabatter för startups över hela din verktygskedja
👉 Besök Get AI Perks för att utforska aktuella AI-mjukvaruförmåner.
Konfiguration och filstruktur
Krokar definieras i filen .claude/settings.json inom ett projekt. Konfigurationsschemat stöder globala krokar och verktygsspecifika matchare som filtrerar när krokar körs.
Grundläggande kommandokrokstruktur:
| { “hooks”: [ { “event”: “PostToolUse”, “command”: “prettier –write”, “args”: [“${file}”] } ] } |
Variabeln ${file} expanderar till den faktiska filvägen från verktygets input. Enligt den officiella dokumentationen stöder krokar dessa variabel-expansioner i kommandot och args-fälten.
Krok-plats-hierarki
Claude Code kontrollerar flera platser för krok-definitioner, med en tydlig prioritetsordning:
- Projektnivå: .claude/settings.json i den aktuella arbetsytan
- Användarnivå: ~/.claude/settings.json för alla sessioner
- Plugin-levererad: Krokar som bundlas med installerade plugins
Projektkrokar åsidosätter användarkrokar för samma händelse. Detta möjliggör projektspecifika formateringsregler samtidigt som globala meddelandehållare bibehålls.
Matcharmönster för selektiv exekvering
Matcharsystemet filtrerar krokar till specifika verktyg eller villkor. Utan matchare avfyras krokar för varje förekomst av deras händelse.
| { “hooks”: [ { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “src/**/*.ts” }, “command”: “./scripts/validate-typescript.sh” } ] } |
Fältet pathPattern accepterar glob-syntax. Fältet toolName matchar mot Claude inbyggda verktyg som edit_file, execute_command, read_file och create_directory.
Communitydiskussioner avslöjar att matcharkombinationer fungerar med OCH-logik. Alla angivna matchare måste matcha för att kroken ska exekveras.
Kommandokrokar: Skal-skriptintegration
Kommandokrokar exekverar skal-kommandon eller skript med strukturerad JSON-input. De representerar den vanligaste kroktypen för lokal automation.
Den officiella dokumentationen anger att kommandokrokar tar emot JSON via stdin med denna struktur:
| { “event”: “PreToolUse”, “toolName”: “edit_file”, “toolInput”: { “path”: “src/app.ts”, “content”: “…” }, “sessionId”: “abc123”, “turnId”: “turn-456” }Skript parsar denna input för att fatta beslut. En Python-valideringskrok kan se ut så här:#!/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(“Kan inte redigera skyddade filer”, file=sys.stderr) sys.exit(1) sys.exit(0) |
Avslutningskod 0 tillåter åtgärden. Avslutningskod 1 blockerar den och visar stderr-meddelandet för Claude. Avslutningskod 2 utlöser speciellt beteende beroende på händelsen.
Avslutningskod 2-beteende
Enligt den officiella dokumentationen för krokreferens har avslutningskod 2 händelsespecifik betydelse (PreToolUse: blockerar och uppmanar till omprövning; UserPromptSubmit: tillhandahåller kontext utan att blockera; PermissionRequest: blockerar tillstånd):
- PreToolUse: Blockerar verktyget och uppmanar Claude att ompröva med stderr-meddelandet som kontext
- UserPromptSubmit: Tillhandahåller stderr-utdata som ytterligare kontext utan att blockera
- PermissionRequest: Blockerar tillståndsbeviljandet
Detta skapar en mellangrund mellan hård blockering och tillåtande. Claude får feedback om varför åtgärden kan vara problematisk och kan anpassa sitt tillvägagångssätt.
Asynkrona kommandokrokar
Flaggan async: true kör krokar i bakgrunden utan att blockera Claude arbetsflöde. Detta är viktigt för långsamma operationer som distributionsmeddelanden eller insamling av mätvärden.
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “execute_command” }, “command”: “./scripts/log-to-analytics.sh”, “async”: true, “timeout”: 30 } |
När en asynkron krok avfyras startar Claude Code processen och fortsätter omedelbart. Fältet timeout ställer in den maximala exekveringstiden i sekunder. Om det inte anges använder asynkrona krokar en standardtidsgräns på 10 minuter.
Verklighet: asynkrona krokar kan inte blockera operationer eftersom de körs efter att Claude har fortskridit. De fungerar för loggning, meddelanden och rensning – inte validering.
HTTP-krokar: Integration med externa tjänster
HTTP-krokar skickar JSON-payloads till fjärrslutpunkter och tolkar svar för beslutsstyrning. De möjliggör integration med valideringstjänster, databaser och tredjepartsverktyg.
Grundläggande HTTP-krok-konfiguration:
| { “event”: “PreToolUse”, “url”: “api.example.com/validate”, “headers”: { “Authorization”: “Bearer ${API_TOKEN}” }, “timeout”: 5 } |
Payloadstrukturen matchar kommandokrokens input men anländer som HTTP POST-kropp. Svaret bestämmer Claude nästa steg.
Hantering av HTTP-svar
Enligt den officiella dokumentationen tolkar HTTP-krokar svar baserat på statuskod och kroppsinnehåll:
| Statuskod | Effekt | Meddelandekälla |
|---|---|---|
| 200 | Tillåt operation | Svarskropp (valfritt) |
| 400 | Blockera operation | Svarskropp visad för Claude |
| 500 | Krokfel, tillåt operation | Loggad men inte visad för Claude |
| Annat | Tillåt operation | Krokfel blockerar inte arbetsflödet |
Svarskroppen kan innehålla ett meddelandefält som Claude ser som kontext. Detta gör det möjligt för valideringstjänster att förklara varför en operation blockerades.
Interpolering av miljövariabler
HTTP-krokar stöder ${VAR}-syntax i url, headers och andra strängfält. Variabler expanderar från miljön där Claude Code körs.
Enligt den officiella MCP-dokumentationen inkluderar miljövariabel-expansion en standard fallback-syntax: ${VAR:-default} expanderar till VAR om den är satt, annars används standardvärdet.
Säkerhetsbegränsning: Enligt GitHub-fråga #28044 kan HTTP-krokar endast komma åt miljövariabler som explicit listas i fältet allowedEnvVars i konfigurationen. Detta förhindrar oavsiktlig exponering av autentiseringsuppgifter.
Promptkrokar: Kontextinjektion
Promptkrokar injicerar dynamiska instruktioner i Claude kontext vid specifika händelser. De modifierar beteendet utan externa processer eller API-anrop.
| { “event”: “SessionStart”, “prompt”: “Du arbetar med ett TypeScript-projekt. Använd alltid strikta null-kontroller och föredra async/await framför promises.” } |
Den injicerade texten blir en del av Claude systeminstruktioner för den sessionen. Promptkrokar kan också använda mallvariabler som expanderar baserat på händelsedata.
Dynamisk promptgenerering
Enligt den officiella dokumentationen stöder promptkrokar kommandofält som genererar dynamiska prompter:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “./scripts/generate-context-summary.sh” } |
Kommandot tar emot standard JSON-input via stdin och skickar ut prompttexten till stdout. Detta möjliggör kontextmedveten instruktionsgenerering baserad på projektets tillstånd.
Agentbaserade krokar
Agentkrokar specificerar en underagent som hanterar händelsen istället för direkt promptinjektion. Underagenten får kontext om händelsen och kan utföra flerstegsresonemang.
| { “event”: “PostToolUseFailure”, “agent”: “debugger”, “agentPrompt”: “Ett verktygsanrop misslyckades. Analysera felet och föreslå lösningar.” } |
Den namngivna underagenten måste definieras i projektkonfigurationen. Agentkrokar möjliggör komplex beslutlogik som enkel promptinjektion inte kan ge.
Praktiska krok-mönster
Communitydiskussioner och officiella exempel avslöjar specifika automationsmönster som fungerar tillförlitligt i produktion.
Automatisk formatering av kod efter ändringar
Det vanligaste mönstret formaterar kod automatiskt efter att Claude har ändrat filer:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/*.{js,ts,jsx,tsx}” }, “command”: “prettier”, “args”: [“–write”, “${toolInput.path}”] } |
Variabeln ${toolInput.path} expanderar till sökvägen för den ändrade filen. PostToolUse säkerställer att formatering sker efter lyckade ändringar men blockerar inte Claude arbetsflöde.
Blockera modifieringar av skyddade filer
PreToolUse-krokar upprätthåller regler för filskydd:
| { “event”: “PreToolUse”, “matcher”: { “toolName”: “edit_file” }, “command”: “./scripts/check-protected.sh” } |
Skriptet validerar målsökvägen mot skyddade mönster och avslutas med kod 1 för att blockera förbjudna ändringar.
Få aviseringar när Claude behöver input
Enligt den officiella arbetsflödesguiden kan Notification-krokar utlösa skrivbordsaviseringar eller skicka meddelanden till externa tjänster:
| { “event”: “Notification”, “command”: “osascript”, “args”: [“-e”, “display notification \”${message}\” with title \”Claude Code\””] } |
Detta avfyras närhelst Claude Code skickar en avisering, inklusive när den väntar på användarinput eller efter slutförande av en uppgift.
Återinjicera kontext efter kompaktering
ContextCompaction-krokar återställer viktig kontext när konversationsfönstret fylls:
| { “event”: “ContextCompaction”, “type”: “prompt”, “command”: “cat .claude/critical-context.md” } |
Kommandots utdata injiceras tillbaka i Claude kontext efter att kompaktering har tagit bort äldre meddelanden. Detta förhindrar förlust av kritisk projektspecifik information.
Granska konfigurationsändringar
Spåra när Claude ändrar konfigurationsfiler:
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “edit_file”, “pathPattern”: “**/{package.json,.env,*.config.*}” }, “command”: “git”, “args”: [“add”, “${toolInput.path}”], “async”: true } |
Asynkron exekvering förhindrar att Claude blockeras medan git-operationer slutförs. Detta skapar en granskningsspår av konfigurationsändringar utan manuell staging.
JSON-utdata och beslutsstyrning
Kommandokrokar kan skicka ut strukturerad JSON för att ge detaljerad feedback bortom enkla avslutningskoder. Enligt den officiella referensen möjliggör JSON-utdata svar med flera fält som Claude tolkar för beslutsfattande.
| { “allowed”: false, “message”: “Denna fil är skyddad av teamets policy”, “suggestion”: “Skapa en ny fil i stället i src/features/” } |
Fältet allowed styr om operationen fortskrider. Meddelandet visas för Claude som kontext. Fältet suggestion tillhandahåller alternativa tillvägagångssätt.
För att krokar ska kunna skicka ut JSON måste de:
- Skriva giltig JSON till stdout
- Avslutas med kod 0 (för tillåtet) eller 1 (för blockerat)
- Inkludera minst det booleska fältet allowed
Claude Code parsar JSON och använder det för att förbättra feedbackloopen. Avslutningskoder bestämmer fortfarande det primära beslutet, men JSON ger rikare kontext.
Referens för krok-input-fält
Alla krokar tar emot ett JSON-objekt via stdin med gemensamma fält plus händelsespecifik data. Att förstå det kompletta schemat möjliggör mer sofistikerad krok-logik.
Gemensamma inputfält
Alla krokar tar emot dessa basfält:
- event: Namnet på krok-händelsen (t.ex. "PreToolUse")
- sessionId: Unik identifierare för den aktuella Claude-sessionen
- turnId: Identifierare för den aktuella konversationssvängen
- timestamp: ISO 8601-tidsstämpel när händelsen avfyrades
Verktygshändelsefält
PreToolUse, PostToolUse och PostToolUseFailure-händelser inkluderar:
- toolName: Namnet på verktyget som anropas (edit_file, execute_command, etc.)
- toolInput: Objekt som innehåller verktygets input-parametrar
- toolResponse: Verktygsoutputdata (endast PostToolUse)
- error: Feldetaljer inklusive meddelande och kod (endast PostToolUseFailure)
Strukturen för toolInput varierar beroende på verktyg. För edit_file innehåller den path och content. För execute_command innehåller den command och args.
Tillståndshändelsefält
PermissionRequest-händelser inkluderar:
- permissionType: Typ av begärt tillstånd (file_write, command_execute, etc.)
- requestedAction: Specifik åtgärd som kräver tillstånd
- resourcePath: Filsökväg eller resursidentifierare som påverkas
MCP-verktygskrokar
Enligt den officiella krok-referensen kan krokar matcha mot Model Context Protocol (MCP) verktyg med hjälp av matcharfältet mcpTool. Detta möjliggör krok-exekvering när Claude använder externa verktyg som tillhandahålls av MCP-servrar.
| { “event”: “PreToolUse”, “matcher”: { “mcpTool”: “database/query” }, “command”: “./scripts/validate-sql.sh” } |
Värdet mcpTool matchar mot verktygets namn i formatet server-namn/verktygs-namn. Detta möjliggör valideringslogik för databasfrågor, API-anrop eller andra externa operationer.
GitHub-funktionförfrågningar indikerar ett växande intresse för djupare MCP-integration, inklusive krokar som kan inspektera MCP-servermeddelanden och svara på externa händelser.
Säkerhetsöverväganden
Krokar exekveras med samma behörigheter som Claude Code självt. Detta skapar säkerhetsimplikationer för miljöer med flera användare och delade konfigurationer.
Sandlåda för kommandokörning
Enligt GitHub-fråga #28044 routas HTTP-krokar genom en sandlådeproxyserver som begränsar nätverksåtkomst och filtrerar miljövariabler. Kommandokrokar har inga sådana begränsningar – de körs med full skalåtkomst.
Dokumentationen rekommenderar dessa metoder:
- Lagra aldrig autentiseringsuppgifter i krok-kommandon
- Använd miljövariabler för känsliga data
- Validera all input från ${…} expansioner
- Implementera tidsgräns för externa tjänster
- Använd asynkrona krokar för icke-kritiska operationer för att förhindra blockering vid fel
Isolering av krok-exekvering
Användarnivå-krokar i ~/.claude/settings.json gäller för alla projekt. Detta skapar risker vid arbete över olika förtroendenivåer. Projektnivå-krokar åsidosätter användarkrokar men kan inte helt inaktivera dem.
Menyn /hooks i Claude Code visar alla aktiva krokar för den aktuella sessionen. Att granska den här listan innan man arbetar med känsliga projekt hjälper till att identifiera potentiella säkerhetsrisker.
Felsökning och problemhantering
Krokfel syns inte alltid tydligt i Claude konversation. Den officiella dokumentationen ger flera felsökningsmetoder.
Krok-exekveringsloggar
Claude Code loggar krok-exekvering till sessionens debug-output. Enligt felsökningsguiden avslöjar aktivering av debug-loggning:
- Vilka krokar som matchade för varje händelse
- JSON-input som skickades till varje krok
- Stdout- och stderr-utdata från krok-processer
- Avslutningskoder och exekveringstid
- HTTP-svar-koder och kroppar för HTTP-krokar
Aktivera debug-loggning genom att sätta CLAUDE_DEBUG=1 i miljön innan du startar Claude Code.
Testa krokar oberoende
Kommandokrokar kan testas utanför Claude Code genom att manuellt konstruera JSON-input:
| echo ‘{“event”:”PreToolUse”,”toolName”:”edit_file”,”toolInput”:{“path”:”test.txt”}}’ | ./scripts/my-hook.sh |
Detta validerar krok-logik utan att utlösa faktiska Claude-operationer. Avslutningskoden och stdout/stderr-utdata bör matcha förväntat beteende.
Vanliga krok-fel
Communitydiskussioner identifierar dessa frekventa problem:
- Tidsgränsfel: Standard 10-minuters tidsgräns för kort för långsamma operationer – öka med timeout-fältet
- Fel vid sökvägs-expansion: Variabler som ${file} är odfinierade för händelser som inte inkluderar filsökvägskontext
- Behörighetsfel: Krok-skript saknar exekverbara behörigheter – kör chmod +x script.sh
- Fel vid JSON-parsning: Felaktigt formaterad JSON-utdata från krokar – validera med jq innan du returnerar
- Otillgängliga miljövariabler: Variabler som inte propageras till krok-processen – kontrollera Claude Codes miljö
Krok-prestanda-implikationer
Synkrona krokar blockerar Claude arbetsflöde tills de slutförs. Standardtidsgränsen på 10 minuter förhindrar oändliga hängningar, men även korta fördröjningar ackumuleras över flera operationer.
Praktiker rapporterar att enkla valideringskrokar har minimal prestandapåverkan. Filformateringskrokar orsakar märkbar men acceptabel prestandapåverkan. Externa API-anrop kan skapa friktion i arbetsflödet. Tunga beräkningsoperationer drar nytta av asynkron exekvering.
Krok-batchning
Flera krokar kan matcha samma händelse. Enligt referensdokumentationen exekveras krokar sekventiellt i definitionsordning. Om någon krok blockerar operationen, exekveras inte de återstående krokarna.
Detta är viktigt för prestanda. Fem synkrona krokar på 200 ms vardera lägger till en sekund per händelse. Att kombinera relaterade valideringar till en enda krok minskar overhead.
Avancerade mönster
Bortom grundläggande automation möjliggör krokar sofistikerad anpassning av arbetsflödet.
Tillståndskänsliga krok-kedjor
Krokar kan upprätthålla tillstånd mellan exekveringar med hjälp av filer eller databaser. En PostToolUse-krok kan registrera lyckade operationer som en PreToolUse-krok senare validerar mot:
| #!/bin/bash # Registrera lyckade ändringar echo “${toolInput.path}” >> .claude/edit-history.txt |
En kompletterande PreToolUse-krok kan kontrollera denna historik för att förhindra redundanta operationer eller upprätthålla ordningsbegränsningar.
Villkorlig aktivering av krokar
Miljövariabler styr krok-beteendet vid körning. Att sätta CLAUDE_SKIP_HOOKS=1 inaktiverar krokar för nödsituationer.
Krokar själva kan kontrollera miljöflaggor:
| #!/bin/bash if [ “$STRICT_MODE” = “1” ]; then # Tillämpa strikt validering exit 1 fi exit 0 |
Detta möjliggör beteende i utvecklingsläge kontra produktionsläge utan konfigurationsändringar.
Flerstegsvalidering
PreToolUse-krokar kan implementera flerdelad validering där avslutningskod 2 tillåter Claude att fortsätta med varningar:
- Hårda fel (avslutning 1): Blockera farliga operationer
- Mjuka varningar (avslutning 2): Varna Claude att ompröva
- Passera med kontext (avslutning 0 + JSON): Tillhandahåll ytterligare information
Detta skapar ett valideringsspektrum som är mer nyanserat än binär tillåt/neka.
Integration med CI/CD
Enligt den officiella dokumentationen för plattforms-integration körs Claude Code i CI/CD-miljöer för automatiserad kodgranskning och ärendehantering. Krokar utökar denna automation.
GitHub Actions-arbetsflöden kan definiera krokar som upprätthåller teampolicyer under automatiserade sessioner:
| – name: Kör Claude Code med strikta krokar env: STRICT_MODE: 1 run: | claude “Granska den här PR:en och föreslå förbättringar” |
Flaggan STRICT_MODE aktiverar villkorlig valideringslogik i krok-skript. Detta säkerställer att automatiserade sessioner följer striktare regler än interaktiv utveckling.
Generering av granskningsspår
PostToolUse-krokar i CI-miljöer skapar detaljerade granskningsloggar över alla Claude-operationer:
| { “event”: “PostToolUse”, “command”: “./scripts/log-to-database.sh”, “async”: true } |
Bakgrundsloggning påverkar inte prestanda men ger fullständig operationshistorik för regelefterlevnad och felsökning.
Menyn /hooks
Claude Code tillhandahåller kommandot /hooks som visar alla aktiva krokar för den aktuella sessionen. Enligt den officiella dokumentationen visar denna meny:
- Krok-händelsetyp
- Matcharmönster
- Kommando eller URL-slutpunkt
- Om kroken körs asynkront
- Konfigurationskälla (projekt, användare eller plugin)
Att välja en krok visar dess fullständiga konfiguration och tillåter tillfällig inaktivering för den aktuella sessionen.
Inaktivera eller ta bort krokar
Krokar kan inaktiveras utan att ta bort konfigurationen genom att lägga till "enabled": false i krok-definitionen. Detta bevarar konfigurationen samtidigt som exekvering förhindras.
För att permanent ta bort en krok, ta bort dess post från lämplig settings.json-fil. Ändringar träder i kraft vid nästa sessionsomstart eller när du kör /reload.
Krokar i färdigheter och agenter
Enligt den officiella dokumentationen gäller krokar som definieras inom färdighets- eller underagentkonfigurationer endast när den färdigheten eller agenten exekveras. Detta möjliggör specialiserad automation för specifika arbetsflöden.
En felsökningsunderagent kan inkludera krokar som loggar alla verktygsanrop:
| { “name”: “debugger”, “hooks”: [ { “event”: “PostToolUse”, “command”: “./scripts/log-debug.sh”, “async”: true } ] } |
Dessa krokar avfyras endast under debugger-agent-sessioner, inte under normal Claude Code-drift.
Referera skript med sökväg
Krok-kommandon stöder både relativa och absoluta sökvägar. Relativa sökvägar löses från projektets rot där Claude Code körs.
Bästa metoder från communitydiskussioner:
- Lagra krok-skript i katalogen .claude/hooks/
- Använd beskrivande namn: validate-typescript.sh inte hook1.sh
- Gör skripten exekverbara: chmod +x .claude/hooks/*.sh
- Inkludera shebang-rad: #!/usr/bin/env bash eller #!/usr/bin/env python3
- Lägg till felhantering med set -e i bash-skript
Framtida krok-funktioner
GitHub-funktionförfrågningar avslöjar planerade och efterfrågade krok-förbättringar:
- Inline skript-krokar: Definiera krok-logik direkt i settings.json utan externa filer
- MCP-verktygs-integration: Anropa MCP-server-verktyg från krokar istället för skal-kommandon
- Samarbete mellan flera agenter: Krokar som samordnar mellan Claude-instanser på olika maskiner
- Förbättrad typning: TypeScript-typer för krok-input/output-scheman
Enligt GitHub-fråga #4274 syftar begäran om integrerade krok-typer (MCP-verktyg, inline-skript, API-anrop) till att förenkla konfigurationen och förbättra utvecklarupplevelsen.
Vanliga frågor och svar
Kan krokar förhindra Claude från att köra farliga kommandon?
Ja. PreToolUse-krokar kan blockera all verktygsanrop genom att avslutas med kod 1. Detta inkluderar filändringar, kommandokörning och MCP-verktygsanrop. Kroken tar emot hela verktygets input och kan validera mot alla kriterier innan operationen tillåts.
Hur felsöker jag en krok som inte fungerar?
Aktivera debug-loggning med CLAUDE_DEBUG=1 innan du startar Claude Code. Kontrollera sessionsloggarna för krok-exekveringsdetaljer inklusive vilka krokar som matchade, JSON-input som skickades, stdout/stderr-utdata och avslutningskoder. Testa krokar oberoende genom att skicka sample JSON till krok-skriptet.
Fungerar krokar med alla Claude Code-plattformar?
Krokar fungerar i CLI, skrivbordsappen och VS Code-tillägget. Enligt den officiella dokumentationen körs krokar där Claude Code körs med åtkomst till filsystemet. Webb-baserade Claude och mobilappar stöder inte krokar på grund av sandlådebegränsningar.
Kan krokar modifiera Claude svar eller beteende?
Promptkrokar injicerar instruktioner som påverkar Claude beteende. Agentkrokar delegerar händelsehantering till specialiserade underagenter. Krokar kan dock inte direkt modifiera Claude genererade text eller resonemangsprocess – de arbetar genom att tillhandahålla kontext och blockera operationer.
Vad är skillnaden mellan asynkrona och synkrona krokar?
Synkrona krokar blockerar Claude arbetsflöde tills de slutförs eller timeout. Asynkrona krokar körs i bakgrunden utan att blockera. Synkron krokar kan förhindra operationer genom avslutningskoder. Asynkrona krokar kan inte blockera eftersom Claude fortsätter innan kroken slutförs. Använd async för loggning och aviseringar, sync för validering.
Hur delar jag krokar med ett team?
Spara filen .claude/settings.json i versionskontrollen. Projektnivå-krokar gäller för alla teammedlemmar som klonar förvaringen. För organisationstäckande policyer kan team underhålla en delad användarnivå-inställningsfil som medlemmar kopierar till ~/.claude/settings.json.
Kan HTTP-krokar anropa interna API:er bakom brandväggar?
Ja, om Claude Code körs i en miljö med nätverksåtkomst till dessa API:er. HTTP-krokar gör standard POST-anrop från maskinen som kör Claude Code. Företagsbrandväggar och VPN gäller normalt. Sandlådeproxyn som nämns i dokumentationen styr exponeringen av miljövariabler, inte nätverksdirigering.
Ökar krokar Claude Codes token-användning?
Promptkrokar injicerar text i Claude kontext, vilket förbrukar tokens. Kommando- och HTTP-krokar påverkar inte token-användningen direkt, men deras utdata (felmeddelanden, förslag) blir en del av konversationskontexten. Avslutningskod 2 med förklarande meddelanden tillför mer kontext än avslutningskod 1 med enkel blockering.
Slutsats
Claude Code-krokar transformerar AI-assistenten från ett kraftfullt verktyg till en fullt automatiserad utvecklingsplattform. Händelsesystemet tillhandahåller avlyssningspunkter genom Claude arbetsflöde – från sessionsinitiering till kontextkompaktering.
Kommandokrokar hanterar lokal validering och formatering. HTTP-krokar integrerar externa tjänster och databaser. Promptkrokar modifierar beteendet genom kontextinjektion. Tillsammans möjliggör dessa automationsmönster som upprätthåller teampolicyer, bibehåller kodkvalitet och integrerar med befintlig utvecklingsinfrastruktur.
Matcharsystemet filtrerar krokar till specifika verktyg och filsökvägsmönster. Avslutningskoder och JSON-utdata styr beslutsflödet. Asynkron exekvering förhindrar blockering vid långsamma operationer. Det kompletta konfigurationsschemat stöder allt från enkel automatisk formatering till komplex flerdelad validering.
Börja med enkla PostToolUse-krokar för kodformatering. Lägg till PreToolUse-validering när policyer uppstår. Experimentera med promptkrokar för beteendemodifiering. Bygg HTTP-integrationer för teamomfattande upprätthållande.
Kontrollera den officiella Claude Code-dokumentationen för den kompletta krok-referensen och det uppdaterade konfigurationsschemat när nya funktioner släpps.
