Chrome DevTools MCP

Depure aplicações web conectando-se às ferramentas de desenvolvedor do Chrome através do Protocolo Chrome DevTools.

Documentação

Chrome DevTools MCP

Um servidor Model Context Protocol (MCP) que fornece integração com o Chrome DevTools Protocol por meio do MCP. Isso permite depurar aplicações web conectando-se às ferramentas de desenvolvedor do Chrome.

Disponível como Extensão do Claude Desktop (.dxt) para instalação fácil com um clique!

O Que Isso Faz

Este servidor MCP atua como uma ponte entre o Claude e os recursos de depuração do Chrome. Uma vez instalado no Claude Desktop, você pode:

Conectar o Claude a qualquer aplicação web em execução no Chrome
Depurar requisições de rede, erros de console e problemas de desempenho
Inspecionar objetos JavaScript e executar código no contexto do navegador
Monitorar sua aplicação em tempo real por meio de conversa natural com o Claude

Nota: Este é um servidor MCP que roda dentro do Claude Desktop — você não precisa executar servidores ou processos separados.

Recursos

Monitoramento de Rede: Capturar e analisar requisições/respostas HTTP com opções de filtragem
Integração com Console: Ler logs do console do navegador, analisar erros e executar JavaScript
Métricas de Desempenho: Dados de tempo, carregamento de recursos e utilização de memória
Inspeção de Página: Informações do DOM, métricas de página e suporte a múltiplos frames
Acesso a Armazenamento: Ler cookies, localStorage e sessionStorage
Monitoramento em Tempo Real: Acompanhamento ao vivo da saída do console
Inspeção de Objetos: Inspecionar objetos e variáveis JavaScript

Instalação

Opção 1: Extensão do Claude Desktop (Mais Fácil)

Baixe a extensão pré-compilada:

Baixe o arquivo .dxt mais recente em Releases
Abra o Claude Desktop
Vá em Extensões e instale o arquivo .dxt baixado
Configure o caminho do Chrome, se necessário, nas configurações da extensão

A extensão inclui todas as dependências e está pronta para uso imediato!

Opção 2: MCP CLI (Avançado)

Instalação rápida (mais comum):

git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
mcp install server.py -n "Chrome DevTools MCP" --with-editable .

Nota: O comando mcp faz parte do Python MCP SDK. Instale-o com pip install mcp se ainda não estiver disponível.

Todas as opções de instalação:

# Clone the repository
git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp

# The --with-editable flag uses pyproject.toml to install dependencies

# Basic installation with local dependencies
mcp install server.py --with-editable .

# Install with custom name
mcp install server.py -n "Chrome DevTools MCP" --with-editable .

# Install with environment variables
mcp install server.py -n "Chrome DevTools MCP" --with-editable . -v CHROME_DEBUG_PORT=9222

# Install with additional packages if needed
mcp install server.py -n "Chrome DevTools MCP" --with-editable . --with websockets --with aiohttp

# Install with environment file (copy .env.example to .env first)
cp .env.example .env
# Edit .env with your settings
mcp install server.py -n "Chrome DevTools MCP" --with-editable . -f .env

Opção 3: Integração com Claude Code

Para usuários do Claude Code CLI:

Clone este repositório

git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp

Instale as dependências com UV (cria venv)

uv sync  # Creates .venv and installs dependencies

Adicione o servidor MCP usando o Claude CLI com caminhos absolutos

IMPORTANTE: O Claude Code precisa de caminhos absolutos tanto para o interpretador Python quanto para o script do servidor para funcionar corretamente.

Configuração recomendada usando caminhos absolutos:

# Get the absolute paths
SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"

# Add the server with absolute paths
claude mcp add chrome-devtools "$PYTHON_PATH" "$SERVER_PATH" -e CHROME_DEBUG_PORT=9222

Alternativa: Usando o Python do sistema (se as dependências estiverem instaladas globalmente):

# Only if you've installed dependencies globally
claude mcp add chrome-devtools python "$(pwd)/server.py" -e CHROME_DEBUG_PORT=9222

Com escopo personalizado:

# Add to user scope (available across all projects)
claude mcp add chrome-devtools "$(pwd)/.venv/bin/python" "$(pwd)/server.py" -s user -e CHROME_DEBUG_PORT=9222

# Add to project scope (only for this project)
claude mcp add chrome-devtools "$(pwd)/.venv/bin/python" "$(pwd)/server.py" -s project -e CHROME_DEBUG_PORT=9222

Verifique a instalação

# List configured MCP servers
claude mcp list

# Get details about the server (check that paths are absolute)
claude mcp get chrome-devtools

# The output should show absolute paths like:
# Command: /Users/you/chrome-devtools-mcp/.venv/bin/python
# Args: ["/Users/you/chrome-devtools-mcp/server.py"]

Problemas Comuns de Caminho e Soluções:

Problema: "python: command not found" ou "server.py not found"
- Solução: Use caminhos absolutos como mostrado acima
Problema: "ModuleNotFoundError" quando o servidor inicia
- Solução: Use o interpretador Python do venv que tem as dependências instaladas
Problema: O servidor não inicia ou aparece como desconectado
- Solução: Teste o comando manualmente: /path/to/.venv/bin/python /path/to/server.py

Opção 4: Configuração Manual do Claude Desktop

Clone este repositório

git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp

Instale as dependências

Com uv (recomendado):

uv sync

Com pip:

pip install -r requirements.txt

Adicione à configuração do Claude Desktop

Edite o arquivo de configuração do Claude Desktop:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "python",
      "args": ["/absolute/path/to/chrome-devtools-mcp/server.py"],
      "env": {
        "CHROME_DEBUG_PORT": "9222"
      }
    }
  }
}

Reinicie o Claude Desktop

Verifique a Instalação

Após a instalação (qualquer método), verifique se o servidor está disponível:

Abra o Claude Desktop
Procure pelas ferramentas MCP na conversa
Tente um comando simples: get_connection_status()

Clientes MCP Alternativos

Para outros clientes MCP, execute o servidor diretamente:

python server.py

Início Rápido

Uma vez instalado no Claude Desktop, você pode começar a depurar qualquer aplicação web:

Depure Sua Aplicação Web

Configuração em uma etapa (recomendada):

start_chrome_and_connect("localhost:3000")

Substitua localhost:3000 pela URL da sua aplicação

Se o Chrome não for encontrado automaticamente:

start_chrome_and_connect("localhost:3000", chrome_path="/path/to/chrome")

Use o parâmetro chrome_path para especificar um local personalizado do Chrome

Este comando irá:

Iniciar o Chrome com depuração habilitada
Navegar até sua aplicação
Conectar o servidor MCP ao Chrome

Configuração manual (se preferir passo a passo):

start_chrome()
navigate_to_url("localhost:3000")
connect_to_browser()

Comece a Depurar

Uma vez conectado, use estes comandos:

get_network_requests() - Visualizar tráfego HTTP
get_console_error_summary() - Analisar erros de JavaScript
inspect_console_object("window") - Inspecionar qualquer objeto JavaScript

Ferramentas MCP Disponíveis

Gerenciamento do Chrome

start_chrome(port?, url?, headless?, chrome_path?, auto_connect?) - Iniciar o Chrome com depuração remota e conexão automática opcional
start_chrome_and_connect(url, port?, headless?, chrome_path?) - Iniciar o Chrome, conectar e navegar em uma única etapa
connect_to_browser(port?) - Conectar a uma instância existente do Chrome
navigate_to_url(url) - Navegar para uma URL específica
disconnect_from_browser() - Desconectar do navegador
get_connection_status() - Verificar o status da conexão

Monitoramento de Rede

get_network_requests(filter_domain?, filter_status?, limit?) - Obter requisições de rede com filtragem
get_network_response(request_id) - Obter dados detalhados de resposta, incluindo corpo

Ferramentas de Console

get_console_logs(level?, limit?) - Obter logs do console do navegador
get_console_error_summary() - Obter resumo organizado de erros e avisos
execute_javascript(code) - Executar JavaScript no contexto do navegador
clear_console() - Limpar o console do navegador
inspect_console_object(expression) - Inspecionar profundamente qualquer objeto JavaScript
monitor_console_live(duration_seconds) - Monitorar a saída do console em tempo real

Análise de Página

get_page_info() - Obter métricas abrangentes de página e dados de desempenho
evaluate_in_all_frames(code) - Executar JavaScript em todos os frames/iframes
get_performance_metrics() - Obter métricas detalhadas de desempenho e tempo de recursos

Armazenamento e Dados

get_storage_usage_and_quota(origin) - Obter informações de uso de armazenamento e cota
clear_storage_for_origin(origin, storage_types?) - Limpar armazenamento por tipo e origem
get_all_cookies() - Obter todos os cookies do navegador
clear_all_cookies() - Limpar todos os cookies do navegador
set_cookie(name, value, domain, path?, expires?, http_only?, secure?, same_site?) - Definir um cookie
get_cookies(domain?) - Obter cookies do navegador com filtragem opcional por domínio
get_storage_key_for_frame(frame_id) - Obter chave de armazenamento para um frame específico
track_cache_storage(origin, enable?) - Ativar/desativar rastreamento de armazenamento em cache
track_indexeddb(origin, enable?) - Ativar/desativar rastreamento do IndexedDB
override_storage_quota(origin, quota_size_mb?) - Substituir a cota de armazenamento

Casos de Uso

Depurando Chamadas de API em Sua Aplicação Web

Quando sua aplicação web faz chamadas de API que falham ou retornam dados inesperados:

Configuração fácil: Use o comando de uma etapa para iniciar o Chrome e navegar até sua aplicação:

Fluxo de trabalho de exemplo:

You: "I need to debug my React app at localhost:3000"
Claude: I'll start Chrome with debugging enabled and navigate to your app.

start_chrome_and_connect("localhost:3000")

Perfect! Chrome is now running with debugging enabled and connected to your app. Let me check for any failed network requests:

get_network_requests(filter_status=500)

I can see there are 3 failed requests to your API. Let me get the details of the first one:

get_network_response("request-123")

Configuração manual (se preferir):

Inicie o Chrome: Use start_chrome()
Navegue até sua aplicação: Use navigate_to_url("localhost:3000")
Conecte: Use connect_to_browser()
Monitore o tráfego de rede: Use get_network_requests() para ver todas as chamadas de API

Verificando Erros do Console JavaScript

Quando sua aplicação web tem erros de JavaScript ou comportamento inesperado:

Navegue até sua aplicação na instância do Chrome conectada
Verifique erros de console: Use get_console_error_summary() para ver todos os erros
Monitore erros ao vivo: Use monitor_console_live(10) para observar novos erros enquanto interage
Inspecione variáveis: Use inspect_console_object("myVariable") para examinar o estado da aplicação

Fluxo de trabalho de exemplo:

You: "My React component isn't updating properly"
Claude: Let me check the JavaScript console for any errors.

get_console_error_summary()

I can see there are 2 JavaScript errors. Let me also monitor the console while you interact with the component:

monitor_console_live(15)

Now try clicking the component that isn't working. I'll watch for any new errors or warnings.

Depuração de Desempenho

Quando sua aplicação web carrega lentamente ou usa memória demais:

Carregue sua aplicação no navegador conectado
Verifique métricas de página: Use get_page_info() para ver tempos de carregamento e contagens de recursos
Analise o desempenho: Use get_performance_metrics() para ver dados detalhados de tempo
Monitore o uso de memória: Verifique as informações de memória nas métricas de desempenho

Fluxo de trabalho de exemplo:

You: "My application takes too long to load"
Claude: Let me analyse the performance of your application.

get_page_info()

I can see your page has 47 scripts and took 3.2 seconds to load. Let me get more detailed performance data:

get_performance_metrics()

The main bottleneck is the initial JavaScript bundle which is 2.1MB. The DOM processing also takes 800ms.

Depurando Problemas de Autenticação

Quando o login ou o gerenciamento de sessão não está funcionando:

Navegue até sua página de login
Verifique cookies: Use get_cookies() para ver cookies de autenticação
Monitore a rede durante o login: Use monitor_console_live() e get_network_requests() durante o processo de login
Examine dados armazenados: Use a execução de JavaScript para verificar localStorage/sessionStorage

Fluxo de trabalho de exemplo:

You: "Users can't stay logged in"
Claude: Let me check the authentication setup.

get_cookies()

I can see the auth cookie is present. Let me check what happens during login by monitoring the network:

get_network_requests(filter_domain="your-api.com")

I notice the login request returns a 200 but no Set-Cookie header. Let me also check localStorage:

execute_javascript("Object.keys(localStorage)")

Inspeção de Elementos DOM

get_document(depth?, pierce?) - Recuperar a estrutura do documento DOM
query_selector(node_id, selector) - Encontrar um único elemento por seletor CSS
query_selector_all(node_id, selector) - Encontrar múltiplos elementos por seletor CSS
get_element_attributes(node_id) - Obter todos os atributos de um elemento
get_element_outer_html(node_id) - Obter o HTML externo de um elemento
get_element_box_model(node_id) - Obter informações de layout
describe_element(node_id, depth?) - Obter descrição detalhada do elemento
get_element_at_position(x, y) - Obter elemento na posição da tela
search_elements(query) - Pesquisar elementos DOM por texto/atributos
focus_element(node_id) - Focar um elemento DOM

Análise de Estilos CSS

get_computed_styles(node_id) - Obter estilos CSS calculados
get_inline_styles(node_id) - Obter estilos inline
get_matched_styles(node_id) - Obter todas as regras CSS que correspondem a um elemento
get_stylesheet_text(stylesheet_id) - Obter conteúdo da folha de estilos
get_background_colors(node_id) - Obter cores de fundo e fontes
get_platform_fonts(node_id) - Obter informações de fontes da plataforma
get_media_queries() - Obter todas as media queries
collect_css_class_names(stylesheet_id) - Coletar nomes de classes CSS
start_css_coverage_tracking() - Iniciar rastreamento de cobertura CSS
stop_css_coverage_tracking() - Parar e obter resultados de cobertura CSS

Comandos Comuns

Tarefa	Comando
Iniciar Chrome e conectar à aplicação	`start_chrome_and_connect("localhost:3000")`
Iniciar Chrome (configuração manual)	`start_chrome()`
Navegar para página	`navigate_to_url("localhost:3000")`
Conectar ao navegador	`connect_to_browser()`
Ver todas as requisições de rede	`get_network_requests()`
Encontrar chamadas de API com falha	`get_network_requests(filter_status=404)`
Verificar erros de JavaScript	`get_console_error_summary()`
Observar console em tempo real	`monitor_console_live(10)`
Verificar desempenho de carregamento de página	`get_page_info()`
Examinar uma variável	`inspect_console_object("window.myApp")`
Visualizar cookies	`get_cookies()`
Executar JavaScript	`execute_javascript("document.title")`

Configuração

Variáveis de Ambiente

CHROME_DEBUG_PORT - Porta de depuração remota do Chrome (padrão: 9222)

Compatibilidade MCP

Versão do Protocolo MCP: 2024-11-05
Versão Mínima do Python: 3.10+
Clientes MCP Suportados: Claude Desktop, qualquer cliente compatível com MCP
Gerenciador de Pacotes: uv (recomendado) ou pip

Fluxo de Trabalho de Uso

Pré-requisitos (Seu Ambiente de Desenvolvimento)

Tenha sua aplicação web em execução (ex.: npm run dev, python -m http.server, etc.)
Anote a URL onde sua aplicação está acessível

Sessão de Depuração

Conecte-se à sua aplicação via Claude Desktop:
```
start_chrome_and_connect("localhost:3000")
```
Substitua pela URL da sua aplicação
Depure sua aplicação usando as ferramentas MCP:
- Monitore requisições de rede
- Verifique erros de console
- Inspecione objetos JavaScript
- Analise o desempenho
Faça alterações no seu código no seu editor
Atualize ou interaja com sua aplicação
Continue depurando com dados em tempo real

Conexão Manual (Alternativa)

Se preferir controle passo a passo:

start_chrome() - Iniciar Chrome com depuração
navigate_to_url("your-app-url") - Navegar até sua aplicação
connect_to_browser() - Conectar o servidor MCP
Use as ferramentas de depuração conforme necessário

Notas de Segurança

Use apenas com ambientes de desenvolvimento
Nunca conecte a instâncias de produção do Chrome
O servidor foi projetado apenas para depuração em localhost
Nenhum dado é armazenado permanentemente — todos os dados são baseados em sessão

Solução de Problemas

Servidor Aparece como "Desabilitado" no Claude Desktop

Se o servidor aparecer no Claude mas mostrar "desabilitado", tente estas etapas:

Verifique os logs do Claude Desktop:
- macOS: ~/Library/Logs/Claude/mcp*.log
- Windows: %APPDATA%/Claude/logs/mcp*.log

Correções comuns:

# Reinstall with verbose output
mcp remove "Chrome DevTools MCP"
mcp install server.py -n "Chrome DevTools MCP" --with-editable . -v CHROME_DEBUG_PORT=9222

# Check installation status
mcp list

# Test the server manually
python3 server.py

Verifique as dependências:

# Ensure all dependencies are available
pip install mcp websockets aiohttp

# Test imports
python3 -c "from server import mcp; print('OK')"

Reinicie o Claude Desktop completamente (saia e reabra)

Problemas de Instalação

MCP CLI não encontrado: Instale o MCP CLI do Python MCP SDK com pip install mcp
Servidor não aparecendo no Claude:
- Para MCP CLI: Execute mcp list para verificar se o servidor está instalado
- Para configuração manual: Verifique o caminho do arquivo de configuração do Claude Desktop e a sintaxe JSON
Erros de importação:
- Para MCP CLI: Use --with-editable . para instalar dependências locais
- Para configuração manual: Execute pip install -r requirements.txt
Erros de permissão: Use caminhos absolutos na configuração
Variáveis de ambiente não funcionando: Verifique o formato do arquivo .env ou a sintaxe da flag -v
Módulo não encontrado: Certifique-se de usar a flag --with-editable . para instalação local de pacotes

Etapas de Depuração

Passo 1: Verifique o status do MCP CLI

# List all installed servers
mcp list

# Check specific server status
mcp status "Chrome DevTools MCP"

Passo 2: Teste o servidor manualmente

# Test if server starts without errors
python3 server.py

# Test imports
python3 -c "from server import mcp; print(f'Server: {mcp.name}')"

Passo 3: Verifique a configuração

Para Claude Desktop:

# View current configuration (macOS)
cat "~/Library/Application Support/Claude/claude_desktop_config.json"

# View current configuration (Windows)
type "%APPDATA%/Claude/claude_desktop_config.json"

Para Claude Code:

# List configured MCP servers
claude mcp list

# Get details about a specific server
claude mcp get chrome-devtools

# IMPORTANT: Verify paths are absolute, not relative
# Good example output:
#   Command: /Users/you/chrome-devtools-mcp/.venv/bin/python
#   Args: ["/Users/you/chrome-devtools-mcp/server.py"]
# Bad example output:
#   Command: python
#   Args: ["server.py"]

# Test the exact command Claude Code will use
/path/to/.venv/bin/python /path/to/server.py

# Check if server is working
claude mcp serve --help

Passo 3.5: Corrija problemas de caminho (específico do Claude Code)

# If paths are relative, remove and re-add with absolute paths
claude mcp remove chrome-devtools

# Re-add with absolute paths
SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"
claude mcp add chrome-devtools "$PYTHON_PATH" "$SERVER_PATH" -e CHROME_DEBUG_PORT=9222

Passo 4: Reinstale se necessário

Para MCP CLI:

# Clean reinstall
mcp remove "Chrome DevTools MCP"
mcp install server.py -n "Chrome DevTools MCP" --with-editable .

# Restart Claude Desktop completely

Para Claude Code:

# Remove and re-add the server
claude mcp remove chrome-devtools
claude mcp add chrome-devtools python server.py -e CHROME_DEBUG_PORT=9222

# Or update with different scope
claude mcp add chrome-devtools python server.py -s user -e CHROME_DEBUG_PORT=9222

Mensagens de Erro Comuns

Erro	Solução
"Módulo não encontrado"	Use a flag `--with-editable .`
"Nenhum objeto de servidor encontrado"	O servidor deve exportar o objeto `mcp` (já corrigido)
"Erro de importação"	Verifique `pip install mcp websockets aiohttp`
"Permissão negada"	Use caminhos absolutos na configuração
"Servidor desabilitado"	Verifique os logs do Claude Desktop, reinicie o Claude
"python: comando não encontrado" (Claude Code)	Use o caminho absoluto para o Python do venv: `/path/to/.venv/bin/python`
"server.py: Arquivo não encontrado" (Claude Code)	Use o caminho absoluto para o servidor: `/path/to/server.py`
"ModuleNotFoundError" (Claude Code)	Use o Python do venv que tenha as dependências instaladas

Fallback de Configuração Manual

Para Claude Desktop: Se o MCP CLI não estiver funcionando, adicione isso à configuração do Claude Desktop manualmente:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "python3",
      "args": ["/absolute/path/to/chrome-devtools-mcp/server.py"],
      "env": {
        "CHROME_DEBUG_PORT": "9222"
      }
    }
  }
}

Para Claude Code: Se o comando claude mcp add não estiver funcionando, você pode usar o formato JSON com caminhos absolutos:

# Get absolute paths first
SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"

# Add server using JSON configuration with absolute paths
claude mcp add-json chrome-devtools "{
  \"command\": \"$PYTHON_PATH\",
  \"args\": [\"$SERVER_PATH\"],
  \"env\": {
    \"CHROME_DEBUG_PORT\": \"9222\"
  }
}"

# Or if you have it working in Claude Desktop, import from there
claude mcp add-from-claude-desktop

Exemplo de configuração correta do Claude Code (com caminhos absolutos):

{
  "command": "/Users/you/chrome-devtools-mcp/.venv/bin/python",
  "args": ["/Users/you/chrome-devtools-mcp/server.py"],
  "env": {
    "CHROME_DEBUG_PORT": "9222"
  }
}

Problemas de Conexão

O Chrome não inicia: O servidor MCP iniciará o Chrome automaticamente quando você usar start_chrome()
Não consegue conectar: Tente get_connection_status() para verificar a conexão
Ferramentas não funcionando: Certifique-se de ter chamado connect_to_browser() ou usado start_chrome_and_connect()

Equívocos Comuns

Isto não é um servidor web: O servidor MCP roda dentro do Claude Desktop, não como um serviço web separado
Nenhuma instalação separada necessária: Uma vez configurado no Claude Desktop, o servidor inicia automaticamente
Seu aplicativo roda separadamente: Esta ferramenta se conecta ao seu aplicativo web existente, não o executa

Desenvolvimento e Testes

Esta seção é para desenvolvedores que desejam testar ou modificar o próprio servidor MCP.

Configuração de Desenvolvimento

Com uv (recomendado):

git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
uv sync

Com pip:

git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
pip install -e ".[dev]"

Ferramentas de Qualidade de Código

# Format code
uv run ruff format .

# Lint code  
uv run ruff check .

# Type checking
uv run mypy src/

Compilando a Extensão

Instale as ferramentas de empacotamento DXT:

npm install -g @anthropic-ai/dxt

Compile a extensão:

# Quick build
make package

# Or manually
npx @anthropic-ai/dxt pack

Usando Makefile para desenvolvimento:

make help           # Show all commands
make install        # Install dependencies
make dev            # Setup development environment + pre-commit
make check          # Run all checks (lint + type + test)
make pre-commit     # Run pre-commit hooks manually
make package        # Build .dxt extension
make release        # Full release build

Hooks de Pre-commit

Este projeto usa hooks de pre-commit para garantir a qualidade do código:

ruff: Linting e formatação
mypy: Verificação de tipos
pytest: Validação de testes
Validação MCP: Verificação de registro do servidor

Os hooks de pre-commit são executados automaticamente em git commit e podem ser executados manualmente com make pre-commit.

Licença

Licença MIT