#!/usr/bin/env bash # # Testa os validadores do install.sh — as guardas que impedem alguém de avançar # a instalação com um dado errado. Só casos que NÃO dependem de rede: formato, # papel da chave, projeto cruzado, Direct-connection e senha não codificada. # As checagens online (curl/psql) são provadas na instalação real. # # bash hostgator-setup-kit/test-validators.sh # set -uo pipefail cd "$(dirname "${BASH_SOURCE[0]}")" # Um GIT_DIR herdado (suíte rodada de dentro de um hook ou de um `rebase --exec`) # manda por cima de todo `cd`/`git -C` dos repositórios descartáveis abaixo, e a # escrita cai no repositório de quem roda. Zerar o ambiente local do git é o # idioma canônico do próprio git para isso. unset $(git rev-parse --local-env-vars) # O _common.sh vem antes porque é dele que saem `nome_do_projeto_compose`, # `veredito_rede_do_proxy` e `garantir_rede_do_proxy` — o install.sh e o update.sh # compartilham essas três, e a suíte exercita as três de um lugar só. . ./_common.sh # Lê UMA chave do .env pelo `load_env` do kit, e não por grep de formato. # # Os três laços de packaging abaixo casavam a LINHA (`^CHAVE='?valor'?$`), o que # amarrava a asserção ao encoding do `.env` — e quebrou quando o `envq` passou a # escrever aspas duplas para o Docker Compose aceitar apóstrofo (`Sant'Ana`). # Comparar VALOR em vez de TEXTO torna o teste imune ao encoding, que é # justamente o que ele nunca quis testar. `load_env` roda em subshell: não # vaza variável para o caso seguinte. valor_no_env() { ( load_env "$1" >/dev/null 2>&1; eval "printf '%s' \"\${$2:-}\"" ) } INSTALL_SH_LIB=1 . ./install.sh set +e # os dois ligam `set -e`; aqui esperamos validadores falharem de propósito fail=0 # ── Sandbox de CHAVES DE IA: o ambiente de quem roda é uma SEGUNDA fonte que o # install.sh lê — e este caso instala SEM chave (issue #1570) ──────────────── # `pendencia_da_ia` (install.sh:2012) decide o aviso da tela final lendo # AI_GATEWAY_API_KEY e a chave do provedor DIRETO DO AMBIENTE, não só do .env; # o caso "instalar SEM chave de IA" limpava apenas o .env (grep -v abaixo) e # deixava o ambiente de quem roda decidir o veredito. Medido em 24/09/2026: com # AI_GATEWAY_API_KEY exportada, a suíte reprova com a MESMA mensagem do run # 35948236372 — `✗ a tela final não avisa # que a IA ainda não atende`, 1 de 1 — porque o install grava a chave herdada # de volta no .env (`envq AI_GATEWAY_API_KEY`, install.sh:1702) e nenhum # assertion daqui cobra o gateway. Os outros três nomes contaminam ANTES: # ANTHROPIC_API_KEY → 2 vermelhos (provedor + `veio com valor`), OPENAI_API_KEY # → 2, OPENROUTER_API_KEY → 3 (contamina o AI_PROVIDER na entrevista). # Zerando as quatro aqui, TODO caso nasce sem chave e cada caso decide as # chaves que quer pelo .env que escreve — mesma hermetização que a linha # `SUPABASE_ACCESS_TOKEN=` já faz por chamada lá embaixo. # O passo do CI não exporta chave de IA (env: só VERIFY_INICIO e PNPM_HOME) e o # mesmo SHA passou na re-execução: isto hermetiza a suíte para quem roda com # chave no terminal, mas NÃO é a causa da intermitência da #1570. # A causa medida é o cano das asserções. Com `set -o pipefail` (topo do # arquivo), `printf '%s' "$saida" | grep -q X` reprova quando o `grep -q` acha a # frase e sai ANTES de o `printf` terminar de escrever: o `printf` leva SIGPIPE # (status 141), o pipefail faz o pipeline inteiro falhar, e o `!` lê isso como # "a frase não está lá". Medido em 02/10/2026 (ubuntu:24.04, bash 5.2, 1 CPU), # sobre a SAÍDA REAL deste caso: taxas baixas e variáveis pelo cano (de 1 a 6 # em 6000, conforme a asserção), sempre com status 141/0, e zero em 6000 com # here-string. # Por isso toda asserção `grep -q` deste arquivo lê a variável por `<<<"$var"` # — sem cano, não há quem leve SIGPIPE. Não volte ao `printf | grep -q`. export ANTHROPIC_API_KEY= OPENAI_API_KEY= OPENROUTER_API_KEY= AI_GATEWAY_API_KEY= # ── Sandbox: a suíte NÃO pode escrever no crontab da máquina de quem a roda ── # Não é hipótese: os testes JÁ sujaram o crontab do mantenedor com 10 linhas # órfãs — uma delas um `curl` com Bearer batendo num domínio de exemplo a cada # minuto, apontando para um diretório temporário que a própria suíte apaga. # Daqui em diante o `crontab` que os testes enxergam é um dublê que grava em # CRONTAB_SANDBOX; a checagem no fim do arquivo compara o crontab REAL de antes # com o de depois e reprova se mudou. SUITE_TMP="$(mktemp -d)" trap 'rm -rf "$SUITE_TMP"' EXIT CRONTAB_SANDBOX="$SUITE_TMP/crontab-dubles.txt" # o que os testes escreveram CRONTAB_REAL_ANTES="$SUITE_TMP/crontab-real-antes.txt" CRONTAB_REAL_DEPOIS="$SUITE_TMP/crontab-real-depois.txt" # Sem crontab na máquina, `crontab -l` sai 1 e o arquivo fica vazio — o mesmo # estado de "usuário sem crontab". A distinção não importa para a comparação; # o que importa é ela ser feita com o MESMO comando nas duas pontas. crontab -l >"$CRONTAB_REAL_ANTES" 2>/dev/null || : >"$CRONTAB_REAL_ANTES" # dublar_uname_amd64 # # Os cenários abaixo medem o instalador, não o processador de quem roda a # suíte. Fixamos o ambiente em x86_64 para que os fixtures e valores de imagem # desses casos permaneçam determinísticos; a aceitação de ARM64 tem prova # própria em tests/shell/arquitetura-kit.test.sh. Só `uname -m` é dublado; # qualquer outro uso vai ao `uname` real. UNAME_REAL="$(command -v uname)" dublar_uname_amd64() { cat > "$1/uname" < [trecho esperado na mensagem] # # O trecho esperado não é firula: sem ele o teste passa por acaso. Provado — # ao remover o guard da Direct connection, a URL seguia até o psql e era # rejeitada por *falha de conexão*, com o teste ainda verde. Rejeição só conta # quando é pelo motivo certo, e é a mensagem que diz o motivo à pessoa. ok() { local desc="$1" expect="$2" fn="$3" val="${4-}" want="${5-}" local out rc if out="$("$fn" "$val" 2>&1)"; then rc=0; else rc=$?; fi if [ "$expect" = pass ]; then if [ $rc -eq 0 ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (esperava aceitar, rejeitou: %s)\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1; fi return fi if [ $rc -eq 0 ]; then printf ' ✗ %s (esperava rejeitar, aceitou)\n' "$desc"; fail=1; return fi if [ -n "$want" ] && ! grep -qi -- "$want" <<<"$out"; then printf ' ✗ %s (rejeitou, mas pelo motivo errado)\n esperava falar de: %s\n disse: %s\n' \ "$desc" "$want" "$(printf '%s' "$out" | head -1)"; fail=1; return fi printf ' ✓ %s\n' "$desc" } # A anon/service_role e a db_url comparam contra o projeto declarado. NEXT_PUBLIC_SUPABASE_URL="https://abcdefghijklmnop.supabase.co" # JWT falso: header.payload.assinatura, payload com role e ref. mkjwt() { local payload; payload="$(printf '{"iss":"supabase","ref":"%s","role":"%s"}' "$2" "$1" \ | base64 | tr -d '\n' | tr '+/' '-_' | tr -d '=')" printf 'eyJhbGciOiJIUzI1NiJ9.%s.assinatura' "$payload" } echo "domínio" ok "aceita subdomínio" pass v_domain "crm.empresa.com.br" ok "rejeita com https://" reject v_domain "https://crm.empresa.com.br" "sem https" ok "rejeita com caminho" reject v_domain "crm.empresa.com.br/app" "sem barra" ok "rejeita sem ponto" reject v_domain "localhost" "falta o ponto" echo "e-mail" ok "aceita e-mail válido" pass v_email "voce@empresa.com.br" ok "rejeita sem @" reject v_email "voce.empresa.com.br" "inválido" echo "URL do Supabase: a da nuvem E a de um Supabase próprio" # O gate de formato exigia `.supabase.co` e matava quem roda Supabase # self-hosted com a frase "Ela termina em .supabase.co" — recusa do dado CERTO, e # sem saída nenhuma: não existe o que digitar que passe. Agora o formato só exige # https://, e a mensagem de recusa precisa ensinar os DOIS casos, senão ela # recria o mesmo beco em prosa. # # FRONTEIRA (o cabeçalho deste arquivo): aqui se mede só o `case` de formato. A # chamada a /auth/v1/verify é dublada, porque prender esta suíte a DNS é trocar # um teste por um oráculo. O que aquela chamada prova de fato — e o que ela NÃO # prova — é medição de instalação real; ver o relatório da triagem. sburl_ok() { # sburl_ok [trecho esperado]... local desc="$1" expect="$2" url="$3" out rc want shift 3 out="$(bash -c ' INSTALL_SH_LIB=1 . ./install.sh set +e # Só o formato está sob teste: para o dublê, todo host é um GoTrue (o # JSON que /auth/v1/verify devolve sem parâmetros, como medido). curl() { printf '\''{"msg":"Verify requires a verification type"}\n400'\''; } v_supabase_url "$1"' _ "$url" 2>&1)"; rc=$? if [ "$expect" = pass ]; then if [ $rc -eq 0 ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (esperava aceitar, rejeitou: %s)\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1; fi return fi if [ $rc -eq 0 ]; then printf ' ✗ %s (esperava rejeitar, aceitou)\n' "$desc"; fail=1; return; fi for want in "$@"; do if ! grep -qi -- "$want" <<<"$out"; then printf ' ✗ %s (rejeitou, mas a mensagem não fala de: %s)\n disse: %s\n' \ "$desc" "$want" "$(printf '%s' "$out" | head -1)"; fail=1; return fi done printf ' ✓ %s\n' "$desc" } sburl_ok "aceita a URL da nuvem" pass "https://abcdefghijklmnop.supabase.co" # ESTE é o caso que não existia: Supabase próprio, host que não tem .supabase.co. sburl_ok "aceita Supabase próprio (self-hosted)" pass "https://db-crm.exemplo.com.br" sburl_ok "aceita host sem ponto (Supabase na rede interna)" pass "https://supabase-interno" # Sem https:// continua sendo recusa — é o que quebra o curl logo abaixo, e o # caso do `.supabase.co` colado sem esquema tem mensagem própria, mais específica. sburl_ok "rejeita .supabase.co colado sem esquema" reject "abcdefghijklmnop.supabase.co" "https://" sburl_ok "rejeita http:// (sem TLS)" reject "http://db-crm.exemplo.com.br" "https://" # A mensagem tem de nomear os DOIS mundos. Uma recusa que só fala da nuvem # devolve o self-hoster ao beco de onde esta correção o tirou — o defeito # migraria do `case` para a prosa, onde não há catraca nenhuma. sburl_ok "a recusa ensina o caso da NUVEM" reject "meu-supabase" "supabase.co" sburl_ok "a recusa ensina o caso do Supabase PRÓPRIO" reject "meu-supabase" "servidor" echo "URL do Supabase: quem responde tem de ser o GoTrue, não qualquer servidor" # O validador aceitava QUALQUER código HTTP diferente de 000. Medido numa VPS # com Coolify (PR 4, E7 Passo 1): a 127.0.0.1:8000 é o PAINEL do Coolify e # responde 302 — e teria passado como "o Supabase local". A 8001 (o Envoy do # Supabase) é a certa. # # O dublê reproduz o que foi MEDIDO, sem chave (a URL é perguntada antes das # chaves, então o validador não tem apikey para mandar): # - Envoy self-hosted e gateway da nuvem: /auth/v1/health → 401 (o gateway # exige apikey; ninguém do GoTrue respondeu ainda); /auth/v1/verify é rota # ABERTA (link de e-mail) e quem responde é o GoTrue: 400 com o JSON dele. # - Coolify na 8000: 302 com HTML de redirecionamento para /login, em tudo. # - Um site qualquer: 200 com HTML. # O dublê imita `-o` e `-w` do curl de verdade, para não amarrar o teste à # forma da chamada — só ao que o servidor responde. gotrue_curl_duble() { curl() { local a prev="" url="" fmt="" so_codigo=0 body code for a; do case "$prev" in -w) fmt="$a";; -o) so_codigo=1;; esac case "$a" in http://*|https://*) url="$a";; esac prev="$a" done case "$url" in http://127.0.0.1:8001/auth/v1/verify*|https://*.supabase.co/auth/v1/verify*|https://db-crm.exemplo.com.br/auth/v1/verify*) body='{"code":400,"error_code":"validation_failed","msg":"Verify requires a verification type"}'; code=400;; http://127.0.0.1:8001/*|https://*.supabase.co/*|https://db-crm.exemplo.com.br/*) body='Unauthorized'; code=401;; https://api.exemplo.com.br/*) # Uma API qualquer que devolve JSON com "msg" e 200: o corpo sozinho # não separa ela do GoTrue; o código separa. body='{"ok":true,"msg":"pong"}'; code=200;; http://127.0.0.1:8000/*) body='Redirecting to http://127.0.0.1:8000/login'; code=302;; *) body='Bem-vindo'; code=200;; esac [ "$so_codigo" = 1 ] || printf '%s' "$body" [ -z "$fmt" ] || { fmt="${fmt//%\{http_code\}/$code}"; printf "$fmt"; } return 0 } } gotrue_ok() { # gotrue_ok [trecho esperado]... local desc="$1" expect="$2" url="$3" ss="$4" interna="$5" out rc want shift 5 out="$(bash -c " INSTALL_SH_LIB=1 . ./install.sh set +e $(declare -f gotrue_curl_duble) gotrue_curl_duble SINGLE_SERVER=\"\$2\" SUPABASE_INTERNAL_URL=\"\$3\" v_supabase_url \"\$1\"" _ "$url" "$ss" "$interna" 2>&1)"; rc=$? if [ "$expect" = pass ]; then if [ $rc -eq 0 ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (esperava aceitar, rejeitou: %s)\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1; fi return fi if [ $rc -eq 0 ]; then printf ' ✗ %s (esperava rejeitar, aceitou)\n' "$desc"; fail=1; return; fi for want in "$@"; do if ! grep -qi -- "$want" <<<"$out"; then printf ' ✗ %s (rejeitou, mas a mensagem não fala de: %s)\n disse: %s\n' \ "$desc" "$want" "$(printf '%s' "$out" | head -1)"; fail=1; return fi done printf ' ✓ %s\n' "$desc" } # O caso medido: single-server apontando para a porta do painel do Coolify. gotrue_ok "single-server: painel do Coolify (302) é RECUSADO" reject \ "https://crm.exemplo.com.br" 1 "http://127.0.0.1:8000" "não é o Supabase" "127.0.0.1:8000" # O caso certo da mesma VPS: o Envoy do Supabase na 8001. gotrue_ok "single-server: o Envoy do Supabase (GoTrue) é ACEITO" pass \ "https://crm.exemplo.com.br" 1 "http://127.0.0.1:8001" # Sem quebrar a nuvem: o gateway dela também deixa /auth/v1/verify aberto. gotrue_ok "nuvem: projeto .supabase.co é ACEITO" pass \ "https://abcdefghijklmnop.supabase.co" 0 "" gotrue_ok "Supabase próprio atrás de domínio é ACEITO" pass \ "https://db-crm.exemplo.com.br" 0 "" # O mesmo defeito fora do single-server: a URL do SITE da empresa no lugar da # do Supabase respondia 200 e passava. gotrue_ok "um site qualquer (200 HTML) é RECUSADO" reject \ "https://www.exemplo.com.br" 0 "" "não é o Supabase" # "msg" no corpo não basta: o GoTrue devolve 400 ali (medido no GoTrue do kit, # v2.196.0). Uma API que responda 200 com "msg" não é o Supabase. gotrue_ok "200 com 'msg' no corpo é RECUSADO" reject \ "https://api.exemplo.com.br" 0 "" "não é o Supabase" "HTTP 200" echo "chaves do Supabase (formato/papel/projeto)" ok "rejeita service_role no campo anon" reject v_anon "$(mkjwt service_role abcdefghijklmnop)" "preciso da 'anon'" ok "rejeita anon no campo service_role" reject v_service "$(mkjwt anon abcdefghijklmnop)" "preciso da 'service_role'" ok "rejeita chave de outro projeto" reject v_anon "$(mkjwt anon zzzzzzzzzzzzzzzz)" "OUTRO projeto" ok "rejeita texto que não é chave" reject v_anon "minha-chave-secreta" "não parece uma chave" echo "connection string" ok "rejeita [YOUR-PASSWORD] não trocado" reject v_db_url "postgresql://postgres.abcdefghijklmnop:[YOUR-PASSWORD]@aws-1-us-west-2.pooler.supabase.com:5432/postgres" "troque isso pela senha" ok "rejeita Direct connection (IPv6)" reject v_db_url "postgresql://postgres:senha@db.abcdefghijklmnop.supabase.co:5432/postgres" "Session pooler" ok "rejeita string de outro projeto" reject v_db_url "postgresql://postgres.zzzzzzzzzzzzzzzz:senha@aws-1-us-west-2.pooler.supabase.com:5432/postgres" "mesmo projeto" ok "rejeita o que não é URL de Postgres" reject v_db_url "aws-1-us-west-2.pooler.supabase.com" "começa com postgresql" echo "connection string: Supabase PRÓPRIO não tem de projeto" # A comparação de projeto lê o `postgres.` do pooler DA NUVEM. Num Supabase # self-hosted não existe e a role pode ser qualquer uma, então a checagem # acusava "a string é do projeto 'crmuser', mas a URL é do projeto 'db-crm'" — # frase sobre duas coisas que não existem, e sem saída. Agora ela só roda quando # a URL é mesmo da nuvem. # # O caso da nuvem está aqui de novo (já existe acima) porque a asserção é OUTRA: # lá se mede a mensagem, aqui se mede que a recusa acontece ANTES de encostar no # banco. É essa fronteira que o `case` novo poderia ter movido sem ninguém ver. # # O que sobra barrando o dado errado no caminho self-hosted é SÓ o `select 1`, e # ele prova que o banco RESPONDE, não que é o banco certo: medido, uma string # apontando para o banco de outra pessoa passa. Isto está no relatório da # triagem como achado — não é um teste vermelho aqui de propósito. db_ok() { # db_ok [trecho esperado] local desc="$1" expect="$2" sburl="$3" conn="$4" want="${5-}" dir out rc tocou dir="$(mktemp -d)"; mkdir -p "$dir/bin" # O `select 1` roda via `docker run postgres:17-alpine`. O dublê não é # conveniência: sem ele um caso de ACEITE baixaria imagem e abriria conexão de # rede, que é justamente o que o cabeçalho deste arquivo promete não fazer. # Ele deixa um rastro para a asserção de vacuidade logo abaixo. printf '#!/usr/bin/env bash\ntouch "%s/tocou-no-banco"\nprintf 1\n' "$dir" > "$dir/bin/docker" chmod +x "$dir/bin/docker" out="$(env PATH="$dir/bin:$PATH" NEXT_PUBLIC_SUPABASE_URL="$sburl" bash -c ' INSTALL_SH_LIB=1 . ./install.sh set +e v_db_url "$1"' _ "$conn" 2>&1)"; rc=$? tocou=nao; [ -e "$dir/tocou-no-banco" ] && tocou=sim rm -rf "$dir" if [ "$expect" = pass ]; then if [ $rc -ne 0 ]; then printf ' ✗ %s (esperava aceitar, rejeitou: %s)\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1 elif [ "$tocou" != sim ]; then # Vacuidade: aceitar SEM chegar ao psql é outro defeito com a mesma cara de # verde — seria um `return 0` antecipado, e a instalação seguiria com uma # connection string que ninguém testou. printf ' ✗ %s (aceitou sem nunca tentar conectar — return 0 antecipado?)\n' "$desc"; fail=1 else printf ' ✓ %s\n' "$desc"; fi return fi if [ $rc -eq 0 ]; then printf ' ✗ %s (esperava rejeitar, aceitou)\n' "$desc"; fail=1; return; fi if [ -n "$want" ] && ! grep -qi -- "$want" <<<"$out"; then printf ' ✗ %s (rejeitou, mas pelo motivo errado)\n disse: %s\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1; return fi if [ "$tocou" = sim ]; then printf ' ✗ %s (recusou só DEPOIS de tentar conectar — a guarda é de formulário)\n' "$desc"; fail=1; return fi printf ' ✓ %s\n' "$desc" } db_ok "próprio: role arbitrária deixa de virar 'projeto'" pass \ "https://db-crm.exemplo.com.br" "postgresql://crmuser:senha@db-crm.exemplo.com.br:5432/postgres" db_ok "próprio: role 'postgres' segue passando" pass \ "https://db-crm.exemplo.com.br" "postgresql://postgres:senha@db-crm.exemplo.com.br:5432/postgres" # A regressão que importa: afrouxar o self-hosted não podia afrouxar a NUVEM, # onde o existe e apontar para o projeto errado é o erro clássico. db_ok "NUVEM: projeto cruzado continua barrado antes do banco" reject \ "https://abcdefghijklmnop.supabase.co" \ "postgresql://postgres.zzzzzzzzzzzzzzzz:senha@aws-1-us-west-2.pooler.supabase.com:5432/postgres" \ "mesmo projeto" db_ok "NUVEM: mesmo projeto passa" pass \ "https://abcdefghijklmnop.supabase.co" \ "postgresql://postgres.abcdefghijklmnop:senha@aws-1-us-west-2.pooler.supabase.com:5432/postgres" # A URL da nuvem NÃO chega sempre terminando em '.supabase.co'. O address bar do # navegador entrega barra final; quem copia da documentação traz caminho; quem # cola com o mouse traz espaço. Decidir "é nuvem?" pela string inteira desliga a # comparação de projeto em silêncio nesses três casos — e o desfecho é o pior # possível: o baseline.sql vai para um banco e o app fala com outro, cada um de # um projeto. Estes três casos guardam a extração de HOST que impede isso. for _sufixo in "/" "/rest/v1" " "; do db_ok "NUVEM com '${_sufixo}' na URL: projeto cruzado continua barrado" reject \ "https://abcdefghijklmnop.supabase.co${_sufixo}" \ "postgresql://postgres.zzzzzzzzzzzzzzzz:senha@aws-1-us-west-2.pooler.supabase.com:5432/postgres" \ "mesmo projeto" done unset _sufixo # E o outro lado da mesma extração: Supabase próprio com barra final continua # sendo Supabase próprio — a correção acima não pode reintroduzir a recusa do # dado certo que este PR veio tirar. db_ok "próprio com barra final segue sem comparar projeto" pass \ "https://db-crm.exemplo.com.br/" "postgresql://crmuser:senha@db-crm.exemplo.com.br:5432/postgres" # Quem responde a connection string ANTES da URL (ou pula a URL) não tem com o # que comparar — e não pode ser barrado por isso. db_ok "sem URL respondida ainda: não há o que comparar" pass \ "" "postgresql://postgres.zzzzzzzzzzzzzzzz:senha@aws-1-us-west-2.pooler.supabase.com:5432/postgres" echo "chaves de IA e senha" ok "rejeita chave Anthropic com prefixo errado" reject v_anthropic "sk-proj-abc123" "começa com 'sk-ant-'" # `v_openrouter` foi referenciada como validador do campo da OpenRouter sem # nunca ter sido definida — e a suíte não tinha uma linha sequer que a # mencionasse. Este caso é o que faz a AUSÊNCIA da função ser vermelha: um nome # inexistente devolve 127, que `ok` lê como rejeição, então o par (rejeita por # prefixo / aceita vazio-não) é o que separa "existe e valida" de "não existe". ok "rejeita chave OpenRouter com prefixo errado" reject v_openrouter "sk-ant-abc123" "começa com 'sk-or-'" ok "rejeita chave OpenRouter vazia" reject v_openrouter "" "começa com 'sk-or-'" ok "rejeita chave OpenAI com prefixo errado" reject v_openai "minha-chave" "começa com 'sk-'" ok "aceita OpenAI vazia (é opcional)" pass v_openai "" ok "rejeita senha curta" reject v_password "1234567" "muito curta" ok "aceita senha de 8+" pass v_password "12345678" echo "rede fora do ar: o sentinela 000 (issue #190)" # O dublê de curl das outras seções é `printf 200` INCONDICIONAL, então o ramo # `000` de todos os seis validadores nunca era exercitado por nenhum caso — e foi # assim que ele passou 6 versões sendo código morto. # # O dublê aqui imita o curl DE VERDADE quando a rede falha: `-w '%{http_code}'` # faz ele IMPRIMIR `000` e sair com código de erro. Era essa dupla que quebrava o # `|| echo 000` de dentro da substituição de comando: o echo CONCATENAVA com o # que o curl já tinha impresso e a variável virava `000000`, que não casa com # nenhum ramo. Os dois desfechos eram errados, em direções opostas — e os dois # estão cobertos abaixo, porque consertar um e não medir o outro deixaria metade # do defeito viva. rede_morta() { # rede_morta [trecho esperado]... local desc="$1" expect="$2" fn="$3" val="$4" out rc want shift 4 out="$(bash -c ' INSTALL_SH_LIB=1 . ./install.sh NEXT_PUBLIC_SUPABASE_URL="https://abcdefghijklmnop.supabase.co" set +e # curl real com -w: imprime 000 E devolve exit != 0. curl() { printf 000; return 6; } "$1" "$2"' _ "$fn" "$val" 2>&1)"; rc=$? if [ "$expect" = pass ] && [ $rc -ne 0 ]; then printf ' ✗ %s (esperava seguir, barrou: %s)\n' "$desc" "$(printf '%s' "$out" | head -1)"; fail=1; return fi if [ "$expect" = reject ] && [ $rc -eq 0 ]; then printf ' ✗ %s (esperava barrar, seguiu)\n' "$desc"; fail=1; return fi for want in "$@"; do if ! grep -qi -- "$want" <<<"$out"; then printf ' ✗ %s (a mensagem não fala de: %s)\n disse: %s\n' \ "$desc" "$want" "$(printf '%s' "$out" | head -1)"; fail=1; return fi done printf ' ✓ %s\n' "$desc" } # LADO 1 — o relatado: a URL inalcançável era ACEITA. `v_supabase_url` é o único # dos seis que exige resposta online, e o `000` dele era inalcançável: medido em # f9abedd0, `rc=0` e saída vazia para um host que não resolve. rede_morta "URL de Supabase inalcançável é RECUSADA" reject v_supabase_url \ "https://abcdefghijklmnop.supabase.co" "não consegui alcançar" # LADO 2 — o oposto, e pior para quem instala: com a rede fora, a chave CERTA # caía no ramo `*)` e era RECUSADA com "Confira a chave e o projeto" — o erro # acusando quem configurou, num laço do qual não se sai digitando certo. O código # sempre quis avisar e seguir; era a variável `000000` que não deixava. rede_morta "chave service_role correta SEGUE com aviso" pass v_service \ "$(mkjwt service_role abcdefghijklmnop)" "não consegui checar" "sigo com ela" rede_morta "chave anon correta SEGUE com aviso" pass v_anon \ "$(mkjwt anon abcdefghijklmnop)" "sigo com ela" # Os três de IA já seguiam (o `*)` deles também é tolerante), mas a mensagem # mostrava `000000` ao usuário. Aqui se cobra o ramo certo, não só o desfecho: # sem checar o texto, um `*)` disfarçado de `000` passaria. rede_morta "chave Anthropic segue pelo ramo 000" pass v_anthropic "sk-ant-abc123" "não consegui checar" rede_morta "chave OpenRouter segue pelo ramo 000" pass v_openrouter "sk-or-abc123" "não consegui checar" rede_morta "chave OpenAI segue pelo ramo 000" pass v_openai "sk-abc123" "não consegui checar" # ── A prova da chave, no single-server, bate no Supabase LOCAL ──────────────── # Defeito medido numa instalação real (10/10/2026; single-server com o domínio # atrás de Cloudflare no modo proxy): a fase 2 provava a chave contra # NEXT_PUBLIC_SUPABASE_URL, mas quem serve essa URL é o Caddy DESTA instalação, # que só sobe DEPOIS desta fase — o proxy devolve 521 e a instalação PARA # mandando conferir uma chave que está certa. O `curl` abaixo é o juiz: ele # registra QUAL endereço foi chamado e responde por host (a pública, 521 ou 200 # conforme o caso; o gateway local do Supabase, sempre 200). prova_no_local() { # prova_no_local local desc="$1" single="$2" publica="$3" esperada="$4" log chamadas rc log="$(mktemp)" SINGLE_DO_CASO="$single" PUBLICA_DO_CASO="$publica" CURL_LOG="$log" \ JWT_DO_CASO="$(mkjwt anon abcdefghijklmnop)" bash -c ' INSTALL_SH_LIB=1 . ./install.sh set +e NEXT_PUBLIC_SUPABASE_URL="https://abcdefghijklmnop.supabase.co" SUPABASE_INTERNAL_URL="http://127.0.0.1:8000" SINGLE_SERVER="$SINGLE_DO_CASO" curl() { local a url="" for a in "$@"; do case "$a" in http://*|https://*) url="$a";; esac; done printf "%s\n" "$url" >> "$CURL_LOG" case "$url" in http://127.0.0.1:8000/*) printf 200;; *) printf "%s" "$PUBLICA_DO_CASO";; esac return 0 } v_anon "$JWT_DO_CASO"' >/dev/null 2>&1 rc=$? chamadas="$(cat "$log" 2>/dev/null)" if [ -n "$chamadas" ] && [ "$chamadas" != "$esperada" ]; then printf ' ✗ %s (chamou o endereço errado)\n esperava: %s\n chamou: %s\n' \ "$desc" "$esperada" "$chamadas"; fail=1 elif [ $rc -ne 0 ]; then printf ' ✗ %s (a chave CERTA foi recusada)\n' "$desc"; fail=1 else printf ' ✓ %s\n' "$desc" fi rm -f "$log" } prova_no_local "single-server com o proxy no caminho: a chave certa SEGUE (prova no Supabase local)" \ 1 521 "http://127.0.0.1:8000/auth/v1/settings" prova_no_local "fora do single-server: a prova continua na URL pública que o operador deu" \ 0 200 "https://abcdefghijklmnop.supabase.co/auth/v1/settings" echo "leitura do .env (load_env)" . ./_common.sh set +e TMP="$(mktemp -d)" cat > "$TMP/.env" <<'EOF' # comentário deve ser ignorado APP_NAME='Loja do João' SENHA_COM_HASH='a#b' SENHA_COM_CIFRAO='p$ass' COM_ASPAS_DUPLAS="valor com espaço" SEM_ASPAS=simples LEGADO_SEM_ASPAS=Loja Antiga linha sem igual EOF ( load_env "$TMP/.env" eq() { if [ "$2" = "$3" ]; then printf ' ✓ %s\n' "$1"; else printf ' ✗ %s esperava [%s] obteve [%s]\n' "$1" "$3" "$2"; exit 1; fi; } eq "nome com espaço" "$APP_NAME" "Loja do João" eq "senha com # não trunca" "$SENHA_COM_HASH" 'a#b' eq "senha com \$ não expande" "$SENHA_COM_CIFRAO" 'p$ass' eq "aspas duplas" "$COM_ASPAS_DUPLAS" "valor com espaço" eq "sem aspas" "$SEM_ASPAS" "simples" eq "legado sem aspas c/ espaço" "$LEGADO_SEM_ASPAS" "Loja Antiga" ) || fail=1 rm -rf "$TMP" echo "credenciais do provisionamento (sb_carrega_credenciais)" # Este bloco existe porque a leitura já foi feita com `eval`, e com `eval` ela # EXECUTAVA o conteúdo: o provisionamento imprime `CHAVE='valor'` sem escapar a # aspa simples, e SUPABASE_REGION — que vem do ambiente — é interpolada dentro da # connection string. Medido: com `eval`, o marcador abaixo era criado. TMP2="$(mktemp -d)" ( MARCA="$TMP2/executou" # Exatamente o que o provisionamento emite quando a região traz uma aspa simples. VENENO="postgresql://postgres.ref:senha@aws-0-sa-east-1'\$(touch $MARCA)'.pooler.supabase.com:5432/postgres" PATH_ANTES="$PATH" unset NEXT_PUBLIC_SUPABASE_URL NEXT_PUBLIC_SUPABASE_ANON_KEY SUPABASE_SERVICE_ROLE_KEY SUPABASE_DB_URL sb_carrega_credenciais "$(printf "SUPABASE_DB_URL='%s'\n" "$VENENO")" eq() { if [ "$2" = "$3" ]; then printf ' ✓ %s\n' "$1"; else printf ' ✗ %s esperava [%s] obteve [%s]\n' "$1" "$3" "$2"; exit 1; fi; } if [ -e "$MARCA" ]; then printf ' ✗ aspa simples no valor EXECUTOU comando\n'; exit 1; fi printf ' ✓ aspa simples no valor não executa comando\n' eq "valor com aspa chega literal" "${SUPABASE_DB_URL:-}" "$VENENO" # Chave fora da lista fixa é ignorada — a saída não pode criar variável qualquer. sb_carrega_credenciais "PATH='/pwn'" eq "chave desconhecida é ignorada" "$PATH" "$PATH_ANTES" # E o caminho feliz continua inteiro. unset SUPABASE_DB_URL sb_carrega_credenciais "$(printf "NEXT_PUBLIC_SUPABASE_URL='https://abc.supabase.co'\nSUPABASE_DB_URL='postgresql://u:p@h:5432/postgres'\n")" eq "url normal chega íntegra" "${NEXT_PUBLIC_SUPABASE_URL:-}" "https://abc.supabase.co" eq "db_url normal chega íntegra" "${SUPABASE_DB_URL:-}" "postgresql://u:p@h:5432/postgres" ) || fail=1 rm -rf "$TMP2" echo "integração: o install.sh não INTERPRETA a saída do provisionamento" # O bloco de cima guarda a FUNÇÃO; este guarda o PONTO DE CHAMADA — trocar # `sb_carrega_credenciais "$_sb_out"` de volta por `eval "$_sb_out"` passava # despercebido, porque a função continuava correta e ninguém mais a chamava. # # Guarda o COMPORTAMENTO, não o texto: uma asserção do tipo "não existe a palavra # eval" pegaria só a reincidência literal, e `. <(printf %s "$_sb_out")` executa # igual. Aqui o install.sh roda de verdade (docker é stub, nada de rede) com um # provisionamento que devolve uma aspa simples no valor; se qualquer mecanismo # interpretar aquilo, o marcador aparece. TMP3="$(mktemp -d)" ( MARCA="$TMP3/executou" mkdir -p "$TMP3/bin" "$TMP3/proj" cp install.sh _common.sh _manifestos.sh _i18n.sh "$TMP3/" : > "$TMP3/proj/docker-compose.prod.yml" cat > "$TMP3/bin/docker" <<'STUBDOCKER' #!/usr/bin/env bash if [ "${1:-}" = buildx ] && [ "${2:-}" = imagetools ] && [ "${3:-}" = inspect ]; then case " $* " in *' --raw '*) printf '%s' '{"schemaVersion":2,"manifests":[{"platform":{"os":"linux","architecture":"amd64"}}]';; *) printf 'linux/amd64\n';; esac fi exit 0 STUBDOCKER chmod +x "$TMP3/bin/docker" cat > "$TMP3/bin/curl" <<'STUBCURL' #!/usr/bin/env bash case "$*" in *releases/latest*) printf '%s' '{"tag_name":"v1.66.1"}' ;; *ghcr.io/token*) printf '%s' '{"token":"teste"}' ;; *ghcr.io/v2/*) printf 200 ;; *) printf 200 ;; esac STUBCURL chmod +x "$TMP3/bin/curl" dublar_uname_amd64 "$TMP3/bin" cat > "$TMP3/supabase-provision.sh" <<'PROV' #!/usr/bin/env bash # O que o provisionamento emite quando SUPABASE_REGION (que vem do ambiente) # traz uma aspa simples: ela fecha o literal do printf e o resto vira código. VENENO="postgresql://u:p@aws-0-x'\$(touch $MARCA)'.pooler.supabase.com:5432/postgres" printf "NEXT_PUBLIC_SUPABASE_URL='https://ref.supabase.co'\n" printf "NEXT_PUBLIC_SUPABASE_ANON_KEY='a'\n" printf "SUPABASE_SERVICE_ROLE_KEY='s'\n" printf "SUPABASE_DB_URL='%s'\n" "$VENENO" PROV saida="$(cd "$TMP3/proj" && env PATH="$TMP3/bin:$PATH" MARCA="$MARCA" \ SUPABASE_ACCESS_TOKEN=fake NEXT_PUBLIC_SUPABASE_URL= \ DESKCOMM_RELEASES_LATEST_URL=https://example.invalid/releases/latest \ bash "$TMP3/install.sh" --yes 2>&1 || true)" # Sem esta checagem o teste passaria por VACUIDADE: se o install.sh morresse # antes do bloco (stub quebrado, refactor movendo o trecho), nada executaria o # veneno e o silêncio seria lido como aprovação. if ! grep -q "credenciais entraram sozinhas" <<<"$saida"; then printf ' ✗ o install.sh não chegou ao bloco do Supabase — teste inconclusivo, não verde\n' printf '%s\n' "$saida" | tail -12 exit 1 fi if [ -e "$MARCA" ]; then printf ' ✗ o install.sh INTERPRETOU a saída do provisionamento (eval/source no ponto de chamada?)\n'; exit 1 fi printf ' ✓ ponto de chamada não interpreta a saída\n' ) || fail=1 rm -rf "$TMP3" echo "sincronia: o install.sh grava as chaves que o .env.hostgator.example promete" # O install.sh monta o .env a partir de uma LISTA FECHADA de `envq` e fecha com # `} > .env`, que TRUNCA. Chave fora da lista simplesmente não é gravada — e se a # pessoa a tiver posto à mão, some no próximo install, num script que o README # vende como idempotente. Medido: uma chave posta à mão é carregada por load_env # e depois DESCARTADA na escrita. # # Passou despercebido porque o env-example-sync do repo compara .env.example com # lib/env.ts e nunca olha para o install.sh — ninguém guardava esta ponta. # # DÍVIDA: chaves que o install.sh hoje não grava. A lista só pode ENCOLHER; se # uma delas passar a ser gravada, o teste manda tirá-la daqui. DIVIDA="AGENT_DISPATCH_CONSUMER NUVEMSHOP_APP_ID NUVEMSHOP_CLIENT_ID NUVEMSHOP_CLIENT_SECRET" EXEMPLO="${EXEMPLO_ENV:-../.env.hostgator.example}" if [ ! -f "$EXEMPLO" ]; then # Pular é aceitável (o kit também roda solto, fora do repo), mas em voz alta: # pulo silencioso é indistinguível de teste que passou. printf ' — pulado: %s não existe (kit fora do repositório)\n' "$EXEMPLO" else regua_quebrou=0 GRAVA="$(grep -oE '^[[:space:]]*envq [A-Z_0-9]+' install.sh | awk '{print $2}' | sort -u)" || regua_quebrou=1 # VACUIDADE — a lista de escrita é a régua deste caso, e uma régua CURTA acusa # o inocente. `$GRAVA` sai de um pipeline de três estágios; quando a máquina # está saturada ele às vezes volta truncado, e o efeito não é um teste que # falha em reconhecer o defeito: é um teste que INVENTA um, nomeando chaves que # o install.sh grava na linha seguinte. # # Medido duas vezes com load average acima de 30, no mesmo dia e no mesmo # arquivo: uma rodada acusou VAPID_PUBLIC_KEY, outra ANTHROPIC_API_KEY e # WAHA_HMAC_SECRET — as três com `envq` presente no install.sh, e as duas # rodadas seguintes verdes. Conjuntos diferentes a cada vez é a assinatura de # régua truncada, não de defeito. # # O piso fixo de 30 não pegava isso: 30 é menos da metade da régua real, e a # truncagem parcial (67 → 40, digamos) passava por baixo da guarda e saía como # acusação. Piso escolhido à mão ainda encolhe de valor relativo a cada chave # nova, sem avisar. O que separa "régua truncada" de "chave faltando" é contar # a MESMA régua duas vezes, por caminhos independentes: a lista acima e uma # contagem direta no install.sh, de um processo só — sem pipeline, logo sem # leitura parcial. Batendo, a régua está inteira e as acusações abaixo têm # chão; divergindo, ou voltando o pipeline acima com status ≠ 0, o desfecho é # INCONCLUSIVO — nunca "chave faltando". A contagem direta é por CHAVE ÚNICA, # como a lista: `envq DOMAIN` escrito em dois ramos de um `if` é uma chave só, # e contar linhas acusaria régua truncada para sempre com a régua inteira. # # A contagem dupla fecha a truncagem, mas não era ela a causa das acusações # soltas da issue #1153: as rodadas registradas acusaram uma ou duas chaves # espalhadas, e uma régua truncada perde a CAUDA — para deixar de fora aquelas # chaves teria de acusar de 14 a 54 ao mesmo tempo. O que produz uma acusação # solta é a checagem POR CHAVE, que era um `printf | grep -qx` por chave: um # processo por chave, que pode falhar sozinho sob carga, lido pelo `&&` como # "ausente" para QUALQUER status ≠ 0. `na_regua` responde a pertença sem abrir # processo nenhum. Qual falha do sistema devolvia o status ≠ 0 não foi medido # (carga ~17: 0 em 6000); o conserto não depende de saber. na_regua() { case $'\n'"$GRAVA"$'\n' in *$'\n'"$1"$'\n'*) return 0 ;; esac; return 1; } n_grava="$(printf '%s\n' "$GRAVA" | grep -c . || true)" n_real="$(awk 'match($0, /^[[:space:]]*envq [A-Z_0-9]+/) { k = substr($0, RSTART, RLENGTH); sub(/^[[:space:]]*envq /, "", k); u[k] = 1 } END { n = 0; for (k in u) n++; print n }' install.sh)" || regua_quebrou=1 if [ "${regua_quebrou:-0}" -ne 0 ] || [ "${n_grava:-0}" -ne "${n_real:-0}" ]; then printf ' ✗ a lista de escrita voltou com %s chave(s) contra %s na contagem direta — a régua está truncada, não o install.sh\n' "${n_grava:-0}" "${n_real:-0}" printf ' (cenário INCONCLUSIVO: sem régua inteira, toda acusação abaixo seria falsa)\n' fail=1 else novas="" for k in $(grep -oE '^[A-Z_0-9]+=' "$EXEMPLO" | tr -d '=' | sort -u); do na_regua "$k" && continue case " $DIVIDA " in *" $k "*) continue ;; esac novas="$novas $k" done if [ -n "$novas" ]; then printf ' ✗ o .env.hostgator.example promete chave(s) que o install.sh não grava:%s\n' "$novas" printf ' quem instalar pelo kit não recebe essa configuração; quem puser à mão perde no próximo install\n' fail=1 else printf ' ✓ nenhuma chave nova fora da lista de escrita\n' fi # Só com a régua inteira: no ramo inconclusivo, conferir a dívida contra uma # régua que não temos imprimiria um ✓ calculado sobre nada. estagnada="" for k in $DIVIDA; do na_regua "$k" && estagnada="$estagnada $k" done if [ -n "$estagnada" ]; then printf ' ✗ já é gravada pelo install.sh — tire da lista DÍVIDA deste teste:%s\n' "$estagnada" fail=1 else printf ' ✓ dívida ainda condiz (%s chaves conhecidas, só pode encolher)\n' "$(printf '%s' "$DIVIDA" | wc -w | tr -d ' ')" fi fi fi echo "resposta afirmativa (resposta_sim)" # O gate do DNS comparava a resposta com a string "s" EXATA: quem digitava "S" # ou "sim" — a resposta certa, com a tecla errada — era morto por um `die` que # ainda dizia "Ajuste o DNS", frase que não corresponde ao que a pessoa # escolheu. Mesmo defeito no reset-mfa.sh. Estes casos são o contrato de que # nenhum prompt do kit volte a ler a intenção pela grafia. sim_ok() { # sim_ok local desc="$1" esperado="$2" val="${3-}" real if resposta_sim "$val"; then real=sim; else real=nao; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (esperava %s, deu %s para "%s")\n' "$desc" "$esperado" "$real" "$val"; fail=1; fi } sim_ok "s minúsculo" sim "s" sim_ok "S maiúsculo" sim "S" sim_ok "sim por extenso" sim "sim" sim_ok "SIM em caixa alta" sim "SIM" sim_ok "y (teclado em inglês)" sim "y" sim_ok "yes" sim "yes" sim_ok "si (español)" sim "si" sim_ok "sí com acento" sim "sí" sim_ok "Sí maiúsculo" sim "Sí" sim_ok "SÍ em caixa alta" sim "SÍ" sim_ok "espaço em volta" sim " s " sim_ok "Enter (vazio) é não" nao "" sim_ok "n" nao "n" sim_ok "nao" nao "nao" sim_ok "não com acento" nao "não" sim_ok "palavra qualquer" nao "talvez" sim_ok "'sims' não vira sim" nao "sims" echo "gêmeas: resposta_sim vale nos DOIS arquivos" # Esta suíte sourceia install.sh, mas outros blocos sourceiam _common.sh — e a # definição que sobrevive é a do último. Descoberto sabotando: com a gêmea do # install.sh devolvendo "sim" para tudo, os casos acima continuavam VERDES, # porque quem respondia era a cópia boa do _common.sh. Metade da correção # estava sem rede. Cada gêmea passa a ser exercitada dentro do seu arquivo, # num shell separado. gemea_ok() { # gemea_ok local arq="$1" val="$2" esperado="$3" real if bash -c 'INSTALL_SH_LIB=1 . "./$0" >/dev/null 2>&1; resposta_sim "$1"' "$arq" "$val" then real=sim; else real=nao; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s: "%s" → %s\n' "$arq" "$val" "$real" else printf ' ✗ %s: "%s" deu %s, esperava %s\n' "$arq" "$val" "$real" "$esperado"; fail=1; fi } for arquivo in install.sh _common.sh; do gemea_ok "$arquivo" "S" sim gemea_ok "$arquivo" "sim" sim gemea_ok "$arquivo" "sí" sim gemea_ok "$arquivo" "nao" nao gemea_ok "$arquivo" "" nao done echo "RAM: o aviso não pode cair em quem comprou a VPS recomendada" # MemTotal é sempre MENOR que o vendido (o kernel reserva). Medido: 8 GiB # configurados reportam 8025284 KB (95,7%). Os valores abaixo são o que cada # tamanho de VPS realmente reporta — o de 4 GB é o caso que este teste existe # para proteger, nas duas convenções em que provedores vendem "4 GB". ram_ok() { # ram_ok local desc="$1" esperado="$2" kb="$3" real if ram_abaixo_do_recomendado "$kb"; then real=avisa; else real=silencia; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (%s KB → %s, esperava %s)\n' "$desc" "$kb" "$real" "$esperado"; fail=1; fi } ram_ok "VPS de 4 GiB (95,7% reportado)" silencia 4012000 ram_ok "VPS de 4 GB decimais (pior caso)" silencia 3735000 ram_ok "VPS de 8 GB (medido de verdade)" silencia 8025284 ram_ok "VPS de 3 GB — abaixo do recomendado" avisa 2900000 ram_ok "VPS de 2 GB — o plano que não dá conta" avisa 1950000 echo "saúde do app (wait_app_healthy)" # O install.sh dava o app por bom quando a PORTA 3000 aceitava conexão — o que # acontece assim que o Node sobe, antes de ele saber se alcança o banco. O caso # "corpo vazio" abaixo é exatamente esse: com o probe antigo era verde, e o # "Instalação concluída!" saía por cima de um app quebrado. # Os payloads abaixo são o CONTRATO REAL da rota, capturado do app em produção # — não um formato inventado aqui. A versão anterior destes testes mockava # {"status":"ok"}, que o produto NUNCA emite: `ok` é o vocabulário dos checks # individuais, e o status geral usa healthy|degraded|unhealthy. O teste passava # validando um contrato que não existia. HEALTHY='{"data":{"status":"healthy","version":"0.1.0","checks":{"supabase":{"status":"ok","latency_ms":268},"redis":{"status":"ok","latency_ms":4},"waha":{"status":"ok","latency_ms":6}}}}' DEGRADED='{"data":{"status":"degraded","checks":{"supabase":{"status":"ok"},"waha":{"status":"degraded","error":"not_configured"}}}}' UNHEALTHY='{"data":{"status":"unhealthy","checks":{"supabase":{"status":"down","error":"http_500"},"redis":{"status":"ok"}}}}' saude_ok() { # saude_ok local desc="$1" esperado="$2" st="$3" corpo="$4" real if ST="$st" CORPO="$corpo" bash -c ' . ./_common.sh app_health_probe() { printf "%s\n%s\n" "${ST}" "${CORPO}"; } wait_app_healthy 2 0 ' >/dev/null 2>&1 then real=saudavel; else real=nao; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } saude_ok "healthy (payload real de produção)" saudavel healthy "$HEALTHY" saude_ok "degraded: serviço opcional sem config" saudavel degraded "$DEGRADED" saude_ok "unhealthy AINDA QUE o redis esteja ok" nao unhealthy "$UNHEALTHY" saude_ok "porta aberta, app mudo" nao '' '' saude_ok "proxy devolveu HTML de erro" nao '' '502 Bad Gateway' echo "healthcheck.sh: veredito pelo status GERAL e código de saída (#4087)" # O defeito: o healthcheck procurava `"status":"ok"` no JSON cru. `ok` é o # vocabulário dos CHECKS individuais, então um app com o BANCO FORA (status # geral `unhealthy`) mas com o Redis de pé casava no `checks.redis` e imprimia # "✓ app saudável" — e, pior, saía 0: nem cron nem monitor podiam usá-lo como # alarme. Medido com o payload UNHEALTHY acima, no script de antes da correção: # ✓ app saudável # EXIT=0 # A prova abaixo é de ponta a ponta e sem Docker nem rede: `docker` e `crontab` # são dublês, e o dublê do `exec` devolve as DUAS linhas que app_health_probe # produz (status geral, corpo). diagnostico_ok() { # diagnostico_ok <0|1> local desc="$1" esperado="$2" st="$3" corpo="$4" real rc if ST="$st" CORPO="$corpo" bash -c ' . ./_common.sh relatar_saude_do_app "$(printf "%s\n%s\n" "${ST}" "${CORPO}")" ' >/dev/null 2>&1 then real=0; else real=1; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } diagnostico_ok "healthy: todos os checks ok" 0 healthy "$HEALTHY" diagnostico_ok "unhealthy com redis ok (o caso do #4087)" 1 unhealthy "$UNHEALTHY" diagnostico_ok "degraded: não é 'saudável' no diagnóstico" 1 degraded "$DEGRADED" diagnostico_ok "status fora do vocabulário (sem_status)" 1 sem_status '{"erro":"rota antiga"}' diagnostico_ok "app mudo: sonda vazia" 1 '' '' # Regressão do grep mentiroso: se alguém voltar a decidir pelo texto do JSON em # vez do status geral, o healthcheck volta a mentir. A varredura é no código, # não nos comentários — por isso o literal não aparece em comentário nenhum. if grep -qF '"status":"ok"' ./healthcheck.sh; then printf ' ✗ healthcheck.sh voltou a procurar o status `ok` dos checks no JSON cru\n'; fail=1 else printf ' ✓ healthcheck.sh não decide mais pelo `ok` dos checks\n' fi if grep -q 'app_health_probe' ./healthcheck.sh && grep -q 'relatar_saude_do_app' ./healthcheck.sh; then printf ' ✓ healthcheck.sh usa a sonda e o veredito do _common.sh\n' else printf ' ✗ healthcheck.sh não usa app_health_probe/relatar_saude_do_app\n'; fail=1 fi hc_dir="$(mktemp -d)" cp ./healthcheck.sh ./_common.sh ./_i18n.sh ./_manifestos.sh "$hc_dir/" printf 'NEXT_PUBLIC_SUPABASE_URL=\n' > "$hc_dir/.env" : > "$hc_dir/docker-compose.prod.yml" mkdir -p "$hc_dir/bin" cat > "$hc_dir/bin/docker" <<'DUBLE' #!/usr/bin/env bash # Dublê do `docker compose … exec`: devolve o que a sonda do Node devolveria. if [ -n "${HC_VAZIO:-}" ]; then exit 1; fi case " $* " in *" exec "*) printf '%s\n%s\n' "${HC_STATUS:-sem_status}" "${HC_CORPO:-}" ;; esac exit 0 DUBLE printf '#!/usr/bin/env bash\nexit 1\n' > "$hc_dir/bin/crontab" chmod +x "$hc_dir/bin/docker" "$hc_dir/bin/crontab" healthcheck_ok() { # healthcheck_ok <0|1> local desc="$1" esperado="$2" verde_esperado="$3" st="$4" corpo="$5" out rc verde out="$(cd "$hc_dir" && PATH="$hc_dir/bin:$PATH" HC_STATUS="$st" HC_CORPO="$corpo" \ bash healthcheck.sh 2>&1)" rc=$? if printf '%s' "$out" | grep -q '✓ app saudável'; then verde=sim; else verde=nao; fi if [ "$rc" = "$esperado" ] && [ "$verde" = "$verde_esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (saiu %s, esperava %s; "saudável": %s, esperava %s)\n' \ "$desc" "$rc" "$esperado" "$verde" "$verde_esperado"; fail=1 fi } healthcheck_ok "banco fora + redis ok ⇒ REPROVA (sai 1)" 1 nao unhealthy "$UNHEALTHY" healthcheck_ok "healthy de verdade ⇒ APROVA (sai 0)" 0 sim healthy "$HEALTHY" healthcheck_ok "degraded ⇒ REPROVA (sai 1)" 1 nao degraded "$DEGRADED" healthcheck_ok "status desconhecido ⇒ REPROVA (sai 1)" 1 nao sem_status '{"erro":"rota antiga"}' out_mudo="$(cd "$hc_dir" && PATH="$hc_dir/bin:$PATH" HC_VAZIO=1 bash healthcheck.sh 2>&1)" rc_mudo=$? if [ "$rc_mudo" = 1 ] && ! printf '%s' "$out_mudo" | grep -q '✓ app saudável'; then printf ' ✓ app não respondeu ⇒ REPROVA (sai 1)\n' else printf ' ✗ app não respondeu (saiu %s; nunca pode sair 0)\n' "$rc_mudo"; fail=1 fi rm -rf "$hc_dir" echo "rascunho das respostas (save_partial → load_env)" # Quem trava na connection string — a pergunta mais difícil, e a última das # credenciais — perdia as 11 respostas anteriores. O que importa aqui é o # ROUND-TRIP: o valor que volta tem de ser byte a byte o que foi digitado, # senão a retomada entrega uma senha adulterada e o erro só aparece lá no # psql. Os valores abaixo são os que quebram parser ingênuo. partial_ok() { # partial_ok # kit capturado ANTES do cd: dentro de $( cd "$dir" && … ) o $PWD já é o # temporário, e passar ele como origem dos scripts fazia o subshell não achar # nem install.sh nem _common.sh — e o round-trip voltava vazio, indistinguível # de "o valor se perdeu no arquivo". local desc="$1" val="$2" dir out kit="$PWD" dir="$(mktemp -d)" # As duas fontes: envq/save_partial vivem no install.sh, load_env no # _common.sh — e o guard de biblioteca do install.sh retorna antes de # sourceá-lo. Carregar só um dos dois deixa a metade que falta indefinida, e # o round-trip volta vazio como se o valor tivesse se perdido. out="$(cd "$dir" && PARTIAL_FILE=".p" bash -c ' . "$1/_common.sh" INSTALL_SH_LIB=1 . "$1/install.sh" SENHA="$2" save_partial SENHA unset SENHA load_env .p printf "%s" "$SENHA" ' _ "$kit" "$val")" rm -rf "$dir" if [ "$out" = "$val" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n escreveu: [%s]\n voltou: [%s]\n' "$desc" "$val" "$out"; fail=1; fi } partial_ok "senha simples" 'abc123' partial_ok "com espaço" 'minha senha boa' partial_ok "com # (não é comentário)" 'se#nha' partial_ok "com \$ (não expande)" 'se$nha$HOME' partial_ok "com aspa simples" "se'nha" partial_ok "com aspas duplas" 'se"nha"' partial_ok "com barra invertida" 'C:\rota\nova' partial_ok "com crase" 'se`nha`' partial_ok "connection string real" 'postgresql://postgres.abc:p%40ss@aws-1-sa-east-1.pooler.supabase.com:5432/postgres' echo "formato do .env: os TRÊS consumidores leem o que o envq escreve" # O .env não tem um leitor, tem três, e cada um traz um parser diferente: # # 1. `load_env` (_common.sh) — leitura manual, por onde passa todo script do kit # 2. `env_file: .env` do docker-compose.prod.yml (:34 e :71) # 3. `source .env && curl …` — a receita do README (:143) # # Até 2026-08 esta suíte só exercitava o (1), e com um fixture sem apóstrofo. O # (2) é o buraco por onde o defeito passou: com aspas simples, o envq gravava # `APP_NAME='Sant'\''Ana Odontologia'` — shell válido, e recusado INTEIRO pelo # parser de dotenv do Compose (medido no v2.38.2): # # failed to read .env: line 1: unexpected character "\" in variable name # "\''Ana Odontologia'" # # Não era um comando: `config`, `ps` e `pull` saíam todos rc=1. O comprador # terminava a instalação com Supabase provisionado, schema aplicado, admin # criado, e todo comando docker do kit morto — por causa do apóstrofo do nome da # clínica dele. # # Por isso a lista de valores é UMA só e os três blocos abaixo a percorrem # inteira: um encoding que agrada dois leitores e quebra o terceiro é # exatamente a forma que o defeito teve. ENV_CASOS=( "apóstrofo — o caso que quebrava o Compose|Sant'Ana Odontologia" 'aspas duplas|Casa "Bela"' 'cifrão não expande|Loja P$ss' 'cerquilha não é comentário|Loja #1' "combinado, como um nome real|D'Ávila & Cia #2 \$X" 'barra invertida|C:\rota\nova' 'senha com apóstrofo|se nh@ Sant'"'"'Ana 8' # A crase é o caractere que separa "valor errado" de "comando executado": sem # escape, o `source` do README roda o que estiver entre elas. RESIDUAL MEDIDO: # o parser de dotenv do Compose desfaz `\"`, `\\` e `\$`, mas NÃO desfaz a # crase escapada — o contêiner recebe `Loja \`date\` Ltda`. Escapá-la assim # mesmo é a escolha registrada no comentário do envq (valor feio no contêiner # < execução de comando). Os dois outros consumidores recebem o valor intacto, # e é isso que os casos abaixo exigem deles. 'crase (sem escape o source EXECUTA)|Loja `date` Ltda' ) # Escreve UM .env com o envq REAL do install.sh, na pasta pedida. Sai do # install.sh de verdade (não uma reimplementação): um envq copiado para cá # ficaria verde com o install.sh sabotado, que é o modo de falha registrado no # bloco `reexec_neg` no fim deste arquivo. env_fixture() { # env_fixture rm -f "$1/.env" ( cd "$1" && KIT="$2" VAL="$3" bash -c ' INSTALL_SH_LIB=1 . "$KIT/install.sh" envq APP_NAME "$VAL" > .env ' ) # A pasta do bloco do Compose é REUSADA entre os casos: sem esta conferência, # uma geração que falhasse deixaria o .env do caso ANTERIOR no lugar e o caso # seguinte passaria medindo o fixture do vizinho — verde por vacuidade. [ -s "$1/.env" ] } le_ok() { # le_ok local desc="$1" val="$2" dir out kit="$PWD" dir="$(mktemp -d)" if ! env_fixture "$dir" "$kit" "$val"; then printf ' ✗ %s — o envq não gerou .env nenhum\n' "$desc"; fail=1; rm -rf "$dir"; return fi out="$(cd "$dir" && KIT="$kit" bash -c ' . "$KIT/_common.sh" load_env .env printf "%s" "$APP_NAME" ')" rm -rf "$dir" if [ "$out" = "$val" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n escreveu: [%s]\n voltou: [%s]\n' "$desc" "$val" "$out"; fail=1; fi } # Este é o consumidor que NÃO perdoa: `source` é o shell interpretando o # arquivo, então uma crase mal escapada não devolve valor errado — EXECUTA. É # por isso que o envq escapa a crase mesmo sabendo que o Compose não a desfaz. src_ok() { # src_ok local desc="$1" val="$2" dir out kit="$PWD" dir="$(mktemp -d)" if ! env_fixture "$dir" "$kit" "$val"; then printf ' ✗ %s — o envq não gerou .env nenhum\n' "$desc"; fail=1; rm -rf "$dir"; return fi # Processo separado: se o encoding regredir, quem executa o conteúdo do .env # é este bash descartável, não a suíte. out="$(cd "$dir" && bash -c 'set -a; . ./.env; set +a; printf "%s" "$APP_NAME"' 2>/dev/null)" rm -rf "$dir" if [ "$out" = "$val" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n escreveu: [%s]\n voltou: [%s]\n' "$desc" "$val" "$out"; fail=1; fi } echo " consumidor 1 — load_env (todo script do kit)" for _caso in "${ENV_CASOS[@]}"; do le_ok "${_caso%%|*}" "${_caso#*|}"; done echo " consumidor 3 — source (a receita do README)" for _caso in "${ENV_CASOS[@]}"; do src_ok "${_caso%%|*}" "${_caso#*|}"; done unset _caso echo " consumidor 2 — docker compose (env_file: .env)" # `docker compose config` é 100% client-side: não fala com o daemon nem baixa # imagem (medido — com DOCKER_HOST apontando para um socket inexistente ele # ainda acusa o erro de parse do .env). Ou seja, cabe no que o cabeçalho deste # arquivo promete: sem rede. # # A asserção é "o Compose CONSEGUE LER o arquivo", e não a igualdade do valor, # por uma razão medida: a saída do `config` re-escapa `$` como `$$` (é o # encoding de interpolação do próprio compose), então comparar byte a byte # reprovaria um arquivo correto. E ler é o que o defeito impedia — rc=1 em # config, ps e pull. if ! docker compose version >/dev/null 2>&1; then # Pulo em voz alta, nomeando o que ficou sem cobertura: pulo silencioso é # indistinguível de teste que passou. printf ' — pulado: sem `docker compose` nesta máquina\n' printf ' NÃO foi medido: se o .env gerado pelo envq é legível pelo `env_file:` do compose\n' printf ' (é o consumidor pelo qual o defeito do apóstrofo passou; os outros dois acima rodaram)\n' else DC_DIR="$(mktemp -d)" cat > "$DC_DIR/docker-compose.yml" <<'YML' services: app: image: alpine:3.20 env_file: .env YML dc_ok() { # dc_ok local desc="$1" val="$2" err rc kit="$PWD" if ! env_fixture "$DC_DIR" "$kit" "$val"; then printf ' ✗ %s — o envq não gerou .env nenhum\n' "$desc"; fail=1; return fi err="$(cd "$DC_DIR" && docker compose config -q 2>&1)"; rc=$? if [ $rc -eq 0 ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s — o Compose recusou o .env (rc=%s)\n %s\n' "$desc" "$rc" "$(printf '%s' "$err" | head -1)"; fail=1; fi } for _caso in "${ENV_CASOS[@]}"; do dc_ok "${_caso%%|*}" "${_caso#*|}"; done unset _caso # CONTROLE POSITIVO. Sem ele os casos acima passariam por vacuidade: um # `docker compose config` que ignorasse o env_file, ou um .env vazio, também # sairiam rc=0. Aqui o formato ANTIGO é escrito à mão — é o que o kit gravava # antes de 2026-08 — e TEM de ser recusado. Se um dia isto ficar verde, o # Compose passou a aceitar `'\''` e a razão de existir do encoding novo mudou: # releia o comentário do envq antes de mexer em qualquer coisa. cat > "$DC_DIR/.env" <<'EOF' APP_NAME='Sant'\''Ana Odontologia' EOF if (cd "$DC_DIR" && docker compose config -q >/dev/null 2>&1); then printf ' ✗ controle positivo: o Compose ACEITOU o formato antigo de aspas simples\n' printf ' os casos acima deixaram de distinguir o defeito da correção\n'; fail=1 else printf ' ✓ controle positivo: o formato ANTIGO (aspas simples) é recusado pelo Compose\n' fi rm -rf "$DC_DIR" fi echo "retrocompatibilidade: o .env de uma instalação antiga continua legível" # Quem instalou antes de 2026-08 tem um .env em aspas simples com `'\''`, e ele # NÃO é reescrito ao atualizar: o update.sh só troca APP_IMAGE e APP_PULL_POLICY # (:159 e :165) e deixa as outras chaves como estavam. Se o ramo de # aspas simples do load_env sumir num "agora é tudo aspas duplas", o kit novo # passa a devolver senha e connection string com quatro caracteres a mais, e a # instalação antiga quebra na atualização, longe de qualquer pista. # # O fixture é escrito à mão, no formato ANTIGO, de propósito: gerá-lo com o # envq de hoje mediria o formato de hoje e não teria nada de retrocompatível. TMP_LEGADO="$(mktemp -d)" cat > "$TMP_LEGADO/.env" <<'EOF' APP_NAME='Sant'\''Ana Odontologia' SENHA_LEGADA='se'\''nha com espaço' DB_LEGADA='postgresql://postgres.abc:p%40ss@aws-1-sa-east-1.pooler.supabase.com:5432/postgres' CIFRAO_LEGADO='p$ass' EOF ( . ./_common.sh load_env "$TMP_LEGADO/.env" eq() { if [ "$2" = "$3" ]; then printf ' ✓ %s\n' "$1"; else printf ' ✗ %s esperava [%s] obteve [%s]\n' "$1" "$3" "$2"; exit 1; fi; } eq "nome antigo com apóstrofo" "$APP_NAME" "Sant'Ana Odontologia" eq "senha antiga com apóstrofo" "$SENHA_LEGADA" "se'nha com espaço" eq "connection string antiga" "$DB_LEGADA" 'postgresql://postgres.abc:p%40ss@aws-1-sa-east-1.pooler.supabase.com:5432/postgres' eq "cifrão antigo não expande" "$CIFRAO_LEGADO" 'p$ass' ) || fail=1 rm -rf "$TMP_LEGADO" echo "cron: instalar uma instância não pode silenciar a outra" # Fixture = o crontab REAL de uma VPS com produção rodando (o Bearer trocado por # placeholder). O filtro antigo era `grep -v 'event-log-drain'`, que casava com # a linha de QUALQUER instalação: subir uma segunda instância na mesma máquina # apagava as duas linhas da primeira, em silêncio. CRONTAB_VIZINHO='0 8 * * * /root/trend-radar/run_full_vps.sh * * * * * curl -fsS -H "Authorization: Bearer SEGREDO" "https://crm.deskcomm.com.br/api/v1/cron/event-log-drain" >/dev/null 2>&1 */5 * * * * cd /root/Aula-Youtube/DeskcommCRM && bash hostgator-setup-kit/agent.sh >/dev/null 2>&1' cron_ok() { # cron_ok local desc="$1" espera="$2" marcador="$3" legado="$4" nova="$5" out out="$(printf '%s\n' "$CRONTAB_VIZINHO" | cron_merge "$marcador" "$legado" "$nova")" if grep -qF -e "$espera" <<<"$out"; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n sumiu do crontab: %s\n' "$desc" "$espera"; fail=1; fi } NOVO_TAG='# deskcomm:/root/instalacao-nova' NOVA_URL='https://crm-novo.exemplo.com.br/api/v1/cron/event-log-drain' cron_ok "o drain do vizinho sobrevive" 'crm.deskcomm.com.br/api/v1/cron/event-log-drain' \ "$NOVO_TAG" "$NOVA_URL" "* * * * * curl \"$NOVA_URL\" $NOVO_TAG" cron_ok "o agente do vizinho sobrevive" 'cd /root/Aula-Youtube/DeskcommCRM && bash hostgator-setup-kit/agent.sh' \ "$NOVO_TAG" "cd /root/instalacao-nova && bash hostgator-setup-kit/agent.sh" \ "*/5 * * * * cd /root/instalacao-nova && bash hostgator-setup-kit/agent.sh $NOVO_TAG" cron_ok "a linha alheia (trend-radar) sobrevive" '/root/trend-radar/run_full_vps.sh' \ "$NOVO_TAG" "$NOVA_URL" "* * * * * curl \"$NOVA_URL\" $NOVO_TAG" # Re-executar a MESMA instalação substitui a própria linha em vez de empilhar — # inclusive a legada, escrita antes de o marcador existir. reexec="$(printf '%s\n' "$CRONTAB_VIZINHO" | cron_merge '# deskcomm:/root/Aula-Youtube/DeskcommCRM' \ 'cd /root/Aula-Youtube/DeskcommCRM && bash hostgator-setup-kit/agent.sh' \ '*/5 * * * * cd /root/Aula-Youtube/DeskcommCRM && bash hostgator-setup-kit/agent.sh # deskcomm:/root/Aula-Youtube/DeskcommCRM')" n_agent="$(printf '%s\n' "$reexec" | grep -cF 'hostgator-setup-kit/agent.sh')" if [ "$n_agent" = 1 ]; then printf ' ✓ re-executar a mesma instalação não duplica a linha\n' else printf ' ✗ re-executar duplicou: %s linhas de agent.sh\n' "$n_agent"; fail=1; fi # As DUAS linhas da mesma instalação têm de coexistir. Com um marcador só por # instalação (sem o papel), a segunda função a rodar apagava a linha da # primeira — as duas casavam com o mesmo marcador. Medido na VPS: depois de # instalar sobrava só o agente, e o CRM ficava SEM o drain de eventos, com a # automação inteira parada em silêncio. Este teste roda as duas em sequência, # como a instalação faz. DIR=/root/instalacao-nova TAG_DRAIN="# deskcomm:${DIR}:drain"; TAG_AGENT="# deskcomm:${DIR}:agent" L_DRAIN="* * * * * curl \"https://novo.exemplo.com.br/api/v1/cron/event-log-drain\" $TAG_DRAIN" L_AGENT="*/5 * * * * cd ${DIR} && bash hostgator-setup-kit/agent.sh $TAG_AGENT" depois_drain="$(printf '%s\n' "$CRONTAB_VIZINHO" | cron_merge "$TAG_DRAIN" 'https://novo.exemplo.com.br/api/v1/cron/event-log-drain' "$L_DRAIN")" depois_agent="$(printf '%s\n' "$depois_drain" | cron_merge "$TAG_AGENT" "cd ${DIR} && bash hostgator-setup-kit/agent.sh" "$L_AGENT")" # Conta as DUAS linhas pelo que elas fazem (a URL do drain, o cd do agente), não # pelo formato do marcador: uma asserção sobre o marcador reprovaria uma mudança # de formato inofensiva e passaria por perto do que importa, que é as duas # tarefas continuarem agendadas. tem_drain="$(printf '%s\n' "$depois_agent" | grep -cF 'novo.exemplo.com.br/api/v1/cron/event-log-drain')" tem_agent="$(printf '%s\n' "$depois_agent" | grep -cF "cd ${DIR} && bash hostgator-setup-kit/agent.sh")" if [ "$tem_drain" -ge 1 ] && [ "$tem_agent" -ge 1 ]; then printf ' ✓ drain e agente da mesma instalação coexistem\n' else printf ' ✗ uma apagou a outra (drain=%s, agente=%s — esperava 1 de cada)\n' "$tem_drain" "$tem_agent"; fail=1 fi echo "cron: o segredo não vai para a linha do crontab (nem para o syslog)" # O `cron` do Ubuntu registra no syslog a linha de comando de cada execução. Com # o Bearer escrito na linha, o segredo das rotas de cron ia para o log a cada # minuto — medido numa VPS de produção em 2026-09-17: 24.827 linhas no journal. # O cenário parte da linha LEGADA, a que toda instalação existente tem. TMP_CRON="$(mktemp -d)" ( . ./_common.sh # Dublê em FUNÇÃO, e não no PATH: `command -v crontab` e os dois lados do cano # enxergam a função, e o crontab real de quem roda a suíte nunca é tocado. crontab() { case "${1:-}" in -l) [ -f "$TMP_CRON/crontab" ] || return 1; cat "$TMP_CRON/crontab" ;; -) cat > "$TMP_CRON/crontab.novo" && mv "$TMP_CRON/crontab.novo" "$TMP_CRON/crontab" ;; esac } step() { :; }; psql_run() { :; } PROJECT_DIR="$TMP_CRON/projeto"; mkdir -p "$PROJECT_DIR" NEXT_PUBLIC_APP_URL="https://crm.exemplo.com.br" URL="$NEXT_PUBLIC_APP_URL/api/v1/cron/event-log-drain" printf '* * * * * curl -fsS -H "Authorization: Bearer segredo-velho-a1b2c3" "%s" >/dev/null 2>&1 # deskcomm:%s:drain\n' \ "$URL" "$PROJECT_DIR" > "$TMP_CRON/crontab" CAB="$PROJECT_DIR/.env.cron-drain" checa() { if eval "$2"; then printf ' ✓ %s\n' "$1"; else printf ' ✗ %s\n' "$1"; exit 1; fi; } INTERNAL_CRON_SECRET="segredo-novo-9f8e7d"; INTERNAL_SECRET="" setup_event_log_drain_cron >/dev/null 2>&1 checa "a linha do drain continua existindo (controle de vacuidade)" \ '[ "$(grep -cF "$URL" "$TMP_CRON/crontab")" = 1 ]' checa "nenhuma linha do crontab carrega o segredo novo" \ '! grep -qF "segredo-novo-9f8e7d" "$TMP_CRON/crontab"' checa "a linha legada, com o segredo velho, foi substituída" \ '! grep -qF "segredo-velho-a1b2c3" "$TMP_CRON/crontab"' # Desde a #2235 a linha do host não carrega mais o `curl`: ela chama o VIGIA # (`hostgator-setup-kit/drain-watchdog.sh`), que só dispara o dreno quando o # contêiner `scheduler` desta instalação não está de pé. O segredo continua # fora da linha — quem lê o cabeçalho passou a ser o script, e as duas metades # são cobradas separadamente para o segredo não voltar para o crontab por # ninguém ter olhado o outro lado. checa "a linha chama o vigia do dreno (e não um curl solto)" \ 'grep -F "$URL" "$TMP_CRON/crontab" | grep -qF "drain-watchdog.sh" && ! grep -F "$URL" "$TMP_CRON/crontab" | grep -q "curl "' checa "o vigia lê o cabeçalho do arquivo" \ 'grep -qF -- "-H @\"\$cabecalho\"" ./drain-watchdog.sh' checa "o arquivo tem o cabeçalho que a rota espera" \ '[ "$(cat "$CAB")" = "Authorization: Bearer segredo-novo-9f8e7d" ]' # `stat -c` é GNU; no macOS o equivalente é `stat -f '%Lp'` (mesma forma usada mais # abaixo neste arquivo). No Windows o `stat` do Git Bash não reflete o chmod; no CI, Linux, reflete. checa "o arquivo nasce só para o dono (600)" \ '[ "$(stat -c "%a" "$CAB" 2>/dev/null || stat -f "%Lp" "$CAB" 2>/dev/null)" = 600 ]' # Trocar o segredo no `.env` e rodar o update de novo é a rotação inteira. INTERNAL_CRON_SECRET="segredo-rotacionado-4c3b2a" setup_event_log_drain_cron >/dev/null 2>&1 checa "rodar de novo com segredo novo regrava o arquivo" \ '[ "$(cat "$CAB")" = "Authorization: Bearer segredo-rotacionado-4c3b2a" ]' checa "e não empilha linha no crontab" \ '[ "$(grep -cF "$URL" "$TMP_CRON/crontab")" = 1 ]' ) || fail=1 rm -rf "$TMP_CRON" echo "provisionamento do Supabase: senha do banco" # Dois testes distintos, porque o defeito e o contrato moram em lugares # diferentes — e o primeiro teste que escrevi aqui era VÁCUO por não separá-los. # # (1) CALL SITE. O bug era a atribuição no escopo do script: com pipefail, o # SIGPIPE do `tr` virava o status da atribuição e o `set -e` matava tudo, # logo depois de a senha existir. Medido: o mesmo pipe DENTRO de uma função # sobrevive (o status passa a ser o do printf final), no escopo sai 141. # Então testar a função não pega a regressão que importa — quem pega é # rodar o script e exigir que ele CHEGUE ao passo seguinte. # O passo 3 imprime o título antes de tocar a rede, então a asserção não # depende de a API responder (e o token aqui é propositalmente inválido). saida="$(SUPABASE_ACCESS_TOKEN=token-invalido-de-teste SUPABASE_ORG_ID=org-de-teste \ SUPABASE_PROVISION_STATE="$SUITE_TMP/senha-do-teste.env" \ bash ./supabase-provision.sh "Projeto de Teste" sa-east-1 2>&1 || true)" if grep -q 'Criando o projeto' <<<"$saida"; then printf ' ✓ o script passa da geração da senha e chega ao passo de criar\n' else printf ' ✗ o script MORREU antes de criar o projeto (o defeito voltou)\n' printf ' última linha vista: %s\n' "$(printf '%s' "$saida" | sed -E 's/\x1b\[[0-9;]*m//g' | grep -v '^$' | tail -1)" fail=1 fi # (2) CONTRATO da senha. Ela entra na connection string: um '@' ou '/' aqui # parte o host no meio, e o erro só apareceria no psql. senha="$(bash -c 'set -euo pipefail; SUPABASE_PROVISION_LIB=1 . ./supabase-provision.sh; gen_db_pass' 2>/dev/null)" if [ "${#senha}" = 32 ]; then printf ' ✓ 32 caracteres\n' else printf ' ✗ senha com %s caracteres, esperava 32\n' "${#senha}"; fail=1; fi case "$senha" in *[!A-Za-z0-9]*) printf ' ✗ tem caractere que quebra a connection string\n'; fail=1;; '') printf ' ✗ senha vazia\n'; fail=1;; *) printf ' ✓ só alfanuméricos (não parte a connection string)\n';; esac echo "provisionamento do Supabase: leitura das chaves e senha do banco" # POR QUE ESTES CENÁRIOS EXISTEM (issue #856): o GET /projects//api-keys # passou a devolver `api_key` ANTES de `name`, e a leitura antiga casava # `"name":"anon"` e só então procurava `api_key` no que vinha DEPOIS, até o `}`. # No dia em que a API mudou, o passo 5 morreu com "Não consegui ler # anon/service_role" num projeto JÁ criado — e a senha do banco, que só existia # na memória do processo, foi junto (a vaga do plano grátis também). # # Por isso os cenários abaixo rodam o SCRIPT INTEIRO contra uma API de mentira # (dublês de curl e de docker no PATH, nada de rede): provar que a função de # leitura lê não prova que a instalação deixa de morrer no passo 5, e é o script # inteiro que quem instala roda. O CONTROLE é a resposta na ordem ANTIGA (a que # sempre funcionou) e o CENÁRIO OPOSTO é a resposta SEM as chaves — que tem de # morrer, e morrer deixando a senha no disco. PROV_TMP="$SUITE_TMP/provisionamento" KIT_DIR="$(pwd)" mkdir -p "$PROV_TMP/bin" "$PROV_TMP/proj" cat > "$PROV_TMP/bin/curl" <<'DUBLECURL' #!/usr/bin/env bash # Dublê de curl: responde o que o supabase-provision.sh pergunta, a partir da # fixture que o cenário apontou em DUBLE_CHAVES. A ordem dos casos importa — # .../api-keys também casa com */projects/*, e vem primeiro. url="" for a in "$@"; do case "$a" in https://api.supabase.com/*) url="$a" ;; esac; done case "$url" in */api-keys) cat "${DUBLE_CHAVES:?dublê de curl sem DUBLE_CHAVES}" ;; */projects/*) printf '{"status":"ACTIVE_HEALTHY"}' ;; */projects) printf '{"ref":"%s"}' "${DUBLE_REF:-abcdefghijklmnop}" ;; *) printf '{"message":"dublê sem resposta para %s"}' "$url"; exit 22 ;; esac DUBLECURL cat > "$PROV_TMP/bin/docker" <<'DUBLEDOCKER' #!/usr/bin/env bash # Dublê de docker: o passo 6 PROVA cada host de pooler com uma conexão real. # Aqui o primeiro candidato responde — o teste não é sobre o pooler, é sobre a # senha chegar inteira até lá. printf '%s\n' "$*" >> "${DOCKER_LOG:-/dev/null}" exit 0 DUBLEDOCKER chmod +x "$PROV_TMP/bin/curl" "$PROV_TMP/bin/docker" # Fixtures: o essencial de cada forma da resposta (valores obviamente de teste). cat > "$PROV_TMP/chaves-ordem-nova.json" <<'JSON' [{"api_key":"chave-anon-nova","id":"a1","type":"publishable","name":"anon"},{"api_key":"chave-service-nova","id":"a2","type":"secret","name":"service_role"}] JSON cat > "$PROV_TMP/chaves-ordem-antiga.json" <<'JSON' [{"id":"a1","name":"anon","api_key":"chave-anon-antiga"},{"id":"a2","name":"service_role","api_key":"chave-service-antiga"}] JSON cat > "$PROV_TMP/chaves-sem-as-chaves.json" <<'JSON' [{"api_key":"chave-de-outra-coisa","id":"a1","name":"outra"}] JSON # rodar_prov [senha imposta] # → stdout em $PROV_TMP/out, stderr em $PROV_TMP/err, código em $prov_rc. # Os dois canais ficam separados porque é o stdout (as 4 linhas do .env) que # carrega a senha em claro, e o stderr é o resumo visual — que não pode # carregá-la. prov_rc=0 rodar_prov() { ( cd "$PROV_TMP/proj" && env PATH="$PROV_TMP/bin:$PATH" \ SUPABASE_ACCESS_TOKEN=token-de-teste SUPABASE_ORG_ID=org-de-teste \ SUPABASE_DB_PASS="${4:-}" SUPABASE_PROVISION_STATE="$3" \ DUBLE_CHAVES="$1" DUBLE_REF=abcdefghijklmnop DOCKER_LOG="$PROV_TMP/docker.log" \ bash "$KIT_DIR/supabase-provision.sh" "$2" sa-east-1 ) >"$PROV_TMP/out" 2>"$PROV_TMP/err" prov_rc=$? } senha_do_estado() { [ -f "$1" ] && sed -n "s/^SUPABASE_DB_PASS='\(.*\)'$/\1/p" "$1" | head -1 || true; } url_do_estado() { grep -qF "postgres.abcdefghijklmnop:$1@aws-0-sa-east-1.pooler.supabase.com:5432/postgres" "$2"; } # (1) O CASO DA ISSUE: api_key ANTES de name. A asserção cobra o VALOR lido, não # a presença da linha — presença passaria com qualquer chave. rodar_prov "$PROV_TMP/chaves-ordem-nova.json" "Projeto de Teste" "$PROV_TMP/estado-novo" if [ "$prov_rc" -eq 0 ] \ && grep -qF "NEXT_PUBLIC_SUPABASE_ANON_KEY='chave-anon-nova'" "$PROV_TMP/out" \ && grep -qF "SUPABASE_SERVICE_ROLE_KEY='chave-service-nova'" "$PROV_TMP/out"; then printf ' ✓ lê as chaves com api_key ANTES de name (o defeito da #856 não volta)\n' else printf ' ✗ não leu as chaves na ordem nova (rc=%s)\n' "$prov_rc" printf ' o script disse: %s\n' "$(sed -E 's/\x1b\[[0-9;]*m//g' "$PROV_TMP/err" | grep -v '^$' | tail -2 | tr '\n' ' ')" fail=1 fi # (2) A outra metade da issue: a senha do banco. Ela tem de existir em arquivo de # 600, com 32 caracteres, e ser EXATAMENTE a que entrou na connection string. senha1="$(senha_do_estado "$PROV_TMP/estado-novo")" # `stat -c` é GNU; no macOS o equivalente é `stat -f '%Lp'`. Sem o segundo ramo, a # asserção abaixo reprova na máquina de quem tria (o `|| printf '?'` engole o erro # e o modo vira '?'), com um ✗ que não é do conserto. Medido em Darwin 25.4.0: # `stat -c '%a' /etc/hosts` → "stat: illegal option -- c". modo1="$(stat -c '%a' "$PROV_TMP/estado-novo" 2>/dev/null || stat -f '%Lp' "$PROV_TMP/estado-novo" 2>/dev/null || printf '?')" if [ "${#senha1}" -eq 32 ] && [ "$modo1" = 600 ] && url_do_estado "$senha1" "$PROV_TMP/out"; then printf ' ✓ senha guardada em 600 e é a mesma que foi para a connection string\n' else printf ' ✗ a senha não sobreviveu (caracteres=%s, modo=%s)\n' "${#senha1}" "$modo1" fail=1 fi # (3) E ela NÃO aparece no resumo visual: quem instala costuma mandar print # pedindo ajuda, e a senha do banco dá acesso direto ao banco. if [ -n "$senha1" ] && grep -qF "$senha1" "$PROV_TMP/err"; then printf ' ✗ a senha apareceu em claro no resumo (stderr)\n'; fail=1 else printf ' ✓ o resumo visual segue mascarado (senha só no arquivo e no .env)\n' fi # (4) CONTROLE: a ordem ANTIGA continua funcionando. Sem este cenário, um # conserto que só soubesse ler a ordem nova passaria no teste da #856 e # quebraria onde a API ainda responde na ordem antiga. rodar_prov "$PROV_TMP/chaves-ordem-antiga.json" "Projeto de Teste" "$PROV_TMP/estado-antigo" if [ "$prov_rc" -eq 0 ] \ && grep -qF "NEXT_PUBLIC_SUPABASE_ANON_KEY='chave-anon-antiga'" "$PROV_TMP/out" \ && grep -qF "SUPABASE_SERVICE_ROLE_KEY='chave-service-antiga'" "$PROV_TMP/out"; then printf ' ✓ lê as chaves também com name antes de api_key (ordem antiga)\n' else printf ' ✗ a ordem antiga parou de funcionar (rc=%s)\n' "$prov_rc"; fail=1 fi # (5) CENÁRIO OPOSTO: resposta SEM anon/service_role (API mudou de novo, ou token # de outra organização). O certo é MORRER — e morrer dizendo onde a senha # ficou, para ninguém recriar o projeto e queimar a segunda vaga do grátis. rodar_prov "$PROV_TMP/chaves-sem-as-chaves.json" "Projeto de Teste" "$PROV_TMP/estado-sem-chaves" falou_motivo=""; grep -qF 'Não consegui ler anon/service_role' "$PROV_TMP/err" && falou_motivo=1 falou_onde="" [ -f "$PROV_TMP/estado-sem-chaves" ] && grep -qF 'a senha do banco está guardada em' "$PROV_TMP/err" && falou_onde=1 if [ "$prov_rc" -ne 0 ] && [ -n "$falou_motivo" ] && [ -n "$falou_onde" ]; then printf ' ✓ resposta sem as chaves morre pelo motivo certo e diz onde a senha ficou\n' else printf ' ✗ esperava morrer dizendo o motivo e onde a senha ficou (rc=%s, motivo=%s, caminho=%s)\n' \ "$prov_rc" "${falou_motivo:-não}" "${falou_onde:-não}"; fail=1 fi # (6) RETOMADA: rodar de novo com o MESMO arquivo e o MESMO projeto reaproveita a # senha. Gerar outra aqui é o que deixaria o banco com uma senha órfã. senha_antes="$(senha_do_estado "$PROV_TMP/estado-sem-chaves")" rodar_prov "$PROV_TMP/chaves-ordem-nova.json" "Projeto de Teste" "$PROV_TMP/estado-sem-chaves" if [ "$prov_rc" -eq 0 ] && [ -n "$senha_antes" ] && url_do_estado "$senha_antes" "$PROV_TMP/out"; then printf ' ✓ a retomada reaproveita a senha guardada em vez de gerar outra\n' else printf ' ✗ a retomada trocou a senha do banco\n'; fail=1 fi # (7) CENÁRIO OPOSTO do reaproveitamento: OUTRO projeto no mesmo arquivo tem de # ganhar senha nova — guardar por máquina repetiria a senha de banco entre # dois clientes provisionados no mesmo VPS. rodar_prov "$PROV_TMP/chaves-ordem-nova.json" "Outro Projeto" "$PROV_TMP/estado-sem-chaves" senha_outro="$(senha_do_estado "$PROV_TMP/estado-sem-chaves")" if [ "$prov_rc" -eq 0 ] && [ -n "$senha_outro" ] && [ "$senha_outro" != "$senha_antes" ]; then printf ' ✓ outro projeto no mesmo arquivo gera outra senha (não repete credencial)\n' else printf ' ✗ outro projeto reaproveitou a senha do anterior\n'; fail=1 fi # (8) SUPABASE_DB_PASS imposta: a válida é a que entra na connection string; a que # tem caractere de URL (@, :) morre avisando POR QUE — ela entra crua, sem # percent-encoding, e o erro só apareceria no psql do passo 6, com cara de # problema de rede. rodar_prov "$PROV_TMP/chaves-ordem-nova.json" "Projeto de Teste" "$PROV_TMP/estado-imposta" "senha-imposta-1" if [ "$prov_rc" -eq 0 ] && url_do_estado "senha-imposta-1" "$PROV_TMP/out"; then printf ' ✓ SUPABASE_DB_PASS imposta é a que vai para a connection string\n' else printf ' ✗ SUPABASE_DB_PASS imposta não chegou à connection string\n'; fail=1 fi rodar_prov "$PROV_TMP/chaves-ordem-nova.json" "Projeto de Teste" "$PROV_TMP/estado-imposta2" "senha@com@arroba" if [ "$prov_rc" -ne 0 ] && grep -qF 'partiria o host' "$PROV_TMP/err"; then printf ' ✓ SUPABASE_DB_PASS com caractere que quebra a URL morre explicando\n' else printf ' ✗ SUPABASE_DB_PASS inválida passou (rc=%s)\n' "$prov_rc"; fail=1 fi echo "e-mails de acesso: marca-emails.sh" # POR QUE ESTE BLOCO EXISTE: o e-mail de confirmação de conta é o PRIMEIRO # artefato que um cliente do revendedor recebe, e ele é montado por um processo # de TERCEIRO (o GoTrue). Nenhum teste do app o alcança — o único jeito de # vigiar isso é exercitar o script que empurra o texto. # # Os casos abaixo cobrem tudo o que dá para provar SEM rede: renderização, # escape, e as três saídas que não podem derrubar a instalação. O caminho com # rede (PATCH + releitura) foi medido à mão contra a Management API em # 2026-08-14 e está declarado no cabeçalho do script. ME_TMP="$(mktemp -d)" # (1) Sem token, sai 0 e ENSINA o passo manual. Este é o caso comum: quem cria # o projeto no painel e cola as 4 credenciais nunca teve token nenhum. saida_me="$(SUPABASE_ACCESS_TOKEN= bash ./marca-emails.sh --env /dev/null 2>&1)"; rc_me=$? if [ $rc_me -ne 0 ]; then printf ' ✗ sem token o script saiu %s — ele NÃO pode derrubar o install.sh\n' "$rc_me"; fail=1 else printf ' ✓ sem token: sai 0 (a instalação continua)\n' fi if grep -q 'SUPABASE_ACCESS_TOKEN' <<<"$saida_me"; then printf ' ✓ sem token: diz qual é a chave que falta\n' else printf ' ✗ sem token: a mensagem não nomeia SUPABASE_ACCESS_TOKEN\n'; fail=1 fi # O passo manual tem de ensinar `&`. Foi um `?` nesta mesma receita (na doc de # deploy) que gravou o link quebrado no projeto de produção. if grep -q '{{ .RedirectTo }}&token_hash' <<<"$saida_me"; then printf ' ✓ sem token: o passo manual ensina o separador & (nunca ?)\n' else printf ' ✗ sem token: o passo manual não mostra o link com &\n'; fail=1 fi # (2) Supabase PRÓPRIO (self-hosted) não tem Management API: com token e tudo, # o certo é ensinar o caminho do GoTrue, não tentar um PATCH que não existe. saida_me="$(SUPABASE_ACCESS_TOKEN=sbp_de_teste NEXT_PUBLIC_SUPABASE_URL=https://supabase.meucliente.com.br \ bash ./marca-emails.sh --env /dev/null 2>&1)"; rc_me=$? if [ $rc_me -eq 0 ] && grep -q 'GOTRUE_MAILER_TEMPLATES' <<<"$saida_me"; then printf ' ✓ Supabase próprio: sai 0 e manda para o caminho do GoTrue\n' else printf ' ✗ Supabase próprio: rc=%s, mensagem sem GOTRUE_MAILER_TEMPLATES\n' "$rc_me"; fail=1 fi # (2b) CONTRATO, e não é preferência de estilo: `GOTRUE_MAILER_TEMPLATES_*` só # aceita URL http(s). O GoTrue COLA no fim do SITE_URL tudo o que não # começa com `http` e busca por HTTP (supabase/auth v2.196.0, # internal/mailer/templatemailer/template.go:456) — então um caminho de # arquivo não dá erro: ele faz o GoTrue pedir `https://DOMINIO/opt/...`, # receber o HTML da tela de login e mandar ISSO na caixa de entrada. # Aconteceu numa instalação real em 2026-09-09 e o Gmail marcou como # phishing. Varremos o kit inteiro porque três scripts imprimem estas # linhas hoje (install.sh, marca-emails.sh, healthcheck.sh) e o quarto que # aparecer não vai lembrar deste parágrafo. fora_do_contrato="$(grep -rhoE 'GOTRUE_MAILER_TEMPLATES_[A-Z]+=[^ "'"'"']*' ./*.sh \ | grep -vE '=(https?://|\$\{[A-Za-z_]+:-https?://)' || true)" if [ -z "$fora_do_contrato" ]; then printf ' ✓ todo GOTRUE_MAILER_TEMPLATES_* que o kit imprime é URL http(s)\n' else printf ' ✗ o kit imprime GOTRUE_MAILER_TEMPLATES_* que NÃO é URL http(s):\n' printf '%s\n' "$fora_do_contrato" | sed 's/^/ /' fail=1 fi # (2c) VACUIDADE do healthcheck: ele decide "o app serve o molde certo" # procurando `token_hash={{ .TokenHash }}` na resposta da rota. Se o # gerador do molde parar de emitir essa string, a sonda passa a responder # "versão anterior à correção" para TODA instalação — inclusive as # corretas —, e ninguém percebe, porque o aviso é plausível. Este caso # amarra os dois lados. assinatura='token_hash={{ .TokenHash }}' if grep -qF "$assinatura" ./healthcheck.sh \ && grep -qF "$assinatura" ../lib/email/templates/acesso-gotrue.ts; then printf ' ✓ a sonda do healthcheck procura a assinatura que o molde emite\n' else printf ' ✗ healthcheck e lib/email/templates/acesso-gotrue.ts discordam da assinatura\n'; fail=1 fi # (3) VACUIDADE: os modelos no disco precisam TER o placeholder, senão o caso # (4) compararia a ausência de marca com a ausência de marca e passaria. for modelo in ../supabase/templates/confirmation.html ../supabase/templates/recovery.html; do if grep -q '__APP_NAME__' "$modelo"; then printf ' ✓ %s tem __APP_NAME__ para substituir\n' "$(basename "$modelo")" else printf ' ✗ %s NÃO tem __APP_NAME__ — a substituição abaixo não prova nada\n' "$(basename "$modelo")"; fail=1 fi done # (4) Renderização com um nome HOSTIL. `&` no lado direito de um `sed` (ou de um # `${x//p/r}` no bash 5.2) vale como "o trecho casado" — medido: `Loja # Top & Cia` saía `Loja gt;Top…`. E `` cru injetaria markup # no corpo do e-mail de todo cliente do revendedor. SUPABASE_ACCESS_TOKEN= APP_NAME='Loja Top & Cia' APP_ACCENT_HEX='#f2c94c' \ bash ./marca-emails.sh --env /dev/null --render-em "$ME_TMP/render" >/dev/null 2>&1 rend="$ME_TMP/render/confirmation.html" if [ ! -f "$rend" ]; then printf ' ✗ --render-em não escreveu confirmation.html\n'; fail=1 else if grep -q '__APP_NAME__\|__ACCENT__\|__ACCENT_FG__' "$rend"; then printf ' ✗ sobrou placeholder no HTML renderizado: %s\n' "$(grep -o '__[A-Z_]*__' "$rend" | sort -u | tr '\n' ' ')"; fail=1 else printf ' ✓ nenhum placeholder sobrou no HTML renderizado\n' fi if grep -qF 'Loja <b>Top</b> & Cia' "$rend"; then printf ' ✓ o nome da marca sai escapado (nada de markup injetado no e-mail)\n' else printf ' ✗ o nome da marca NÃO saiu escapado: %s\n' "$(grep -o 'Sua conta no [^.]*' "$rend" | head -1)"; fail=1 fi # Amarelo é claro: texto branco em cima seria ilegível. É o caso exato que o # `#ffffff` fixo produzia — e é a marca que um revendedor cola sem avisar. if grep -q 'color: #171f15' "$rend"; then printf ' ✓ accent claro (#f2c94c) escolhe texto ESCURO\n' else printf ' ✗ accent claro não escolheu texto escuro: %s\n' "$(grep -o 'background: #f2c94c[^"]*' "$rend" | head -1)"; fail=1 fi # A nota de manutenção do topo do modelo fala de placeholder e de --render-em: # é endereçada a quem edita o repositório, não ao cliente final. if grep -q 'MODELO — os' "$rend"; then printf ' ✗ a nota interna do modelo foi junto para dentro do e-mail\n'; fail=1 else printf ' ✓ a nota interna do modelo fica fora do e-mail\n' fi fi # (5) O par claro/escuro: accent escuro tem de escolher BRANCO. Sem este caso, # um `frente_sobre` que devolvesse sempre "#171f15" passaria no caso (4). SUPABASE_ACCESS_TOKEN= APP_NAME='Marca Escura' APP_ACCENT_HEX='#0b3d2e' \ bash ./marca-emails.sh --env /dev/null --render-em "$ME_TMP/escuro" >/dev/null 2>&1 if grep -q 'color: #ffffff' "$ME_TMP/escuro/confirmation.html" 2>/dev/null; then printf ' ✓ accent escuro (#0b3d2e) escolhe texto BRANCO\n' else printf ' ✗ accent escuro não escolheu texto branco\n'; fail=1 fi # (6) Hex inválido no .env não pode virar CSS quebrado no e-mail: cai no accent # do produto, que é o mesmo piso de lib/branding/saida.ts. SUPABASE_ACCESS_TOKEN= APP_NAME='Marca Torta' APP_ACCENT_HEX='verde-limão' \ bash ./marca-emails.sh --env /dev/null --render-em "$ME_TMP/torto" >/dev/null 2>&1 if grep -q 'background: #506d48; background: #506d48' "$ME_TMP/torto/confirmation.html" 2>/dev/null; then printf ' ✓ APP_ACCENT_HEX inválido cai no accent do produto\n' else printf ' ✗ APP_ACCENT_HEX inválido virou CSS inválido: %s\n' \ "$(grep -o 'background: [^;]*;' "$ME_TMP/torto/confirmation.html" 2>/dev/null | head -2 | tr '\n' ' ')"; fail=1 fi rm -rf "$ME_TMP" # (7) O VALIDADOR da cor, no install.sh — a outra ponta dos casos (4)-(6). # `v_hex` é estreito de propósito: aceita SÓ `#` + 6 dígitos, que é a única # forma que o `case` de `marca-emails.sh:125` reconhece. O `ehHexValido` do app # (`lib/branding/rampa.ts:49`) aceita mais quatro (`#abc`, `abc`, `aabbcc`), # e deixá-las passar aqui produziria o pior desfecho: a cor do revendedor na # tela e o verde do produto no primeiro e-mail — split-brain que ninguém # percebe, porque cada metade parece certa sozinha. ok "cor em hex de 6 dígitos" pass v_hex "#7a5cd6" ok "cor vazia (Enter) — o campo é opcional" pass v_hex "" ok "nome de cor não é hex" reject v_hex "verde-limão" "6 dígitos" ok "hex de 3 dígitos: o e-mail não o lê" reject v_hex "#7a5" "6 dígitos" # (8) REGRESSÃO DO LAÇO. O caso de integração da VPS limpa já prova o # comportamento (a cor respondida volta pelo `load_env`); este aqui existe # para NOMEAR a linha que falta quando aquele reprova — "a cor não voltou" # não diz a quem lê que o buraco é a lista de `envq`. if grep -qE '^[[:space:]]*envq APP_ACCENT_HEX' install.sh; then printf ' ✓ o install.sh grava APP_ACCENT_HEX no .env\n' else printf ' ✗ o install.sh NÃO grava APP_ACCENT_HEX: perguntar sem gravar faz a pessoa\n' printf ' responder e perder a resposta na mesma execução (o bloco fecha com `} > .env`,\n' printf ' que trunca a partir da lista de envq).\n'; fail=1 fi echo "proxy reverso: quem está com as portas 80/443" # A versão anterior só sabia procurar Traefik. Qualquer outro proxy — inclusive o # Caddy de OUTRO DeskcommCRM na mesma VPS — caía no ramo "portas livres", e a # instalação seguia até a fase 4 para morrer com "Bind for 0.0.0.0:80 failed: # port is already allocated". Medido numa VPS com produção rodando. # dono_das_portas lê o que o `docker ps` imprime de verdade. Os casos com "->" # vêm da coluna Ports real; o que decide é o lado ANTES da seta (a porta do # HOST). A primeira versão disto olhava a porta INTERNA e errava dos dois lados. dono_ok() { # dono_ok local desc="$1" esperado="$2" linhas="$3" real real="$(printf '%s\n' "$linhas" | dono_das_portas || true)" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n deu: [%s]\n esperava: [%s]\n' "$desc" "$real" "$esperado"; fail=1; fi } dono_ok "proxy publicando 80 no host é encontrado" \ 'traefik|infra|traefik:v3.3' 'traefik|infra|traefik:v3.3|0.0.0.0:80->80/tcp, [::]:80->80/tcp' dono_ok "app em 8080->80 NÃO é ocupante (80 do host livre)" \ '' 'phpmyadmin|web|phpmyadmin:latest|0.0.0.0:8080->80/tcp' dono_ok "proxy sem privilégio (80->8080) É ocupante" \ 'traefik|infra|traefik:v3' 'traefik|infra|traefik:v3|0.0.0.0:80->8080/tcp' dono_ok "Caddy de outro Deskcomm é encontrado" \ 'outro-caddy-1|outro|caddy:2-alpine' 'outro-caddy-1|outro|caddy:2-alpine|0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp' dono_ok "contêiner sem porta publicada é ignorado" \ '' 'worker|app|meu/worker|' dono_ok "só 443 no host também conta" \ 'proxy|infra|nginx' 'proxy|infra|nginx|0.0.0.0:443->443/tcp' # A varredura NÃO exclui mais ninguém: quem decide é o chamador, comparando o # projeto. Excluir aqui produzia um "ocupado por ninguém" — bloqueio sem # comando acionável — porque o teste de bind não tem como se auto-excluir. dono_ok "contêiner desta instalação é IDENTIFICADO (com o projeto)" \ 'crm-caddy-1|meu-projeto|caddy:2-alpine' 'crm-caddy-1|meu-projeto|caddy:2-alpine|0.0.0.0:80->80/tcp' # Sem label de compose, o campo do meio vem VAZIO — com IFS de tab ele colapsava # e a imagem sumia, fazendo um Traefik de `docker run` virar intruso. dono_ok "contêiner sem label de compose mantém a imagem" \ 'meu-traefik||traefik:v3.1' 'meu-traefik||traefik:v3.1|0.0.0.0:80->80/tcp' echo "proxy reverso: é um Traefik?" tk_ok() { # tk_ok local desc="$1" esperado="$2" real if eh_traefik "${3:-}" "${4:-}"; then real=sim; else real=nao; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } tk_ok "imagem traefik" sim "traefik:v3.3" "proxy-01" tk_ok "nome com maiúsculas (TRAEFIK)" sim "meureg/proxy:3" "TRAEFIK-PROXY" tk_ok "coolify-proxy é traefik na imagem" sim "traefik:v2.11" "coolify-proxy" tk_ok "caddy não é traefik" nao "caddy:2-alpine" "outro-caddy-1" tk_ok "nginx não é traefik" nao "nginxproxy/nginx" "webproxy" echo "proxy reverso: a decisão" dec_ok() { # dec_ok [árvore_dono] [árvore_atual] local desc="$1" esperado="$2" real real="$(decide_proxy "${3:-}" "${4:-}" "${5:-}" "${6:-}" "${7:-}" "${8:-}" "${9:-}")" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } dec_ok "portas livres → nosso Caddy" caddy "" "" "crm" "" "" # ESTE é o caso que a revisão pegou: o teste de bind não tem como se # auto-excluir, então numa re-execução as portas aparecem ocupadas — pelo nosso # PRÓPRIO Caddy. Tratar isso como intruso bloqueia a instalação que o kit manda # rodar de novo para corrigir uma resposta, e sem nem um comando acionável. dec_ok "re-execução: portas com esta mesma instalação" caddy "80 e 443" "crm" "crm" "caddy:2-alpine" "crm-caddy-1" dec_ok "Caddy de OUTRO Deskcomm → bloqueia" bloqueia "80 e 443" "outro" "crm" "caddy:2-alpine" "outro-caddy-1" # O fixture acima nomeia "outro Deskcomm" mas usa projeto DIFERENTE ("outro" vs # "crm") — e é justamente o nome do projeto que NÃO difere no caso real: o # projeto do compose é o basename da pasta, e toda cópia do repo se chama # DeskcommCRM. Medido numa VPS de produção em 2026-08-24: a instalação de uma # aula em /root/apagar7/DeskcommCRM viu o Caddy da produção em # /root/DeskcommCRM com o MESMO projeto `deskcommcrm`, concluiu "é a # re-execução" e subiu por cima — trocando o banco do CRM no ar sem um aviso. # Quem distingue as duas é a ÁRVORE (label com.docker.compose.project.working_dir), # não o nome. dec_ok "cópia irmã: mesmo projeto, OUTRA árvore → bloqueia" \ bloqueia "80 e 443" "deskcommcrm" "deskcommcrm" "caddy:2-alpine" "deskcommcrm-caddy-1" \ "/root/DeskcommCRM" "/root/apagar7/DeskcommCRM" # O outro lado da mesma moeda: re-execução DE VERDADE é mesma árvore, e tem de # seguir passando (é o caminho que o kit manda usar para corrigir uma resposta). dec_ok "re-execução real: mesmo projeto, MESMA árvore → segue" \ caddy "80 e 443" "deskcommcrm" "deskcommcrm" "caddy:2-alpine" "deskcommcrm-caddy-1" \ "/root/DeskcommCRM" "/root/DeskcommCRM" # Contêiner sem o label de árvore (não foi o compose que criou, ou é antigo): # não dá para afirmar que é cópia irmã, e fechar aqui quebraria re-execução # legítima. Mantém o comportamento anterior — a varredura de portas continua # sendo a rede que pega o resto. dec_ok "sem árvore conhecida: mantém o comportamento anterior" \ caddy "80 e 443" "deskcommcrm" "deskcommcrm" "caddy:2-alpine" "deskcommcrm-caddy-1" \ "" "/root/apagar7/DeskcommCRM" dec_ok "Traefik da hospedagem → por ele" traefik "80 e 443" "coolify" "crm" "traefik:v3.3" "coolify-proxy" dec_ok "ocupante não identificado → bloqueia" bloqueia "80" "" "crm" "" "" dec_ok "projeto vazio não casa projeto vazio" bloqueia "80" "" "" "nginx" "web" echo "proxy reverso: Traefik em MODO HOST (o caso da Hostinger, issue #139)" # Os fixtures acima têm todos porta publicada, e por isso a suíte inteira passava # sem nunca exercitar o proxy em modo host — o cenário que gerou a issue. # Medido no docker 28.3.2: contêiner em `--network host` sai do `docker ps` com a # coluna Ports VAZIA, inclusive quando subido com `-p 80:80` (o daemon avisa # "Published ports are discarded when using host network mode"). Controle # positivo: o mesmo nginx numa bridge com `-p 8080:80` sai com # "0.0.0.0:8080->80/tcp". Logo, dono_das_portas NUNCA o encontra — é por isso que # existe uma segunda varredura, sobre `docker ps --filter network=host`. uni_ok() { # uni_ok local desc="$1" esperado="$2" linhas="$3" real real="$(printf '%s\n' "$linhas" | unico_traefik || true)" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s\n deu: [%s]\n esperava: [%s]\n' "$desc" "$real" "$esperado"; fail=1; fi } # Ports vazio é o dado REAL do modo host, não um campo esquecido no fixture. uni_ok "Traefik em modo host (Ports vazio) é encontrado" \ 'traefik|hostinger|traefik:v3.3' 'traefik|hostinger|traefik:v3.3|' uni_ok "entre outros contêineres em modo host, acha o Traefik" \ 'proxy-hostinger||traefik:v3' 'node-exporter||prom/node-exporter| proxy-hostinger||traefik:v3| netdata||netdata/netdata|' # Fecha FECHADO no plural: com dois não dá para saber qual está com 80/443, e # apontar para o errado publica um CRM que instala "com sucesso" e não responde. uni_ok "dois Traefiks → não elege ninguém" \ '' 'traefik-a||traefik:v3| traefik-b||traefik:v2.11|' uni_ok "nenhum Traefik → não elege ninguém" \ '' 'nginx-host||nginx:alpine|' uni_ok "lista vazia → não elege ninguém" '' '' echo "proxy reverso: qual rede gravar em TRAEFIK_NETWORK" # As duas conclusões são OPOSTAS e as duas foram, em algum momento, a única # implementada. Bridge própria → a rede do PROXY (medido com Traefik v3.3: com o # label na rede do projeto a requisição fica em HTTP 000). Modo host → uma bridge # NOSSA (medido: contêiner em `--network host` alcança por IP um contêiner numa # bridge separada, HTTP 200; e o compose recusa `external` apontando para a rede # que ele mesmo criaria). rt_ok() { # rt_ok local desc="$1" esperado="$2" real real="$(rede_do_traefik "${3:-}" "${4:-}" "${5:-}")" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu [%s], esperava [%s])\n' "$desc" "$real" "$esperado"; fail=1; fi } # NetworkMode e Networks medidos no docker 28.3.2 (não inventados): rede custom # devolve o nome dela nos dois campos; modo host devolve "host" nos dois. rt_ok "Traefik em bridge própria → a rede DELE" coolify coolify "coolify " crm_proxy rt_ok "Traefik na bridge default → bridge" bridge bridge "bridge " crm_proxy rt_ok "Traefik em 2 redes com a coolify → coolify" coolify coolify "coolify web " crm_proxy # O docker devolve as redes em ORDEM ALFABÉTICA (o template percorre um mapa), e # "a primeira" era a rede que vence o sorteio do alfabeto, não a que o painel usa # para os sites. Medido numa VPS com Coolify: com uma rede "aaa-simulado" # pendurada no coolify-proxy, a descoberta devolveu aaa-simulado. rt_ok "2 redes, coolify NÃO é a primeira → coolify" coolify coolify "aaa-simulado coolify " crm_proxy # Sem a coolify entre elas não há como saber qual é a do proxy: vazio, e quem # chama recusa mandando declarar TRAEFIK_NETWORK. Chutar pode ligar o CRM à rede # de outro projeto, ou a uma rede `internal` que derruba o `up -d`. rt_ok "2 redes sem a coolify → não escolhe (vazio)" '' rede-a "rede-a rede-b " crm_proxy # ESTE é o defeito da issue #139: em modo host `.NetworkSettings.Networks` devolve # a string "host", que é uma rede de driver `host` — gravá-la em TRAEFIK_NETWORK # mata o `up -d` com "network host declared as external, but could not be found". rt_ok "modo host NÃO grava a pseudo-rede 'host'" crm_proxy host "host " crm_proxy echo "proxy reverso: como o Traefik da hospedagem chama as portas 80 e 443" # `web`/`websecure` é convenção da documentação, não regra. O EasyPanel usa # `http`/`https`, e o Traefik ignora em SILÊNCIO um label que aponte para um # entrypoint inexistente: nenhum erro no log, a rota nunca nasce, o domínio cai # no 404 do painel. Medido numa VPS com EasyPanel — 6 contêineres no ar, # /api/v1/health saudável por dentro, site mudo por fora. ep_ok() { # ep_ok "> local desc="$1" esperado="$2" real real="$(entrypoints_do_traefik "${3:-}")" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu [%s], esperava [%s])\n' "$desc" "$real" "$esperado"; fail=1; fi } # Env copiado do contêiner easypanel-traefik de uma VPS real. ep_ok "EasyPanel (env, http/https)" "http https" 'TRAEFIK_ENTRYPOINTS_HTTP_ADDRESS=:80 TRAEFIK_ENTRYPOINTS_HTTPS_ADDRESS=:443 TRAEFIK_PROVIDERS_DOCKER=true' # A grafia da documentação, que é como sobe quem segue o traefik.io. ep_ok "flags clássicas (web/websecure)" "web websecure" '--entrypoints.web.address=:80 --entrypoints.websecure.address=:443' # camelCase é aceito pelo Traefik e aparece em tutorial antigo. ep_ok "flag em camelCase" "web websecure" '--entryPoints.web.address=:80 --entryPoints.websecure.address=:443' # Endereço com IP: a porta continua sendo o que decide. ep_ok "address com IP explícito" "http https" '--entrypoints.http.address=0.0.0.0:80 --entrypoints.https.address=0.0.0.0:443' # Nada reconhecido → vazio, e quem chama fica com o default. Sem isto, um Traefik # configurado por arquivo (que o inspect não vê) apagaria os nomes que funcionam. ep_ok "sem entrypoint declarado → vazio" " " 'TRAEFIK_PROVIDERS_DOCKER=true' # Só HTTPS declarado: o :443 é o que decide a rota do site, e o :80 fica no default. ep_ok "só o :443 declarado" " https" '--entrypoints.https.address=:443' # Entrypoint de outra coisa (métricas, dashboard) não vira o do site. ep_ok "porta alheia não vira entrypoint do site" "http https" '--entrypoints.metrics.address=:8082 --entrypoints.http.address=:80 --entrypoints.https.address=:443' echo "proxy reverso: a rede externa existe e serve?" vr_ok() { # vr_ok [attachable] local desc="$1" esperado="$2" real # O attachable só é passado quando o caso o declara, e isso NÃO é firula de # assinatura: a chamada de 3 argumentos é o call site de antes do Swarm, e ela # tem de continuar recusando overlay. Passar "" sempre apagaria essa medição em # silêncio — a função trata ausente e vazio igual, então os dois casos ficariam # verdes pelo mesmo caminho e o de compatibilidade deixaria de existir. if [ $# -ge 6 ]; then real="$(veredito_rede_do_proxy "${3:-}" "${4:-}" "${5:-}" "$6")" else real="$(veredito_rede_do_proxy "${3:-}" "${4:-}" "${5:-}")"; fi if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } vr_ok "bridge existente → segue" ok bridge coolify crm_proxy # Sem este caso a instalação NOVA em modo host morre: a bridge do projeto ainda # não existe (quem a cria é este instalador), e recusar aqui só deixaria instalar # quem já tivesse instalado antes. vr_ok "a bridge do PROJETO ainda não existe → cria" criar "" crm_proxy crm_proxy vr_ok "rede de outro que não existe → morre" inexistente "" coolify crm_proxy # TRAEFIK_NETWORK=host escrito à mão: existe, mas não aceita contêiner de bridge. vr_ok "driver host → morre" driver_errado host host crm_proxy # Chamada com 3 argumentos DE PROPÓSITO: é o call site de antes do attachable. # Sem este caso, apagar o `att` de garantir_rede_do_proxy (deixando a função # intacta e o símbolo presente) não seria pego por teste nenhum. vr_ok "driver overlay, chamada de 3 args → morre" driver_errado overlay traefik crm_proxy # Sem bridge do projeto conhecida (chamada defensiva), ausência volta a ser morte. vr_ok "sem rede nossa declarada → não inventa" inexistente "" crm_proxy "" # ── Overlay do Swarm ──────────────────────────────────────────────────────── # Numa VPS com Docker Swarm o Traefik vive numa overlay, e a recusa por driver # matava a instalação com "ponha a bridge certa em TRAEFIK_NETWORK" — instrução # impossível de seguir, porque ali bridge do Traefik não existe. O que separa a # overlay que SERVE da que não serve é o --attachable: sem ele um contêiner de # compose comum não entra na rede e o `up -d` morre em "could not attach to # network". Por isso o veredito lê os DOIS campos, nunca só o driver. # # Os valores abaixo são o que `docker network inspect -f '{{.Attachable}}'` # imprime DE VERDADE (medido no docker 28.3.2): `true` ou `false`, minúsculo e # sem aspas, e VAZIO quando a rede não existe (aí o inspect sai != 0). Um teste # escrito com "True" ou "1" guardaria um formato que o Docker não emite. vr_ok "overlay attachable → serve como bridge" ok overlay traefik crm_proxy true vr_ok "overlay SEM attachable → morre" driver_errado overlay traefik crm_proxy false # Vazio é a resposta de quem não sabe, não um "pode entrar". Tratar ausência de # resposta como permissão é exatamente o falhar-em-verde que este arquivo existe # para impedir. vr_ok "overlay com attachable vazio → morre" driver_errado overlay traefik crm_proxy "" # O attachable NÃO pode virar critério único: a bridge default do Docker e as que # os painéis criam reportam Attachable=false (medido no docker 28.3.2, inclusive # na rede `bridge`). Exigi-lo de todo mundo quebraria toda instalação com Traefik # em bridge que hoje funciona — que é a maioria. vr_ok "bridge com attachable=false segue ok" ok bridge coolify crm_proxy false # E o driver continua mandando: attachable=true numa rede `host` não muda que # contêiner de bridge não entra nela. vr_ok "host com attachable=true continua morrendo" driver_errado host host crm_proxy true echo "proxy reverso: o CALL SITE pergunta o attachable ao Docker" # Guardar a função não guarda a correção. Apagar o `att=` e o 4º argumento de # `garantir_rede_do_proxy` deixa `veredito_rede_do_proxy` intacta, o símbolo # presente e todo grep verde — e a VPS com Swarm volta a morrer, no update.sh # que o agent.sh roda sozinho a cada 5 minutos, sem ninguém lendo a tela. É o # call site que precisa de rede, e aqui o _common.sh roda de verdade contra um # `docker` dublê que responde como um Swarm responderia. rede_e2e() { # rede_e2e local desc="$1" esperado="$2" drv="$3" att="$4" dir real perguntou kit="$PWD" dir="$(mktemp -d)"; mkdir -p "$dir/bin" cat > "$dir/bin/docker" <> "$dir/chamadas.log" if [ "\$1" = network ] && [ "\$2" = inspect ]; then case "\$*" in *Driver*) printf '$drv\n'; exit 0 ;; *Attachable*) printf '$att\n'; exit 0 ;; esac fi exit 0 STUB chmod +x "$dir/bin/docker" # O kit é capturado ANTES do cd: dentro do subshell o \$PWD já é o temporário, # e o _common.sh não seria encontrado — o teste "morreria" por não achar o # arquivo, indistinguível de uma recusa legítima. if (cd "$dir" && env PATH="$dir/bin:$PATH" REVERSE_PROXY=traefik \ TRAEFIK_NETWORK=traefik PROJECT_DIR="$dir" \ bash -c '. "$1/_common.sh"; garantir_rede_do_proxy' _ "$kit") >/dev/null 2>&1 then real=segue; else real=morre; fi # Vacuidade: "segue" só significa alguma coisa se o call site TIVER perguntado # o attachable ao Docker. Sem esta checagem, um call site que parasse de # perguntar — e um veredito que aceitasse overlay de olhos fechados — passaria # com a mesma cara de aprovado. perguntou=nao grep -q 'Attachable' "$dir/chamadas.log" 2>/dev/null && perguntou=sim rm -rf "$dir" if [ "$perguntou" != sim ]; then printf ' ✗ %s (o call site não perguntou o attachable ao Docker)\n' "$desc"; fail=1 elif [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } rede_e2e "overlay attachable: install/update seguem" segue overlay true rede_e2e "overlay sem attachable: morre explicando" morre overlay false echo "proxy reverso: NPM (Nginx Proxy Manager)" # NPM nunca é auto-detectado (ao contrário do Traefik, ele não fala por labels) — # é sempre REVERSE_PROXY=npm escrito à mão no .env. O que precisa de prova é o # CALL SITE: dc()/dc_files() entram o override certo, e garantir_rede_do_proxy # não deixa o `up -d` morrer no erro opaco do compose quando a rede do NPM sumiu # (prune, down -v) — o mesmo risco que o Traefik já tinha, e o update.sh roda # sozinho pelo agent.sh, sem ninguém lendo a tela. if REVERSE_PROXY=npm dc_files | grep -q 'docker-compose.npm.yml'; then printf ' ✓ dc_files() entra o docker-compose.npm.yml com REVERSE_PROXY=npm\n' else printf ' ✗ dc_files() não entrou o docker-compose.npm.yml com REVERSE_PROXY=npm (deu: %s)\n' \ "$(REVERSE_PROXY=npm dc_files)"; fail=1 fi if REVERSE_PROXY=caddy dc_files | grep -q 'docker-compose.npm.yml'; then printf ' ✗ dc_files() entrou o docker-compose.npm.yml SEM REVERSE_PROXY=npm (vacuidade)\n'; fail=1 else printf ' ✓ REVERSE_PROXY=caddy (default): dc_files() não menciona o override do NPM\n' fi npm_rede_e2e() { # npm_rede_e2e local desc="$1" esperado="$2" existe="$3" dir real kit="$PWD" dir="$(mktemp -d)"; mkdir -p "$dir/bin" cat > "$dir/bin/docker" <> "$dir/chamadas.log" [ "\$1" = network ] && [ "\$2" = inspect ] && exit $existe exit 0 STUB chmod +x "$dir/bin/docker" if (cd "$dir" && env PATH="$dir/bin:$PATH" REVERSE_PROXY=npm PROJECT_DIR="$dir" \ bash -c '. "$1/_common.sh"; garantir_rede_do_proxy' _ "$kit") >/dev/null 2>&1 then real=segue; else real=morre; fi rm -rf "$dir" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } npm_rede_e2e "rede do NPM presente: install/update seguem" segue 0 npm_rede_e2e "rede do NPM sumiu (prune/down -v): morre explicando" morre 1 echo "proxy reverso: Cloudflare Tunnel (atrás de NAT)" # Como o NPM, o cloudflared é sempre declarado à mão no .env — não há nada para # detectar. O que se prova é o CALL SITE (dc()/dc_files() entram o override) e # que garantir_rede_do_proxy NÃO exige rede externa: o cloudflared sobe na rede # interna do próprio compose. if REVERSE_PROXY=cloudflared dc_files | grep -q 'docker-compose.cloudflared.yml'; then printf ' ✓ dc_files() entra o docker-compose.cloudflared.yml com REVERSE_PROXY=cloudflared\n' else printf ' ✗ dc_files() não entrou o docker-compose.cloudflared.yml (deu: %s)\n' \ "$(REVERSE_PROXY=cloudflared dc_files)"; fail=1 fi if REVERSE_PROXY=caddy dc_files | grep -q 'docker-compose.cloudflared.yml'; then printf ' ✗ dc_files() entrou o override do Cloudflare SEM REVERSE_PROXY=cloudflared (vacuidade)\n'; fail=1 else printf ' ✓ REVERSE_PROXY=caddy (default): dc_files() não menciona o override do Cloudflare\n' fi # garantir_rede_do_proxy com cloudflared não pode nem olhar rede externa: não há # nenhuma. O dublê responde "inexistente" para qualquer inspect — se a função # tentasse conferir, morreria pedindo TRAEFIK_NETWORK. _cloudflared_rede() { # → segue | morre local dir real kit="$PWD" dir="$(mktemp -d)"; mkdir -p "$dir/bin" cat > "$dir/bin/docker" </dev/null 2>&1 then real=segue; else real=morre; fi rm -rf "$dir" printf '%s' "$real" } if [ "$(_cloudflared_rede)" = segue ]; then printf ' ✓ cloudflared não exige rede externa: garantir_rede_do_proxy segue sem tocar o Docker\n' else printf ' ✗ cloudflared tentou conferir rede externa e morreu (não usa nenhuma)\n'; fail=1 fi echo "proxy reverso: quanta confiança a eleição merece" # A eleição por porta publicada traz a evidência (a coluna Ports diz ':80->'); a # varredura por modo host não traz nenhuma — em modo host a coluna é vazia para # TODOS, então ela só sabe dizer "há um único Traefik em modo host aqui". cf_ok() { # cf_ok local desc="$1" esperado="$2" real real="$(confianca_no_dono_das_portas "${3:-}" "${4:-}")" if [ "$real" = "$esperado" ]; then printf ' ✓ %s\n' "$desc" else printf ' ✗ %s (deu %s, esperava %s)\n' "$desc" "$real" "$esperado"; fail=1; fi } cf_ok "dono pela coluna Ports → segue (tem prova)" segue 0 0 cf_ok "dono pela coluna Ports, --yes → segue" segue 0 1 cf_ok "eleito pela varredura host, interativo → pergunta" pergunta 1 0 cf_ok "eleito pela varredura host, --yes → recusa" recusa 1 1 # ── Fixture de VPS: os scripts do kit rodam DE VERDADE contra dublês ──────── # Os blocos de unidade acima guardam as FUNÇÕES; os de integração abaixo guardam # o CAMINHO INTEIRO, que é onde esta correção já falhou uma vez. O ramo do modo # host chegou a ser escrito sendo INALCANÇÁVEL: dependia de `traefik_container`, # atribuído só quando o dono das portas era identificado pela coluna Ports — # vazia em modo host. As funções ficavam certas e a VPS continuava morrendo no # painel "porta 80 já ocupada". # # São três VPS diferentes daqui pra frente, e o que muda entre elas é SÓ o dublê # do `docker`. Curl, crontab e .env são os mesmos: uma cópia por cenário seria # uma cópia para envelhecer sozinha. # # .env completo para o modo --yes: o que interessa aqui é o proxy, e as demais # respostas só precisam passar pelos validadores. REVERSE_PROXY e TRAEFIK_NETWORK # ficam de FORA — são justamente o que o instalador decide. É preciso reescrever # a cada rodada: o próprio install.sh grava as duas de volta no .env, e a segunda # rodada não estaria mais decidindo nada. BASE_ENV="DOMAIN='crm.exemplo.com.br' ACME_EMAIL='eu@exemplo.com.br' NEXT_PUBLIC_SUPABASE_URL='https://abcdefghijklmnop.supabase.co' NEXT_PUBLIC_SUPABASE_ANON_KEY='$(mkjwt anon abcdefghijklmnop)' SUPABASE_SERVICE_ROLE_KEY='$(mkjwt service_role abcdefghijklmnop)' SUPABASE_DB_URL='postgresql://postgres.abcdefghijklmnop:senha@aws-1-sa-east-1.pooler.supabase.com:5432/postgres' ANTHROPIC_API_KEY='sk-ant-teste' OWNER_EMAIL='eu@exemplo.com.br' OWNER_PASSWORD='senha12345'" # montar_vps < corpo do dublê de `docker` # Define VPS_RAIZ / VPS_PROJ / VPS_LOG para o `rodar` logo abaixo. montar_vps() { local raiz="$1" pasta="$2" VPS_RAIZ="$raiz"; VPS_PROJ="$raiz/$pasta"; VPS_LOG="$raiz/docker.log" mkdir -p "$raiz/bin" "$VPS_PROJ" # `marca-emails.sh` entra porque o install.sh o INVOCA no fim (passo 7). Sem # ele no sandbox, aquele `bash` falhava, o `|| true` engolia, e todo cenário # media uma instalação em que o passo dos e-mails de acesso simplesmente não # aconteceu — o elo mais fácil de quebrar sem ninguém ver. # `manutencao.sh` e a pasta `manutencao/` entram pela MESMA razao, e a lista # acima nasceu curta duas vezes: o `update.sh` os carrega com `source` DURO, no # topo, igual ao `_common.sh`. Sem eles aqui, o script morre na LINHA 21 — antes # de qualquer mensagem — e todo cenario reporta "o update.sh nao chegou ao # banco / ao fim / ao up -d", que le como defeito do produto e e cenario faltando. cp install.sh update.sh backup.sh _common.sh _manifestos.sh _i18n.sh marca-emails.sh manutencao.sh "$raiz/" cp -R manutencao "$raiz/" : > "$VPS_PROJ/docker-compose.prod.yml" cat > "$raiz/bin/docker" # O corpo fornecido por cada cenário continua cuidando de compose/exec. # O wrapper só dublê o registry OCI que o preflight novo consulta. mv "$raiz/bin/docker" "$raiz/bin/docker-inner" cat > "$raiz/bin/docker" <<'STUBOCI' #!/usr/bin/env bash if [ "${1:-}" = buildx ] && [ "${2:-}" = imagetools ] && [ "${3:-}" = inspect ]; then case " $* " in *' --raw '*) if [ -n "${DUBLE_MANIFEST:-}" ]; then printf '%s' "$DUBLE_MANIFEST" else printf '%s' '{"schemaVersion":2,"manifests":[{"platform":{"os":"linux","architecture":"amd64"}},{"platform":{"os":"linux","architecture":"arm64"}}]}' fi ;; *) printf 'linux/amd64\nlinux/arm64\n' ;; esac exit 0 fi exec "$(dirname "$0")/docker-inner" "$@" STUBOCI chmod +x "$raiz/bin/docker-inner" # Só o v_supabase_url exige resposta online (000 reprova, e quem responde tem # de ser o GoTrue — o ramo `*auth/v1/verify*`); os outros toleram. # # O dublê fala DOIS protocolos porque o install.sh passou a sondar o GHCR # antes de pinar as imagens (`ghcr_status`/`trio_publicado` no _common.sh): o # endpoint de token devolve JSON, o de manifest devolve o código HTTP. Um # dublê que respondesse `200` para tudo faria o `sed` do token sair vazio, a # sonda devolver `000`, e a suíte passaria a exercitar o ramo de fallback # achando que exercita o normal — verde medindo outra coisa. # # `DUBLE_GHCR` permite ao teste escolher o cenário: vazio/`200` = as três # imagens publicadas; `403` = pacote privado; `404` = não existe. cat > "$raiz/bin/curl" <<'STUBCURL' #!/usr/bin/env bash case "$*" in *releases/latest*) printf '{"tag_name":"%s"}' "${DUBLE_RELEASE_TAG:-v1.66.1}" ;; *ghcr.io/token*) printf '{"token":"dublê"}' ;; *ghcr.io/v2/*) printf '%s' "${DUBLE_GHCR:-200}" ;; # O v_supabase_url exige o GoTrue: o JSON de /auth/v1/verify sem parâmetros. *auth/v1/verify*) printf '{"msg":"Verify requires a verification type"}\n400' ;; *) printf 200 ;; esac STUBCURL # O install.sh e o update.sh vão até o fim, e no fim eles AGENDAM CRON. Sem # dublê a suíte escreveria no crontab de quem a roda — apontando para um # diretório temporário que ela mesma apaga em seguida. Teste que suja a máquina # do desenvolvedor é defeito do teste; medido: 10 linhas órfãs no crontab do # mantenedor, uma delas um `curl` com Bearer batendo numa URL de exemplo a cada # minuto. # # O dublê imita o crontab de verdade em vez de engolir tudo. A versão anterior # era `cat >/dev/null` INCONDICIONAL, e isso TRAVAVA A SUÍTE PARA SEMPRE: o # _common.sh faz `crontab -l | grep -qF ...`, o `cat` do dublê ficava lendo o # stdin herdado do processo — num terminal, o tty, que nunca dá EOF — e o # `grep` do outro lado esperava um fim que não vinha. Medido: com stdin no tty, # morta a marteladas depois de 90s numa suíte que roda inteira em menos disso; # com `< /dev/null`, passava. Um dublê só pode consumir stdin onde o comando # real consumiria: `crontab -` e `crontab `, nunca `crontab -l`. cat > "$raiz/bin/crontab" <<'STUB' #!/usr/bin/env bash : "${CRONTAB_SANDBOX:?dublê de crontab sem sandbox — não vou tocar no crontab real}" # Substituição ATÔMICA, como o crontab de verdade (escreve um temporário e # renomeia sobre o spool). Sem isso o dublê mente num ponto que importa: o kit # faz `crontab -l | ... | crontab -`, os dois lados do cano rodam ao mesmo tempo, # e um `cat > arquivo` truncava o arquivo que o leitor ainda estava lendo. O # merge recebia um crontab vazio e cada gravação apagava a linha da anterior — # a suíte "isolava" bem e media pouco. grava() { cat > "$CRONTAB_SANDBOX.novo" && mv "$CRONTAB_SANDBOX.novo" "$CRONTAB_SANDBOX"; } case "${1:-}" in -l) [ -f "$CRONTAB_SANDBOX" ] || { printf 'no crontab for %s\n' "$(id -un)" >&2; exit 1; } cat "$CRONTAB_SANDBOX" ;; -r) rm -f "$CRONTAB_SANDBOX" ;; -) grava ;; -*) ;; # flag que o kit não usa: nada a fazer *) [ -n "${1:-}" ] && grava < "$1" ;; esac exit 0 STUB chmod +x "$raiz/bin/docker" "$raiz/bin/curl" "$raiz/bin/crontab" dublar_uname_amd64 "$raiz/bin" } # rodar