@rt-tools/agent-kit 0.8.3 → 0.9.1

package/assets/hooks/sql-guard.sh

@@ -16,6 +16,11 @@
 #   вопрос   — остальная запись: адресная правка и вставка, решение за владельцем;
 #   пропуск  — чтение.
 #
+# Каждый предмет разбора живёт своим помощником рядом: запрос из ввода — `sql-guard-request.sh`,
+# приведение команды к одному виду и нарезка на сегменты — `sql-guard-parse.sh`, адресат вместе
+# с правилами боевой базы — `sql-guard-target.sh`, признак записи, разрушительное, миграции и
+# адресация строк — `sql-guard-write.sh`. Здесь остаётся порядок: он зовёт их и решает.
+#
 # Боевое хранилище отдельно: его адреса и подключения перечисляет профиль дерева —
 #   RT_PROD_DSN          — образец адреса боевой базы: порт туннеля, хост, домен;
 #   RT_PROD_CONNECTIONS  — идентификаторы боевых подключений среды разработки;
@@ -53,174 +58,16 @@ for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../d
     [ -f "$profile" ] && . "$profile" 2>/dev/null
 done
 
-PROD_DSN="${RT_PROD_DSN:-}"
-
-sql=""
-context=""
-conn=""
-case "$tool" in
-    mcp__webstorm__execute_sql_query)
-        sql="$(printf '%s' "$input" | jq -r '.tool_input.queryText // empty' 2>/dev/null)"
-        conn="$(printf '%s' "$input" | jq -r '.tool_input.connectionId // empty' 2>/dev/null)"
-        context="запрос через подключение редактора"
-        ;;
-    # Терминал IDE исполняет ту же командную строку и кладёт её в то же поле, что и Bash:
-    # без этой ветки весь гард обходился сменой инструмента.
-    Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
-        cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
-        [ -z "$cmd" ] && exit 0
-
-        # Универсальный исполнитель зовёт ЛЮБОЙ инструмент редактора по имени, в том числе
-        # `execute_sql_query`, — и тогда в строке нет ни одного имени клиента, по которому
-        # гард себя включает. Сам инструмент закрыт в permissions.deny, но полагаться только
-        # на настройку нельзя: её снимут, а гард останется.
-        if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
-            case "$cmd" in
-                *execute_sql_query*)
-                    inner_sql="$(printf '%s' "$cmd" | perl -0ne '
-                        if (/--queryText(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
-                            print defined $1 ? $1 : (defined $2 ? $2 : $3);
-                        }
-                    ' 2>/dev/null)"
-                    inner_conn="$(printf '%s' "$cmd" | perl -0ne '
-                        if (/--connectionId(?:=|\s+)(?:"([^"]*)"|\x27([^\x27]*)\x27|(\S+))/) {
-                            print defined $1 ? $1 : (defined $2 ? $2 : $3);
-                        }
-                    ' 2>/dev/null)"
-                    ;;
-            esac
-            # Терминал, завёрнутый в тот же исполнитель: разбираем настоящую команду.
-            if [ -z "$inner_sql" ]; then
-                inner_cmd="$(printf '%s' "$cmd" | perl -0ne '
-                    if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
-                        print defined $1 ? $1 : (defined $2 ? $2 : $3);
-                    }
-                ' 2>/dev/null)"
-                [ -n "$inner_cmd" ] && cmd="$inner_cmd"
-            fi
-        fi
-
-        # Завёрнутый запрос разбирается как запрос из редактора, а не как команда оболочки:
-        # имени клиента в нём нет, зато есть подключение и текст SQL.
-        if [ -n "$inner_sql" ]; then
-            sql="$inner_sql"
-            conn="$inner_conn"
-            context="запрос через подключение редактора (обёртка исполнителя)"
-        else
-
-        # Команда, которая ничего никуда не доставляет, разбору не подлежит — даже если имя
-        # клиента стоит в её аргументах. `grep -rn "prisma db push" docs/` читает файлы, а не
-        # базу; раньше он получал deny, и обойти это можно было только испортив сам шаблон
-        # поиска. Тот же приём уже применён в dev-server-guard: решает ГОЛОВА команды, а не
-        # упоминание имени где-то внутри.
-        # Интересуют команды, которые доносят SQL до сервера. Клиент ищется КАК СЛОВО в любом
-        # месте команды, а не только в начале: удаление на бою выглядит как
-        # `ssh root@host "docker compose exec postgres psql -c '…'"` — при проверке одного
-        # лишь начала строки оно проходило мимо гарда целиком.
-        #
-        # Порядок здесь принципиален. Раньше выше стояла отсечка «команда начинается с git/gh»,
-        # снимавшая ложные срабатывания на тексте коммита, — и она же открывала обход: в
-        # `git log && psql … -c "DELETE …"` первое звено уносило с собой весь остальной SQL.
-        # Теперь сперва ищется клиент, и только его отсутствие завершает проверку.
-        printf '%s\n' "$cmd" | grep -qE \
-            '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
-            || exit 0
-
-        # Ложные срабатывания на описаниях снимаются иначе — вырезанием текста сообщений
-        # (`-m '…'`, `-am "…"`, `--message="…"`, `-F file`), а не отказом от проверки всей
-        # команды. В самом сообщении SQL не исполняется, но слова «delete» и «drop» в нём
-        # обычны: `git commit -am "chore(api): update prisma schema"` разбирался как
-        # UPDATE без WHERE, потому что шаблон требовал `-m` вплотную к дефису.
-        if command -v perl >/dev/null 2>&1; then
-            # `file` в альтернации быть не должно: под него попадал `--file=cleanup.sql`
-            # у psql, и признак «SQL приехал файлом» умирал раньше, чем его проверяли.
-            # Здесь только флаги, которые несут ТЕКСТ сообщения.
-            cmd="$(printf '%s' "$cmd" | perl -0pe '
-                s/(^|[^[:alnum:]])--?[a-zA-Z]*(m|message|body|title|body-file|F)(=|\s+)("([^"\\]|\\.)*"|\x27[^\x27]*\x27|[^\s;&|]+)/$1/gs
-            ' 2>/dev/null || printf '%s' "$cmd")"
-            # После вырезания сообщения клиента может уже не остаться — тогда это была
-            # git-команда, лишь упоминавшая psql в тексте.
-            printf '%s\n' "$cmd" | grep -qE \
-                '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
-                || exit 0
-        else
-            # Без perl вырезать текст сообщения нечем, и разбирать его как SQL нельзя:
-            # штатный коммит упирался бы в отказ. Доставки SQL в git-команде не бывает,
-            # поэтому здесь дешевле пропустить, чем ломать работу.
-            case "$cmd" in
-                git\ *|*/git\ *|gh\ *|*/gh\ *) exit 0 ;;
-            esac
-        fi
-
-        sql="$cmd"
-        context="команда psql/prisma"
-        fi
-        ;;
-    *) exit 0 ;;
-esac
-
-[ -z "$sql" ] && exit 0
-
-# Дальше разбираем без учёта регистра и переводов строк: `delete\n  from bookings`
-# — тот же запрос, что и в одну строку.
-#
-# Перевод строки при этом превращается в `;`, а не в пробел: в командной строке он РАЗДЕЛЯЕТ
-# вызовы ровно как `;`, и склейка его в пробел стирала границу между ними. Многострочная
-# команда становилась одним сегментом, доказательство чтения из первой строки покрывало
-# неразобранный вызов из второй, и запись на боевую базу проходила молча — тот же обход,
-# что чинили для `&&`, только набранный с новой строки.
-normalize() {
-    perl -0ne '
-        # Продолжение длинной команды обратным слешем — это одна строка, а не две: без
-        # склейки адрес из первой уезжал в соседний сегмент, где клиента уже нет.
-        s/\\\n/ /g;
-        # Перевод строки заменяется на `;` ТОЛЬКО вне кавычек. Внутри `-c "…"` он часть
-        # запроса: многострочный SELECT резался на сегменты, и штатное чтение боевой базы
-        # переставало быть доказанным.
-        my ($out, $quote, $esc) = ("", "", 0);
-        for my $ch (split //, $_) {
-            if ($esc) { $out .= $ch; $esc = 0; next; }
-            if ($ch eq "\\") { $out .= $ch; $esc = 1; next; }
-            if ($quote ne "") {
-                $out .= ($ch eq "\n" ? " " : $ch);
-                $quote = "" if $ch eq $quote;
-            } elsif ($ch eq q{"} || $ch eq q{'"'"'}) {
-                $quote = $ch; $out .= $ch;
-            } elsif ($ch eq "\n" || $ch eq ";") {
-                $out .= "\x01";              # граница независимых команд
-            } elsif ($ch eq "|") {
-                $out .= "\x02";              # граница звена конвейера
-            } elsif ($ch eq "&") {
-                $out .= "\x01";
-            } else {
-                $out .= $ch;
-            }
-        }
-        # Соседние маркеры схлопываются: `&&` и `||` дают по два подряд.
-        $out =~ s/\x01+/\x01/g;
-        $out =~ s/\x02\x01/\x01/g;
-        $out =~ s/\x01\x02/\x01/g;
-        # Незакрытая кавычка означает, что автомат разъехался: апостроф в комментарии
-        # (`# don'"'"'t forget`) оставлял состояние «внутри строки» до конца ввода, и все
-        # последующие переводы строк переставали разделять вызовы — сегментация выключалась
-        # одним символом. В таком случае честнее ничего не печатать: вызывающий разделит
-        # строки грубым способом, и лишнее дробление сыграет в пользу строгости.
-        print $out if $quote eq "";
-    ' 2>/dev/null
-}
-
-# Грубое разделение — запасной путь: все переводы строк становятся разделителями. Оно строже
-# точного (может разрезать многострочный запрос), поэтому годится и как фолбэк без perl,
-# и как ответ на неразобранную команду.
-flat_rough="$(printf '%s' "$sql" | perl -0pe 's/\\\n/ /g' 2>/dev/null | tr '\n;&' '\001\001\001' | tr '|' '\002' | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
-[ -z "$flat_rough" ] && flat_rough="$(printf '%s' "$sql" | tr '\n;&' '\001\001\001' | tr '|' '\002' | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
+# Помощники лежат рядом с гардом и уезжают в дерево вместе с ним. Нет хотя бы одного —
+# разбирать команду нечем, и гард пропускает ход: отказ в пользу работы здесь тот же, что и
+# при отсутствии `jq`.
+for helper in sql-guard-request.sh sql-guard-parse.sh sql-guard-target.sh sql-guard-write.sh; do
+    [ -f "$rt_hooks_dir/$helper" ] || exit 0
+    # shellcheck disable=SC1090
+    . "$rt_hooks_dir/$helper"
+done
 
-if command -v perl >/dev/null 2>&1; then
-    flat="$(printf '%s' "$sql" | normalize | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
-    [ -z "$flat" ] && flat="$flat_rough"
-else
-    flat="$flat_rough"
-fi
+PROD_DSN="${RT_PROD_DSN:-}"
 
 deny() {
     jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
@@ -234,440 +81,23 @@ ask() {
     exit 0
 }
 
-# --- прод: запись запрещена в любом виде ------------------------------------------------
-# Признак берётся из профиля: порт туннеля, хост, домен — у каждого дерева свои.
-#
-# Ищем его в АДРЕСЕ, а не в данных: домен приложения живёт и в самих строках — в почте
-# владельца, в канонической ссылке объекта. Пока признак брался по всей команде, вставка
-# строки с таким адресом в локальную базу отклонялась как запись в бой, а опт-аута у этой
-# ветки нет по замыслу — команда становилась неисполнимой.
-# Поэтому текст запроса (то, что стоит после `-c`/`--command`) из проверки вырезается.
-is_prod=""
-
-# Запрос из редактора адресата в тексте не называет: база выбирается идентификатором
-# подключения, и по одному SQL отличить прод от локальной копии невозможно. Поэтому
-# подключения опознаются в лицо. Список сверяется вызовом list_database_connections;
-# добавили новое — допишите сюда, иначе оно попадёт в «неизвестные» ниже.
-PROD_CONNECTIONS="${RT_PROD_CONNECTIONS:-}"
-LOCAL_CONNECTIONS="${RT_LOCAL_CONNECTIONS:-}"
-
-conn_known=""
-if [ -n "$conn" ]; then
-    case " $PROD_CONNECTIONS " in *" $conn "*) is_prod="yes"; conn_known="prod" ;; esac
-    # Опознанное локальное подключение сильнее текстовой догадки: домен приложения живёт в
-    # самих данных — в почте владельца, в канонической ссылке объекта. Пока вывод не
-    # отменялся, обновление такой строки на локальной базе отклонялось как запись в бой, и
-    # обойти это было нечем.
-    case " $LOCAL_CONNECTIONS " in *" $conn "*) conn_known="local"; is_prod="" ;; esac
-fi
-
-# Разбор идёт по сегментам, а не по всей строке: `ls -l /opt && … psql -c "\copy …"` целиком
-# выглядел как чтение, потому что `-l` от `ls` засчитывался за `psql -l`.
-#
-# Нарезка живёт в ЕДИНСТВЕННОМ месте. Пока наборов разделителей было два — один в раннем слое,
-# другой здесь, — расхождение само по себе оказалось дырой: одиночный `|` считался границей
-# тут и не считался там, и доставка файла конвейером в клиент проходила как чтение.
-# Команда — то, что стоит между `;`, `&&`, `||` и переводами строк. Конвейер границей НЕ
-# является: `cat fix.sql | psql …` — не две независимые команды, а одна доставка SQL, где
-# левое звено питает правое. Пока `|` резал команды, глагол из `echo "drop table …"` терялся
-# вместе с отброшенным звеном, и запись проходила молча.
-split_segments() {
-    # Перевод строки в конце обязателен: без него `read` не отдаёт последнюю строку в тело
-    # цикла, и команда из одного сегмента молча выпадала из разбора целиком.
-    printf '%s\n' "$1" | tr '\001' '\n'
-}
-
-# Звенья конвейера внутри одной команды.
-split_pipeline() {
-    printf '%s' "$1" | tr '\002' '\n'
-}
-
-# Команда считается вызовом клиента, только если клиент стоит ГОЛОВОЙ хотя бы одного звена.
-# Имя в аргументе (`grep -rn "prisma db push" docs/`) вызовом не является.
-calls_client() {
-    _found=""
-    _links="$(printf '%s' "$1" | tr '\002' '\n')"
-    while IFS= read -r link; do
-        [ -z "$link" ] && continue
-        # Голова звена: пропускаем присваивания окружения и обёртки вроде sudo/time/xargs.
-        head="$(printf '%s' "$link" | sed -E 's/^[[:space:]]*//; s/^([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*//; s/^(sudo|time|env|nice|xargs)[[:space:]]+//')"
-        case "$head" in
-            psql*|pg_restore*|pg_dump*|pg_dumpall*|prisma*|*/psql*|*/pg_restore*|*/pg_dump*)
-                _found="yes"; break ;;
-        esac
-        # Транспорт до машины: сам вызов стоит внутри строки, которую он исполняет.
-        case "$head" in
-            ssh\ *|scp\ *|docker\ *|*/ssh\ *|*/docker\ *)
-                printf '%s' "$link" | grep -qE '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
-                    && { _found="yes"; break; } ;;
-        esac
-        # Раннер пакетов перед клиентом: `npx prisma migrate deploy`.
-        case "$head" in
-            npx\ *|pnpm\ *|yarn\ *|bun\ *|npm\ *)
-                printf '%s' "$head" | grep -qE '^(npx|pnpm|yarn|bun|npm)([[:space:]]+(exec|run|dlx))?[[:space:]]+(psql|pg_restore|pg_dump|prisma)([[:space:]]|$)' \
-                    && { _found="yes"; break; } ;;
-        esac
-    done <<CALLS_EOF
-$_links
-CALLS_EOF
-    [ -n "$_found" ]
-}
-
-# Голова сегмента — читающий инструмент: имя клиента стоит в его аргументе, то есть это поиск
-# или просмотр файла, а не доставка SQL. `grep -rn "prisma db push" docs/` читает документацию.
-# Решает именно ГОЛОВА: тот же приём применён в dev-server-guard якорем BOUND.
-is_reader() {
-    printf '%s' "$1" | grep -qE '^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*((sudo|time|env|nice|xargs)[[:space:]]+)*([^[:space:]]*/)?(grep|rg|ag|ack|find|awk|sed|cat|less|more|head|tail|wc|echo|printf|jq|diff|comm|sort|uniq|column)([[:space:]]|$)'
-}
-
-# Сегменты с настоящим вызовом клиента: читающие головы отсеиваются здесь же, а не отдельным
-# слоем с собственным выходом.
-client_segments() {
-    split_segments "$flat" | while IFS= read -r seg; do
-        [ -z "$seg" ] && continue
-        calls_client "$seg" || continue
-        # Маркер звена больше не нужен: дальше команда разбирается как одна строка.
-        printf '%s\n' "$(printf '%s' "$seg" | tr '\002' ' ')"
-    done
-}
-
-
-segments="$(client_segments)"
-if [ -z "$segments" ]; then
-    # У запроса из редактора сегментов нет вовсе — там весь текст и есть запрос.
-    if [ -n "$conn" ] || [ "$context" != "команда psql/prisma" ]; then
-        segments="$flat"
-    else
-        # Команда, где имя клиента встретилось только в аргументах читающих инструментов,
-        # ничего никуда не доставляет. Выход здесь безопасен: он стоит ПОСЛЕ разбора, а не
-        # вместо него, и срабатывает лишь когда настоящего вызова в команде нет.
-        exit 0
-    fi
-fi
-
-# Адресат берётся ТОЛЬКО из сегментов вызова клиента и только из аргументов, а не из данных.
-# Домен сайта живёт в самих строках — в почте владельца, в canonical и og:url объекта, — а
-# рядом в цепочке его дёргают по HTTP. Пока признак искался по всей команде, `curl
-# https://<домен приложения>/... && psql -p 5432 -c "update …"` отклонялся как запись в
-# боевую базу, и опт-аута у этой ветки нет по замыслу: команда становилась неисполнимой.
-# Текст запроса вырезается ДО нарезки на сегменты. Внутри `-c "…"` свободно живут `;` и `||`
-# — по ним сегменты и режутся, поэтому кусок запроса с доменом в данных становился отдельным
-# сегментом, и почта на домене приложения снова читалась как адрес боевой базы.
-addr_flat="$flat"
-if command -v perl >/dev/null 2>&1; then
-    addr_flat="$(printf '%s' "$flat" | perl -0pe '
-        s/(^|[^[:alnum:]])--?(c|command|querytext)(=|\s+)("([^"\\]|\\.)*"|\x27[^\x27]*\x27)/$1/gs
-    ' 2>/dev/null || printf '%s' "$flat")"
-fi
-addr_segments() {
-    split_segments "$addr_flat" | while IFS= read -r seg; do
-        [ -z "$seg" ] && continue
-        flat_seg="$(printf '%s' "$seg" | tr '\002' ' ')"
-        # Адрес берётся из команд с вызовом клиента и из транспорта до машины: `ssh root@…`
-        # называет боевой хост, а сам вызов стоит дальше по цепочке.
-        if calls_client "$seg"; then
-            printf '%s\n' "$flat_seg"
-        elif printf '%s' "$flat_seg" | grep -qE '(^|[^[:alnum:]_.-])(ssh|scp|docker)([^[:alnum:]_.-]|$)|(pghost|pgport|pgdatabase|pguser|database_url|postgres_url)='; then
-            is_reader "$flat_seg" && continue
-            printf '%s\n' "$flat_seg"
-        fi
-    done
-}
-
-# Для запроса из редактора адрес в тексте не назван вовсе: там решает опознанное подключение,
-# а если оно неизвестно — ветка ниже спросит пользователя.
-is_scratch=""
-addr_other=""
-if [ -z "$conn" ] && [ "$context" != "запрос через подключение редактора (обёртка исполнителя)" ]; then
-    while IFS= read -r seg; do
-        [ -z "$seg" ] && continue
-        if [ -n "$PROD_DSN" ] && printf '%s' "$seg" | grep -qE "$PROD_DSN"; then
-            is_prod="yes"
-            addr_other="yes"
-            continue
-        fi
-        # Одноразовая база проверки: петлевой адрес и порт из отведённого под них диапазона.
-        # Диапазон занимают контейнеры, которые поднимают на время одной проверки —
-        # восстановление копии, репетиция миграции на непустой базе — и сносят следом. Данных,
-        # которые стоило бы стеречь, там нет по построению, а вопрос на каждую строку такой
-        # проверки приучает отвечать «да» не читая и обесценивает тот вопрос, который был важен.
-        #
-        # Диапазон узкий и петлевой намеренно: под него не должны попадать ни рабочая база
-        # дерева, ни туннель к бою, ни базы соседних деревьев на этой машине. Какой он здесь,
-        # знает профиль; не назван — исключения нет вовсе, и вопрос задаётся всегда.
-        if [ -n "${RT_SCRATCH_PORT_RE:-}" ] \
-            && printf '%s' "$seg" | grep -qE "$RT_SCRATCH_PORT_RE" \
-            && printf '%s' "$seg" | grep -qE '127\.0\.0\.1|localhost|host\.docker\.internal'; then
-            is_scratch="yes"
-        else
-            # Любой другой адресованный вызов снимает исключение целиком: в цепочке
-            # `psql -p 19434 -f x.sql && psql -c "delete …"` ранний выход убрал бы проверку
-            # со второго звена, а это ровно тот обход, ради которого гард и написан.
-            addr_other="yes"
-        fi
-    done <<EOF
-$(addr_segments)
-EOF
-fi
-
-is_write=""
-# Глаголы ищутся в сегментах ВЫЗОВА, а не по всей строке: иначе слово из шаблона поиска в
-# соседнем звене цепочки объявляло записью читающую команду.
-write_scope="$segments"
-# `copy … from` и `select … into` — запись, не называющая ни одного привычного глагола.
-printf '%s' "$write_scope" | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|create|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
-    && is_write="yes"
-# Конвейер из источника в клиент — та же доставка файла, только без флага: содержимое
-# `cat fix.sql | psql …` гарду не видно, значит это запись по определению.
-while IFS= read -r seg; do
-    [ -z "$seg" ] && continue
-    printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])(cat|head|tail|gzcat|zcat|gunzip|echo|printf|curl|wget)([[:space:]]|$)' \
-        && is_write="yes" && break
-done <<PIPE_EOF
-$(client_segments)
-PIPE_EOF
-
-# Команды prisma меняют базу, не называя ни одного SQL-глагола: `migrate reset` пересоздаёт
-# её целиком, `db push` подгоняет схему под модель, `db execute` льёт произвольный файл.
-printf '%s' "$write_scope" | grep -qE 'prisma[[:space:]]+(migrate[[:space:]]+(reset|deploy|dev)|db[[:space:]]+(push|execute))' \
-    && is_write="yes"
-
-# Глагол в командной строке — не единственный способ довезти SQL до сервера. Файл (`-f`,
-# `--file`, `< dump.sql`) и `pg_restore` не называют ни одного, поэтому раньше проходили
-# мимо всех трёх уровней: доставка файла в клиент на боевой базе завершалась нулём
-# без единого вопроса, а `pg_restore` не мог сработать в принципе, хотя `--clean` сносит
-# содержимое. Содержимое файла гарду недоступно — значит это запись по определению.
-printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_.-])pg_restore([^[:alnum:]_.-]|$)' \
-    && is_write="yes"
-# У `pg_dump` тот же `-f` означает файл ВЫВОДА: это чтение, и записью его считать нельзя —
-# иначе штатное снятие дампа с боевой базы отклонялось, хотя текст отказа сам его советует.
-#
-# Исключение действует ПОСЕГМЕНТНО. Пока оно проверялось по всей команде, одного упоминания
-# `pg_dump` где угодно в цепочке хватало, чтобы `-f` перестал считаться записью во всех
-# остальных вызовах: `pg_dump … > /dev/null && psql -d app -f /tmp/x.sql` проходил молча.
-while IFS= read -r seg; do
-    [ -z "$seg" ] && continue
-    # Граница слова обязательна: `-f /tmp/pg_dump-restore.sql` — это заливка дампа, а не
-    # его снятие, и подстрочное совпадение снимало с неё обе защиты разом.
-    if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])pg_dump(all)?([^[:alnum:]_.-]|$)'; then
-        continue
-    fi
-    # Хвост сегмента после имени клиента: `-f` у `docker compose` (боевой compose-файл
-    # называется нестандартно, без флага не поднимается) стоит ДО `psql` и к запросу
-    # отношения не имеет.
-    seg_tail="$(printf '%s' "$seg" | perl -0pe 's{^.*?(?<![[:alnum:]_./-])(psql|pg_restore|prisma)(?=\s|$)}{$1}s' 2>/dev/null)"
-    [ -z "$seg_tail" ] && seg_tail="$seg"
-    if printf '%s' "$seg_tail" | grep -qE '(^|[[:space:]])(-f|--file)([[:space:]]|=)|<[[:space:]]*[^[:space:]|<]+\.(sql|dump)'; then
-        is_write="yes"
-        break
-    fi
-done <<EOF
-$segments
-EOF
-
-# Исключение стоит ПОСЛЕ разбора адреса и ПЕРЕД правилами записи, но строго после того, как
-# признак боевой базы уже выставлен: прод перекрывает исключение при любом совпадении, а не
-# наоборот. Условие тройное — одноразовый адрес найден, боевого нет, и других адресованных
-# вызовов в команде нет вовсе.
-if [ -n "$is_scratch" ] && [ -z "$is_prod" ] && [ -z "$addr_other" ]; then
-    exit 0
-fi
-
-if [ -n "$is_prod" ] && [ -n "$is_write" ]; then
-    deny "BLOCKED: запись в БОЕВОЕ хранилище (${context}). Адрес ведёт на бой — оттуда данные не восстанавливаются ничем, кроме копии. Схема на бою меняется миграцией через выкатку, данные — через панель владельца. Если правка данных на бою действительно нужна, её делает владелец руками, предварительно сняв копию; гард обойти нельзя."
-fi
-
-# На боевой базе разрешено только то, что гард опознал как чтение — БЕЛЫМ списком, а не
-# перечислением запретов. Чёрный список здесь принципиально не работает: SQL доезжает до
-# сервера файлом, редиректом, `\copy`, `SELECT … INTO`, и каждая заделанная форма оставляет
-# соседнюю. Поэтому вопрос перевёрнут: не «есть ли здесь запись», а «доказано ли чтение».
-#
-# Чтением считаются три формы, и каждая проверяется в СЕГМЕНТЕ своего вызова:
-#   pg_dump без --clean/--create   — снятие дампа
-#   psql -c "<один SELECT>"        — запрос без второго стейтмента
-#   psql -l / --version / --help   — проверка соединения без запроса
-if [ -n "$is_prod" ]; then
-    unproven=""
-    while IFS= read -r seg; do
-        [ -z "$seg" ] && continue
-        seg_read=""
-        # Аргументы клиента — всё, что стоит ПОСЛЕ его имени. До имени в том же сегменте
-        # свободно живут чужие флаги: `docker compose -f docker-compose.prod.yml … psql`,
-        # и `-f` от compose однажды отменял доказательство чтения.
-        seg_tail="$(printf '%s' "$seg" | perl -0pe 's{^.*?(?<![[:alnum:]_./-])(psql|pg_restore|prisma)(?=\s|$)}{$1}s' 2>/dev/null)"
-    [ -z "$seg_tail" ] && seg_tail="$seg"
-
-        if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])pg_dump(all)?([^[:alnum:]_.-]|$)'; then
-            case "$seg" in
-                *--clean*|*--create*) ;;
-                *) seg_read="yes" ;;
-            esac
-        fi
-
-        # Один SELECT и ничего кроме: второй стейтмент через `;` уже не чтение.
-        if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_])select([^[:alnum:]_]|$)' \
-            && ! printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
-            && ! printf '%s' "$seg_tail" | grep -qE '(^|[[:space:]])(-f|--file)([[:space:]]|=)'; then
-            seg_read="yes"
-        fi
-
-        printf '%s' "$seg_tail" | grep -qE '(^|[[:space:]])(-l|--list|--version|--help)([[:space:]]|$)' \
-            && seg_read="yes"
+sql_read_request
+[ -z "$sql" ] && exit 0
 
-        [ -z "$seg_read" ] && unproven="yes"
-    done <<EOF
-$segments
-EOF
+sql_flatten
+sql_collect_segments
+sql_addr_flatten
+sql_resolve_target
+sql_detect_write
 
-    if [ -n "$unproven" ]; then
-        deny "BLOCKED: вызов клиента БД против БОЕВОЙ базы (${context}). На проде разрешено только доказанное чтение — \`pg_dump\` без \`--clean\`, одиночный SELECT через \`-c\`, либо \`-l\`/\`--version\`. Всё остальное отклоняется, даже если гард просто не разобрал команду: содержимое файлов (\`-f\`, \`< dump.sql\`), \`\\copy\` и восстановление дампа ему не видны. Если нужен разбор данных боевой базы — снимай дамп и работай с локальной копией."
-    fi
-fi
+sql_pass_scratch
+sql_check_prod
 
 [ -z "$is_write" ] && exit 0
 
-# --- заведомо разрушительное ------------------------------------------------------------
-soft=""
-case "$flat" in
-    *destructive-ok*) soft="yes" ;;
-esac
-
-verdict() {
-    if [ -n "$soft" ]; then
-        ask "Запрос помечен маркером destructive-ok, но остаётся разрушительным: $1 Подтверди выполнение, если это осознанно."
-    fi
-    deny "BLOCKED: $1 Адресуй строки по первичному ключу — \`WHERE id IN ('…','…')\`: так затрагивается ровно столько строк, сколько перечислено, и промах виден до выполнения. Удаление по маске (email LIKE '%test%') однажды унесло вместе с тестовыми записями демонстрационные брони владельца. Если адресация по id действительно не подходит — сначала выполни SELECT с тем же условием, покажи пользователю, что попадает под удаление, и помечай запрос маркером destructive-ok с объяснением."
-}
-
-if printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_])(truncate|drop[[:space:]]+(table|database|schema|column|index)|alter[[:space:]]+table)([^[:alnum:]_]|$)'; then
-    verdict "запрос меняет саму схему или очищает таблицу целиком (${context})."
-fi
-
-if printf '%s' "$flat" | grep -qE 'prisma[[:space:]]+(migrate[[:space:]]+reset|db[[:space:]]+push)'; then
-    verdict "\`prisma migrate reset\` / \`db push\` пересоздаёт базу и теряет её содержимое (${context})."
-fi
-
-# `pg_restore --clean` перед загрузкой удаляет существующие объекты — то же очищение
-# таблиц, только чужими руками. Без `--clean` это обычная догрузка, она идёт общим путём.
-if printf '%s' "$flat" | grep -q 'pg_restore' && printf '%s' "$flat" | grep -qE '(^|[[:space:]])(--clean|-c|--create)([[:space:]]|=|$)'; then
-    verdict "\`pg_restore --clean\` удаляет объекты базы перед загрузкой дампа (${context})."
-fi
-
-# Штатное применение миграций разрушительным не считается. Раньше здесь стоял безусловный
-# `ask` со словами «убедись, что DATABASE_URL указывает на локальную базу» — гард
-# перекладывал на человека ровно ту работу, которую умеет сделать сам. На локальной базе
-# миграции гоняются постоянно, и вопрос на каждую не добавляет безопасности: гард, который
-# спрашивает по десятому разу, перестают читать вместе с тем единственным вопросом, который
-# был важен.
-#
-# Поэтому адрес РАЗРЕШАЕТСЯ, а не угадывается: сначала inline-префикс самой команды, затем
-# переменная окружения, затем `.env` рабочего каталога.
-unquote() {
-    sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e 's/^"//' -e 's/"$//' -e "s/^'//" -e "s/'$//"
-}
-
-resolve_database_url() {
-    # Искать по `$flat` нельзя: он приведён к нижнему регистру, и `DATABASE_URL=` в нём
-    # не встречается никогда — правило молча брало бы адрес из `.env`, игнорируя явно
-    # указанный в команде. Разбирается исходная строка, а `$flat` остаётся запасным
-    # вариантом с регистронезависимым поиском.
-    inline="$(printf '%s' "${cmd:-}" | grep -oE '[Dd][Aa][Tt][Aa][Bb][Aa][Ss][Ee]_[Uu][Rr][Ll]=[^[:space:]]+' | tail -n1)"
-    [ -z "$inline" ] && inline="$(printf '%s' "$flat" | grep -oiE 'database_url=[^[:space:]]+' | tail -n1)"
-    if [ -n "$inline" ]; then
-        printf '%s' "${inline#*=}" | unquote
-        return
-    fi
-    if [ -n "${DATABASE_URL:-}" ]; then
-        printf '%s' "$DATABASE_URL" | unquote
-        return
-    fi
-    # Подъём по дереву, а не только рабочий каталог: агент работает в git worktree под
-    # `.claude/worktrees/<ветка>/`, где своего `.env` нет, а у основного чекаута — есть,
-    # и он лежит ровно выше по пути. Без подъёма гард не разрешил бы адрес ни разу
-    # именно там, где миграции и гоняются.
-    dir="$hook_cwd"
-    depth=0
-    while [ -n "$dir" ] && [ "$dir" != '/' ] && [ "$depth" -lt 8 ]; do
-        for env_file in "$dir/.env" "$dir/.env.local"; do
-            [ -f "$env_file" ] || continue
-            value="$(grep -m1 -E '^[[:space:]]*DATABASE_URL=' "$env_file" 2>/dev/null | sed -e 's/^[[:space:]]*DATABASE_URL=//' | unquote)"
-            if [ -n "$value" ]; then
-                printf '%s' "$value"
-                return
-            fi
-        done
-        dir="$(dirname "$dir")"
-        depth=$((depth + 1))
-    done
-}
-
-if printf '%s' "$flat" | grep -qE 'prisma[[:space:]]+migrate[[:space:]]+(deploy|dev)'; then
-    migrate_target="$(resolve_database_url)"
-    # Боевой адрес проверяется ДО разбора по видам: туннель к бою тоже висит на петлевом
-    # адресе, только на своём порту, и общее правило «петлевой значит локальный» пропустило бы
-    # миграцию на бой.
-    if [ -n "$PROD_DSN" ] && printf '%s' "$migrate_target" | grep -qE "$PROD_DSN"; then
-        deny "BLOCKED: применение миграций к БОЕВОЙ базе (${context}). Адрес базы ведёт на бой. Схема на бою меняется выкаткой: она сама зовёт применение миграций одноразовым контейнером до старта приложения. Руками этого делать нельзя — гард обойти нельзя."
-    fi
-    case "$migrate_target" in
-        *@localhost:*|*@127.0.0.1:*|*@postgres:*|*@host.docker.internal:*)
-            # Локальная база — штатная работа. Разбор завершается здесь, иначе ниже
-            # сработает общее правило про запись в базу и вопрос всё равно будет задан:
-            # `migrate deploy` помечен записью выше по тексту.
-            #
-            # Но выйти можно, только если запись в команде ОДНА — сама миграция. В цепочке
-            # `prisma migrate deploy && psql -c "delete …"` ранний выход снял бы проверку со
-            # второго звена, а это ровно тот обход, ради которого гард и написан.
-            other_write=""
-            printf '%s' "$write_scope" \
-                | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|create|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
-                && other_write="yes"
-            while IFS= read -r seg; do
-                [ -z "$seg" ] && continue
-                printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])(cat|head|tail|gzcat|zcat|gunzip|echo|printf|curl|wget)([[:space:]]|$)' \
-                    && other_write="yes" && break
-            done <<MIGRATE_PIPE_EOF
-$(client_segments)
-MIGRATE_PIPE_EOF
-            [ -z "$other_write" ] && exit 0
-            ;;
-        '')
-            ask "Применение миграций к базе (${context}), но адрес разрешить не удалось: DATABASE_URL нет ни в команде, ни в окружении, ни в \`.env\` рабочего каталога. Проверь, куда пойдёт миграция, и подтверди."
-            ;;
-        *)
-            ask "Применение миграций по адресу, НЕИЗВЕСТНОМУ ГАРДУ (${context}). Гард знает локальные адреса и боевые; этот — ни то, ни другое. Убедись, что это не прод, и подтверди."
-            ;;
-    esac
-fi
-
-# --- delete/update: смотрим на адресацию ------------------------------------------------
-if printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_])(delete[[:space:]]+from|update)([^[:alnum:]_]|$)'; then
-    if ! printf '%s' "$flat" | grep -q 'where'; then
-        verdict "DELETE/UPDATE без WHERE затрагивает всю таблицу (${context})."
-    fi
-
-    # Адресация ищется ТОЛЬКО в хвосте после последнего `where`. Пока смотрели на весь
-    # запрос, присваивание в SET засчитывалось за адресацию: `UPDATE bookings SET
-    # "propertyId" = 'p1' WHERE source = 'site'` выглядел адресным, хотя задевал все прямые
-    # заявки объекта — ровно то, от чего гард и защищает.
-    # Регистр здесь сохраняется, в отличие от `flat`: колонки Prisma пишутся в camelCase, и
-    # приведённый к нижнему регистру `bookingid` уже не отличить от слова `paid`.
-    where_tail="$(printf '%s' "$sql" | tr '\n\t' '  ' | sed -E 's/.*[Ww][Hh][Ee][Rr][Ee]/where/')"
-
-    # Имя колонки требуется целиком: `id`, `booking_id`, `"bookingId"`. Прежний шаблон
-    # `[a-z_]*id` принимал за идентификатор `paid` и `valid`.
-    if ! printf '%s' "$where_tail" | grep -qE '(^|[^[:alnum:]_"])"?(id|[A-Za-z_]+_id|[a-zA-Z]+Id)"?[[:space:]]*(=|[Ii][Nn][[:space:]]*\()'; then
-        verdict "DELETE/UPDATE адресует строки не по идентификатору (${context}) — условие может совпасть шире, чем задумано."
-    fi
-
-    # Гард видит имя колонки, но не схему: `propertyId` и `session_id` — внешние ключи, и
-    # запрос по ним адресный только на вид. `DELETE … WHERE "propertyId" = 'p1'` сносит все
-    # брони объекта. Отличить это от первичного ключа без схемы нельзя, поэтому решение
-    # остаётся за пользователем — но предупреждение должно быть прямым, а не общим.
-    if ! printf '%s' "$where_tail" | grep -qE '(^|[^[:alnum:]_"])"?id"?[[:space:]]*(=|[Ii][Nn][[:space:]]*\()'; then
-        ask "Условие адресует строки по ВНЕШНЕМУ ключу, а не по первичному (${context}): $(printf '%s' "$where_tail" | head -c 200). Под него попадут ВСЕ строки, связанные с этой сущностью, — например \`WHERE \"propertyId\" = …\` заденет все брони объекта, включая демонстрационные. Если нужны конкретные строки, сперва выбери их SELECT-ом и перечисли в \`WHERE id IN (…)\`."
-    fi
-fi
+sql_check_destructive
+sql_check_migrations
+sql_check_addressing
 
 # --- остальная запись: решает пользователь ----------------------------------------------
 # Неизвестное подключение — не повод пропустить молча: адресат запроса не опознан, и им