DeepADB

O servidor MCP mais profundo do Android Debug Bridge — 147 ferramentas da interface ao baseband.

Documentação

DeepADB

Servidor MCP (Model Context Protocol) para agentes de IA que precisam inspecionar, controlar, testar e diagnosticar dispositivos Android via ADB—ou diretamente no dispositivo através do Termux.

209 ferramentas, 5 recursos e 4 prompts em 49 módulos—desde automação de UI e gerenciamento de aplicativos até logs, captura de rede, banda base, firmware, segurança e diagnósticos de hardware.

Começando

O DeepADB executa como um servidor MCP local. Ele usa ADB por padrão e alterna automaticamente para execução direta quando detecta o Termux em um dispositivo Android.

git clone https://github.com/fullread/DeepADB.git
cd DeepADB
npm ci
npm run build
npm start

Adicione build/index.js à configuração do seu cliente MCP e comece com estes fluxos de trabalho:

Objetivo	Comece com
Confirmar o conjunto de ferramentas e o dispositivo conectado	`adb_health_check`, depois `adb_devices`
Inspecionar a UI Android atual	`adb_screen_state`, depois `adb_ui_dump`
Diagnosticar um dispositivo ou aplicativo	`adb_device_info`, `adb_logcat` e `adb_dumpsys`

Para uma conexão local guiada, consulte Configuração do Claude Code. Leia SECURITY.md antes de expor transportes HTTP, WebSocket ou GraphQL além do loopback.

Arquitetura

┌──────────────────────────────────────────────────┐
│                   MCP Client                     │
│             (Claude Code / claude.ai)            │
└──────────────────────┬───────────────────────────┘
                       │ stdio (JSON-RPC) or HTTP/SSE or WebSocket
┌──────────────────────▼───────────────────────────┐
│               DeepADB Server                     │
│                                                  │
│  ┌─────────────────────────────────────────────┐ │
│  │           Tool Modules (49)                 │ │
│  │  device │ shell │ packages │ files │ logs   │ │
│  │  diagnostics │ ui │ build │ health          │ │
│  │  wireless │ control │ logcat-watch          │ │
│  │  forwarding │ screen-record │ emulator      │ │
│  │  testing │ multi-device │ snapshot          │ │
│  │  network-capture │ ci │ plugins │ baseband  │ │
│  │  accessibility │ regression                 │ │
│  │  device-farm │ registry │ at-commands       │ │
│  │  screenshot-diff │ workflow │ sensors       │ │
│  │  split-apk │ mirroring │ test-gen           │ │
│  │  ota-monitor │ ril-intercept                │ │
│  │  device-profiles │ firmware-analysis        │ │
│  │  workflow-market │ selinux-audit            │ │
│  │  thermal-power │ network-discovery          │ │
│  │  input-gestures │ wireless-firmware         │ │
│  │  app-network │ database-inspector           │ │
│  │  runtime-audit │ wear                       │ │
│  ├─────────────────────────────────────────────┤ │
│  │  Resources (5) │ Prompts (4)                │ │
│  └───────────────────┬─────────────────────────┘ │
│                      │                           │
│  ┌───────────────────▼─────────────────────────┐ │
│  │          ToolContext (unified DI)           │ │
│  │  server │ bridge │ deviceManager            │ │
│  │  logger │ security │ config                 │ │
│  └───────────────────┬─────────────────────────┘ │
│                      │                           │
│  ┌───────────────────▼─────────────────────────┐ │
│  │           Middleware Layer                  │ │
│  │  OutputProcessor │ SecurityMiddleware       │ │
│  │  InputSanitizer │ Logger (stderr-safe)      │ │
│  └───────────────────┬─────────────────────────┘ │
│                      │                           │
│  ┌───────────────────▼─────────────────────────┐ │
│  │         Bridge Layer (auto-detect)          │ │
│  │                                             │ │
│  │  ┌─────────────┐    ┌────────────────────┐  │ │
│  │  │  ADB Bridge  │ OR │  Local Bridge      │ │ │
│  │  │  (PC mode)   │    │  (on-device mode)  │ │ │
│  │  │  via adb.exe │    │  via sh/su direct  │ │ │
│  │  └──────┬───────┘    └────────┬───────────┘ │ │
│  │         │                     │             │ │
│  │  Retry │ Timeout │ Cache │ Serial routing   │ │
│  └─────────┼─────────────────────┼─────────────┘ │
└────────────┼─────────────────────┼───────────────┘
             │                     │
     ┌───────▼───────┐    ┌───────▼───────┐
     │  ADB Binary   │    │   sh / su     │
     │  (USB/WiFi)   │    │   (local)     │
     └───────┬───────┘    └───────┬───────┘
             │                    │
       ┌─────▼────────────────────▼─────┐
       │          Android Device        │
       └────────────────────────────────┘

Arquitetura de Modo Duplo

O DeepADB opera em dois modos, detectados automaticamente na inicialização:

Modo ADB (padrão) — ponte pelo PC

AI Agent (PC) ←→ MCP ←→ DeepADB (PC) ←→ ADB (USB) ←→ Android Device

Modo padrão: o DeepADB executa em um host PC/Mac/Linux e se comunica com o dispositivo via USB usando ADB. A superfície completa de 209 ferramentas é registrada através da ponte ADB com nova tentativa automática em falhas transitórias; ferramentas específicas do ambiente relatam seus requisitos de capacidade quando um host não pode executá-las.

Modo no Dispositivo — execução local direta

AI Agent (Termux) ←→ MCP (stdio/HTTP) ←→ DeepADB (Termux) ←→ sh/su (local)

Quando o DeepADB executa diretamente no dispositivo Android (por exemplo, dentro do Termux), ele detecta automaticamente o ambiente e alterna para LocalBridge. Os comandos são executados diretamente via sh/su — sem servidor ADB, sem USB, sem sobrecarga de serialização. A mesma superfície MCP de 209 ferramentas é registrada, com orientação ciente de capacidade quando um binário opcional no dispositivo, como sqlite3, não está disponível.

Validação de hardware do host v1.1.4: a regressão completa do Pixel 6a / Android 16 foi concluída com 604 aprovados, 0 falhas e 17 pulos esperados específicos do ambiente (621 no total). Isso inclui validação AT/OK ao vivo em /dev/umts_router, um snapshot de esquema SQLite somente leitura protegido com limpeza, a auditoria de runtime unificada, contexto de rota por aplicativo e o pré-voo Wear de dispositivo único. Os pulos são as cinco verificações QEMU somente no dispositivo, mais doze verificações de segurança do host Windows ou tcpdump indisponível.

Linha de base de hardware v1.1.3: validado em um Pixel 6a (Android 16, Termux + Magisk + QEMU 10.2.1) em uma matriz de teste de quatro células — host (ADB) e no dispositivo (LocalBridge), cada um com e sem PIN do dispositivo — com 0 falhas em cada célula. A suíte v1.1.3 continha 577 testes na configuração host/ADB e 613 no dispositivo; a diferença são as suítes de virtualização QEMU e inicialização de VM Alpine, que executam apenas no dispositivo:

Modo ADB, sem PIN: 556 aprovados / 0 falhas / 21 pulados (577 no total). Pulados: 5 QEMU (somente no dispositivo), 7 testes de unidade gracefulKill (exigem sinais POSIX, pulados no host Windows), 3 sanitização tcpdump (tcpdump é somente root e inacessível via shell ADB não root), 2 idas e voltas do shell do host (exigem /bin/sh POSIX), 4 estado de tela (exigem DA_TEST_PIN).
Modo ADB, com PIN: 560 aprovados / 0 falhas / 17 pulados (577 no total). Os 4 testes de estado de tela desbloqueiam e executam.
Modo no dispositivo, sem PIN: 606 aprovados / 0 falhas / 7 pulados (613 no total). Todos os testes QEMU executam, incluindo inicialização de VM Alpine Linux com aceleração KVM, detecção de topologia de CPU big.LITTLE, tratamento de erros de conectividade ADB convidado e desligamento limpo da VM; as suítes tcpdump e gracefulKill também executam aqui (root + POSIX). Pulados: 3 etapas de configuração QEMU que não operam quando o kernel/initrd/disco Alpine já estão em cache, 4 estado de tela (exigem PIN).
Modo no dispositivo, com PIN: 610 aprovados / 0 falhas / 3 pulados (613 no total). Todos os testes habilitados pelo ambiente executam; os 3 pulos são as etapas de configuração da VM em cache.

Elevação de privilégios: No modo ADB, todos os comandos de shell executam como uid=2000 (o usuário shell) que tem permissões de nível de sistema. No Termux, os comandos executam como um usuário de aplicativo comum. O LocalBridge eleva automaticamente comandos privilegiados através de su quando root (Magisk) está disponível:

Lista de permissão de comandos: 16 comandos de sistema (settings, dumpsys, am, input, screencap, screenrecord, uiautomator, app_process, getenforce, setenforce, cmd, pm, wm, svc, ip, ifconfig) são roteados através de su -c para corresponder ao comportamento do modo ADB.
Elevação baseada em caminho: Comandos que referenciam caminhos /sdcard, /storage ou /system/ são elevados para contornar as restrições de armazenamento com escopo do Android.
Detecção de root: Armazenada em cache após uma única sondagem su -c id no primeiro uso. Degradação graciosa quando root não está disponível.
A lista de permissão de elevação é congelada (ReadonlySet + Object.freeze) — não configurável via variáveis de ambiente ou API de runtime.

Auto-detecção: Verifica /system/build.prop (presente em todos os dispositivos Android, nunca em hosts). Substitua com DA_LOCAL=true ou DA_LOCAL=false.

Configuração no dispositivo (Termux):

pkg install nodejs-lts git
git clone <deepadb-repo> && cd deepadb
npm install && npm run build
npm start                              # stdio — for local AI agents (Claude Code, OpenCode)
DA_HTTP_PORT=3000 npm start            # HTTP/SSE — for remote AI access over WiFi

Configuração do Claude Code

{
  "mcpServers": {
    "deepadb": {
      "command": "node",
      "args": ["/path/to/DeepADB/build/index.js"]
    }
  }
}

Ferramentas Disponíveis (209)

Comece pela área de capacidade que corresponde à sua tarefa; a referência completa permanece abaixo.

Área	Inclui
Inspecionar e diagnosticar	Dispositivo, pacotes, arquivos, logs, diagnósticos, auditoria de runtime e SQLite
Controlar e automatizar	UI, controle do dispositivo, automação de entrada e sessões de teste
Conectar e escalar	Depuração sem fio, encaminhamento de porta, roteamento por aplicativo, pré-voo Wear, orquestração multi-dispositivo e CI/CD
Analisar internals do Android	Captura de rede, banda base, firmware, SELinux e sensores
Estender fluxos de trabalho	Plugins, orquestração de fluxos de trabalho, perfis de dispositivo e handles de resultado

Referência completa de ferramentas

Saúde (1 ferramenta)

adb_health_check — Validação abrangente do conjunto de ferramentas: binário ADB, servidor, conexão do dispositivo, autorização, acesso root e capacidade de gravação do armazenamento

Auditoria de Runtime (1 ferramenta)

adb_runtime_audit — Auditoria de prontidão unificada somente leitura para transporte, userspace Android, root, SELinux, armazenamento, capacidades de comando, diagnósticos de UI/rede, SQLite, nós de modem e pré-requisitos Wear

Dispositivo (3 ferramentas)

adb_devices — Lista todos os dispositivos conectados com estado, modelo e informações do produto
adb_device_info — Propriedades detalhadas do dispositivo (modelo, SO, SDK, build, patch de segurança, ABI)
adb_getprop — Lê uma propriedade de sistema específica ou despeja todas as propriedades

Shell (2 ferramentas)

adb_shell — Executa comandos de shell arbitrários com timeout configurável (verificado por segurança)
adb_root_shell — Executa comandos como root via su (requer dispositivo com root, verificado por segurança)

Pacotes (12 ferramentas)

adb_install — Instala APK com opções de substituição/downgrade
adb_uninstall — Remove pacote com retenção opcional de dados
adb_list_packages — Lista pacotes filtrados por nome ou tipo (todos/sistema/terceiros)
adb_package_info — Informações detalhadas do pacote (versão, permissões, caminhos)
adb_clear_data — Limpa todos os dados e cache do aplicativo
adb_grant_permission — Concede uma permissão de runtime a um pacote
adb_revoke_permission — Revoga uma permissão de runtime de um pacote (redefine o estado da permissão para testar fluxos de negação)
adb_list_permissions — Lista todas as permissões declaradas e concedidas para um pacote, filtrável por concedida/negada
adb_force_stop — Força a parada de um aplicativo imediatamente
adb_start_app — Inicia um aplicativo pelo nome do pacote (resolve a atividade do launcher)
adb_restart_app — Força a parada e reinicia em uma única chamada (atraso configurável)
adb_resolve_intents — Descobre atividades, serviços e receptores registrados com filtros de intent

Inspeção de Room e SQLite (1 ferramenta)

adb_sqlite_inspect — Listagem de banco de dados com escopo de pacote, inspeção de esquema e SQL somente leitura validado com limites rígidos de linhas/saída. Prefere run-as, recorre a root, rejeita arquivos de banco de dados/WAL de link simbólico, usa sqlite3 do dispositivo quando presente e, caso contrário, exclui um snapshot privado e limitado do lado do host após a inspeção

Arquivos (18 ferramentas)

adb_push — Envia arquivo local para o dispositivo (caminhos de kernel bloqueados, consciência de tipo de fs, relatório de armazenamento)
adb_pull — Puxa arquivo do dispositivo para o sistema de arquivos local
adb_ls — Lista o conteúdo do diretório do dispositivo (simples ou detalhado)
adb_cat — Lê arquivo de texto do dispositivo com limite opcional de linhas
adb_file_write — Cria ou sobrescreve arquivos de texto via heredoc (aviso de limite de buffer, consciência de fs, pós-verificação)
adb_find — Procura arquivos por nome/padrão com controle de profundidade e limite de resultados
adb_file_stat — Metadados do arquivo: tamanho, permissões, timestamps, propriedade, contexto SELinux
adb_file_checksum — Hash SHA-256/SHA-1/MD5 com estimativa de timeout baseada em tamanho
adb_mkdir — Cria diretórios com criação de pais (-p), caminhos de kernel bloqueados
adb_rm — Exclui arquivos/diretórios com proteção recursiva baseada em profundidade e resolução de link simbólico
adb_file_move — Move/renomeia com proteção de profundidade de origem e pós-verificação
adb_file_copy — Copia com verificação prévia de tamanho+espaço e correspondência de tamanho pós-verificação
adb_file_chmod — Altera permissões (modo octal validado por Zod, proteção recursiva baseada em profundidade)
adb_file_touch — Cria arquivos vazios ou atualiza timestamps (suporte explícito a timestamp)
adb_file_fsinfo — Relatório do sistema de arquivos: tipo, montagem, capacidade, capacidades, SELinux, limitações
adb_file_chown — Altera propriedade (requer root, proteção recursiva baseada em profundidade)
adb_grep — Procura conteúdo de arquivos com padrão de string fixa por padrão, controle de profundidade recursiva, limite de resultados
adb_file_replace — Localiza/substitui texto em arquivos (baseado em sed, escape adequado, opção de backup)

Logs — Snapshots (3 ferramentas)

adb_logcat — Snapshot logcat filtrado com seleção de tag, prioridade, grep e buffer
adb_logcat_clear — Limpa todos os buffers logcat
adb_logcat_crash — Snapshot do log do buffer de crash

Logs — Observadores Persistentes (4 ferramentas)

adb_logcat_start — Inicia um observador logcat em segundo plano com acumulação em buffer circular
adb_logcat_poll — Recupera novas linhas desde a última consulta de um observador em execução
adb_logcat_stop — Para uma sessão de observador (ou todas as sessões)
adb_logcat_sessions — Lista todas as sessões de observador ativas com estatísticas

Diagnóstico (9 ferramentas)

adb_dumpsys — Executa dumpsys para qualquer serviço (ou lista todos os serviços)
adb_telephony — Informações de célula, intensidade do sinal e registro de rede (consulta paralela)
adb_battery — Status da bateria, nível, temperatura e informações de carregamento
adb_network — Conectividade WiFi, celular e IP (consulta paralela)
adb_top — Instantâneo de uso de CPU e memória
adb_perf_snapshot — Perfil paralelo de memória, estatísticas de quadros e CPU para um pacote
adb_bugreport — Captura completa de relatório de bug em zip (estado do dispositivo, logs, informações do sistema)
adb_crash_logs — Rastreamentos de ANR e despejos de falha tombstone de /data/anr/ e /data/tombstones/
adb_heap_dump — Captura de despejo de heap (.hprof) de um processo em execução para análise de memória

Contexto de Rota por Aplicativo (1 ferramenta)

adb_app_route_context — Resolve um pacote instalado para seu UID e correlaciona seus intervalos efetivos de ip rule, tabelas de rota, política de rede, VPN e estado da rede padrão sem alterar rotas ou políticas

Interface do Usuário (10 ferramentas)

adb_screencap — Tira screenshot com sanitização de nome de arquivo, salva localmente
adb_screencap_annotated — Screenshot com caixas delimitadoras de elementos de UI e rótulos numerados compostos no PNG. Retorna o caminho da imagem anotada mais uma legenda de texto. Ideal para fluxos de trabalho de LLM que referenciam elementos por número
adb_current_activity — Obtém a atividade em foco e a pilha de janelas superior
adb_input — Envia entrada de toque, deslize, texto ou keyevent
adb_start_activity — Inicia atividades por intent ou nome de componente
adb_ui_dump — Despeja a hierarquia completa da UI. Suporta três formatos de saída: text (padrão, legível por humanos), tsv (separado por tabulações compacto para loops de automação eficientes em tokens), xml (XML bruto do uiautomator)
adb_ui_find — Pesquisa a hierarquia da UI por texto, resource-id ou content-description (retorna coordenadas de toque)
adb_screen_state — Estado combinado da tela em uma chamada: atividade em primeiro plano, dimensões e densidade da tela, orientação, nível da bateria e uma lista TSV de elementos interativos. Substitui 3–4 chamadas de ferramenta separadas
adb_screenrecord_start — Inicia a gravação da tela do dispositivo (1-180s, armazenada no dispositivo)
adb_screenrecord_stop — Para a gravação e puxa o arquivo de vídeo mp4 localmente

Controle do Dispositivo (9 ferramentas)

adb_airplane_mode — Alterna o modo avião com broadcast e verificação
adb_airplane_cycle — Cicla o modo avião ligado/desligado para forçar o re-registro celular
adb_wifi — Ativa ou desativa o WiFi
adb_mobile_data — Ativa ou desativa os dados móveis
adb_location — Define o modo de localização (off/sensors/battery/high)
adb_screen — Acorda, dorme, alterna, bloqueia ou desbloqueia a tela. O bloqueio verifica o estado do keyguard via dumpsys window. O desbloqueio usa wm dismiss-keyguard (funciona para keyguards de deslize); forneça pin para executar a sequência completa de entrada de PIN: acorda a tela, desliza para cima para revelar o teclado, digita o PIN, confirma e verifica se o token de suspensão do keyguard foi liberado
adb_settings_get — Lê qualquer configuração do Android dos namespaces system/secure/global
adb_settings_put — Escreve qualquer configuração do Android com verificação de leitura de volta
adb_reboot — Reinicia o dispositivo (modo normal, recovery ou bootloader)

Depuração sem Fio (4 ferramentas)

adb_pair — Pareia com o dispositivo via WiFi usando código de pareamento
adb_connect — Conecta ao dispositivo via WiFi/TCP
adb_disconnect — Desconecta dispositivo(s) sem fio
adb_tcpip — Alterna o dispositivo USB para o modo TCP/IP (detecta automaticamente o IP do dispositivo)

Encaminhamento de Portas (8 ferramentas)

adb_forward — Encaminha uma porta local para uma porta do dispositivo (host → dispositivo)
adb_reverse — Encaminhamento reverso de uma porta do dispositivo para o host (dispositivo → host)
adb_forward_list — Lista todos os mapeamentos de portas de encaminhamento e reverso ativos
adb_forward_remove — Remove um encaminhamento de porta ou todos os encaminhamentos
adb_reverse_remove — Remove um encaminhamento reverso ou todos os encaminhamentos reversos
adb_tunnel_open — Abre um túnel gerenciado com ID opaco. Escolhe automaticamente uma porta host livre para a direção de encaminhamento quando omitida; registra limpeza para que o túnel seja removido na saída do servidor
adb_tunnel_list — Lista túneis gerenciados ativos (aqueles abertos via adb_tunnel_open). Filtro opcional por dispositivo; mostra ID, direção, endpoints e idade
adb_tunnel_close — Fecha um túnel gerenciado por ID, ou fecha todos de uma vez com id="all"

Gerenciamento de Emulador (3 ferramentas)

adb_avd_list — Lista AVDs disponíveis (modo PC) ou detecta capacidades de virtualização KVM/QEMU (modo no-dispositivo)
adb_emulator_start — Inicia um AVD com opções headless, cold boot e GPU (modo PC) ou relata alternativa QEMU (modo no-dispositivo)
adb_emulator_stop — Desliga graciosamente um emulador em execução

Virtualização QEMU/KVM (8 ferramentas)

adb_qemu_setup — Verifica e instala QEMU para virtualização no-dispositivo. Verifica KVM, relata CPU/RAM do host, instala via Termux pkg
adb_qemu_images — Gerencia imagens de disco de VM: lista, cria (qcow2/raw), exclui. Verificação de contenção de caminho previne traversal
adb_qemu_start — Inicia uma VM acelerada por KVM com alocação dinâmica de recursos. Detecta automaticamente CPUs ideais (total menos 1, reservando um para o host) e memória (65% da RAM física). Suporta kernel/initrd/append para boot Android, encaminhamento de porta ADB
adb_qemu_stop — Para uma VM em execução (SIGTERM gracioso ou SIGKILL forçado). Desconecta automaticamente o ADB do convidado antes de matar. Relata VMs em execução se nenhum nome for fornecido
adb_qemu_status — Status completo: disponibilidade KVM/QEMU, orçamento de recursos do host, VMs em execução com PID/recursos/uptime/portas/estado de conexão ADB, inventário de imagens
adb_qemu_connect — Conecta ao serviço ADB convidado de uma VM em execução. Restrito apenas a localhost — porta derivada do estado da VM em execução, nunca da entrada do usuário. Habilita ferramentas multi-dispositivo para operar em VMs convidadas
adb_qemu_disconnect — Desconecta do serviço ADB de uma VM convidada. Limpa o estado da conexão e remove o convidado da lista de dispositivos
adb_qemu_guest_shell — Executa comandos shell em uma VM convidada via ADB. Sujeito ao middleware de segurança. Serial do convidado derivado internamente — nenhum host/IP fornecido pelo usuário alcança o binário ADB

Sessões de Teste (3 ferramentas)

adb_test_session_start — Inicia uma sessão de teste nomeada com diretório de saída organizado
adb_test_step — Captura uma etapa numerada com screenshot e logcat na sessão
adb_test_session_end — Encerra a sessão, escreve o manifesto de resumo, retorna o caminho do diretório

Orquestração Multi-Dispositivo (4 ferramentas)

adb_multi_shell — Executa um comando em todos/dispositivos selecionados em paralelo (verificado por segurança)
adb_multi_install — Instala um APK em vários dispositivos simultaneamente
adb_multi_compare — Executa um comando em todos os dispositivos e destaca diferenças de saída
adb_multi_test — Fluxo de trabalho de teste comparativo: executa perfis de diagnóstico predefinidos (firmware/segurança/rede/identidade/completo) ou listas de comandos personalizadas em todos os dispositivos, incluindo convidados QEMU, compara por verificação, relata correspondências e diferenças

Camada de Dados Wear (1 ferramenta)

adb_wear_datalayer_preflight — Pré-verificação somente leitura de papel telefone/relógio, Google Play services, Bluetooth, pacote opcional, associação de companheiro e serviço de Camada de Dados; identificadores de pareamento são intencionalmente omitidos

Gestos de Entrada e Automação de UI (15 ferramentas)

adb_input_drag — Arrasta do ponto A ao ponto B (usa draganddrop com fallback de deslize para Android mais antigo)
adb_input_fling — Gesto de fling de alta velocidade para rolagem por momentum em listas e visualizações paginadas (duração configurável 20-200ms)
adb_input_long_press — Pressionamento longo em coordenadas com duração de retenção configurável
adb_input_double_tap — Toque duplo com intervalo configurável entre toques
adb_input_text — Entrada de texto dedicada com tratamento de espaço/caracteres especiais
adb_open_url — Abre uma URL no dispositivo via intent VIEW
adb_orientation — Obtém ou define a orientação da tela (auto/portrait/landscape/reverse)
adb_clipboard — Lê ou escreve a área de transferência do dispositivo
adb_input_pinch — Gesto de pinça multi-toque (zoom out) ou espalhar (zoom in). Dois dedos se movem simetricamente em torno de um ponto central. Injeção em camadas: input swipe paralelo (universal, sem root) ou sendevent bruto protocolo MT Type B (verdadeiro multi-toque, requer root). Detecta automaticamente o dispositivo de tela sensível ao toque e capacidades via getevent -p. Centro, raio, duração, ângulo e etapas de interpolação configuráveis
adb_tap_element — Encontra elemento por texto/resource-id/content-description e toca em seu centro
adb_wait_element — Consulta a hierarquia da UI até um elemento aparecer ou desaparecer (timeout/intervalo de consulta configuráveis)
adb_wait_stable — Consulta até que despejos de UI consecutivos correspondam (estabilização da tela após transições)
adb_scroll_until — Rola repetidamente até que um elemento alvo seja encontrado, com auto-toque opcional
adb_screenshot_compressed — Captura screenshot com metadados de tamanho/qualidade para fluxos de trabalho eficientes em tokens
adb_batch_actions — Executa múltiplas ações de entrada (tap/swipe/fling/long_press/double_tap/keyevent/text/drag/pinch/back/home/sleep) em uma única chamada de ferramenta com validação de segurança

Consciência do Dispositivo (3 ferramentas)

adb_screen_size — Resolução da tela, densidade de exibição (DPI), proporção de aspecto e largura DP em uma chamada
adb_device_state — Instantâneo combinado: nível/status/temperatura da bateria, tipo de rede, estado WiFi, tela ligada/desligada, orientação, atividade em primeiro plano
adb_notifications — Analisa notificações ativas com pacote, título, texto, importância, canal, flags e timestamp (filtrável por pacote)

Snapshot/Restauração (3 ferramentas)

adb_snapshot_capture — Salva estado abrangente do dispositivo (pacotes, configurações, propriedades) em JSON
adb_snapshot_compare — Compara o estado atual com um snapshot salvo (pacotes adicionados/removidos, configurações alteradas)
adb_snapshot_restore_settings — Restaura configurações global/secure de um snapshot salvo

Captura de Rede (3 ferramentas)

adb_tcpdump_start — Inicia captura de pacotes em segundo plano via tcpdump (requer root)
adb_tcpdump_stop — Para a captura e puxa o arquivo pcap localmente para análise no Wireshark
adb_network_connections — Mostra conexões TCP/UDP ativas (ss/netstat com fallback /proc/net)

Integração CI/CD (3 ferramentas)

adb_ci_wait_boot — Aguarda o dispositivo/emulador inicializar completamente com timeout configurável
adb_ci_device_ready — Verificação estruturada de prontidão pass/fail (boot, PM, tela, rede, disco)
adb_ci_run_tests — Executa testes instrumentados via am instrument com resultados pass/fail analisados

Baseband/Modem (6 ferramentas)

adb_baseband_info — Firmware do modem, implementação RIL, chipset, configuração SIM (detecção de SIM duplo com estado por slot), registro de rede. Recuperação de IMEI é somente opt-in (includeImei=true)
adb_cell_identity — Cell ID (CID), TAC/LAC, EARFCN, PCI, PLMN de dumpsys phone para análise de rede celular
adb_signal_detail — RSRP, RSRQ, SINR, RSSI, timing advance — medições de rádio brutas para análise de sinal
adb_neighboring_cells — Todas as células LTE/5G/WCDMA/GSM visíveis com identidades e intensidades de sinal
adb_carrier_config — Despejo de configuração da operadora, ID da operadora, APN preferido
adb_modem_logs — Buffer de rádio RIL, framework de telefonia, RILJ/RILC, logs de modem do kernel dmesg (root)

Auditoria de Acessibilidade (3 ferramentas)

adb_a11y_audit — Auditoria WCAG automatizada: rótulos ausentes, alvos de toque subdimensionados (<48dp), descrições duplicadas, clicáveis sem foco
adb_a11y_touch_targets — Lista todos os elementos interativos com dimensões de alvo de toque em dp, sinaliza subdimensionados
adb_a11y_tree — Árvore de UI focada em acessibilidade mostrando apenas elementos relevantes para leitor de tela com papéis, rótulos e estados

Detecção de Regressão (3 ferramentas)

adb_regression_baseline — Captura linha de base de desempenho (memória, CPU, estatísticas de quadros, bateria, rede) em JSON
adb_regression_check — Compara o desempenho atual com uma linha de base salva com limites de regressão configuráveis
adb_regression_history — Lista todas as linhas de base salvas com tendências, opcionalmente filtradas por pacote

Device Farm (3 ferramentas)

adb_farm_run — Executa testes instrumentados no Firebase Test Lab em vários modelos de dispositivos e níveis de API
adb_farm_results — Recupera resultados de uma execução do Test Lab ou lista matrizes de teste recentes
adb_farm_matrix — Lista modelos de dispositivos e versões Android disponíveis no Firebase Test Lab

Registro de Plugins (3 ferramentas)

adb_registry_search — Pesquisa o registro de plugins da comunidade, mostra status de instalação e atualizações disponíveis
adb_registry_install — Baixa e instala um plugin do registro pelo nome
adb_registry_installed — Lista plugins instalados localmente com versão e disponibilidade de atualização

Plugins (2 ferramentas)

adb_plugin_list — Lista todos os plugins carregados com caminhos e tempos de carregamento
adb_plugin_info — Documentação do sistema de plugins e formato de exemplo de plugin

Build (2 ferramentas)

adb_gradle — Executa qualquer tarefa Gradle em um diretório de projeto
adb_build_and_install — Compila APK de depuração e instala via direcionamento ANDROID_SERIAL

Comandos AT (6 ferramentas)

adb_shannon_session — Verifica detecção de chipset Shannon/Exynos, root, portas de modem de dispositivo de caractere e um handshake benigno AT/OK juntos; suporta /dev/umts_router do Google Tensor, rearma leituras CPIF limitadas até um resultado terminal, opcionalmente envia ATI somente leitura e nunca envia um comando de configuração de modem
adb_at_detect — Detecta automaticamente o nó do dispositivo de comando AT do modem pela família de chipset (Shannon, Qualcomm, MediaTek, Unisoc, genérico). Testa caminhos conhecidos e retorna o primeiro nó que responde
adb_at_send — Envia um único comando AT ao modem com captura de resposta. Detecta automaticamente a porta ou aceita substituição manual. Lista de bloqueio de comandos perigosos com substituição forçada
adb_at_batch — Envia vários comandos AT sequencialmente com resultados por comando. Atraso configurável entre comandos
adb_at_probe — Executa uma sonda de diagnóstico padrão: ID do modem, qualidade do sinal, registro de rede, status do SIM, operadora, modo de funcionalidade
adb_at_cross_validate — Valida cruzadamente o firmware da banda base comparando respostas de comandos AT (ATI, AT+CGMR, AT+CGMM) com propriedades do sistema. Sinaliza discrepâncias como possível adulteração de firmware, OTA incompleto ou falsificação de propriedades. Suporte específico para AT+DEVCONINFO da Shannon. Requer root

Comparação de Capturas de Tela (3 ferramentas)

adb_screenshot_baseline — Captura e salva uma captura de tela nomeada como linha de base com metadados (dimensões, SHA-256, timestamp)
adb_screenshot_diff — Compara a tela atual com uma linha de base salva usando decodificação PNG em nível de pixel. Relata contagem/percentual de pixels alterados, caixa delimitadora da região alterada e suporta um limite de tolerância para absorver elementos dinâmicos como relógios
adb_screenshot_history — Lista todas as capturas de tela de linha de base salvas com metadados

Orquestração de Fluxos de Trabalho (3 ferramentas)

adb_workflow_run — Executa um fluxo de trabalho definido em JSON: operações sequenciais de dispositivo com substituição de variáveis, etapas condicionais, loops e captura de resultados. Ações: shell, root_shell, install, screenshot, logcat, getprop, sleep
adb_workflow_validate — Valida a estrutura do fluxo de trabalho sem executar. Mostra o plano de execução
adb_workflow_list — Lista arquivos de fluxo de trabalho salvos no diretório de fluxos de trabalho

Gerenciamento de APK Dividido (4 ferramentas)

adb_install_bundle — Instala APKs divididos (app bundles) via install-multiple com opções de substituição e downgrade
adb_list_splits — Mostra todos os caminhos de divisão de APK para um pacote com classificação (base, config.density, config.language, etc.) e tamanho total
adb_extract_apks — Puxa todas as divisões de um pacote para um diretório local para análise ou backup
adb_apex_list — Lista módulos APEX instalados com informações de versão

Espelhamento de Dispositivo (3 ferramentas)

adb_mirror_start — Inicia espelhamento de tela ao vivo via scrcpy. Suporta modos com janela e headless, gravação, controle de bitrate/FPS/resolução, manter ativo e desligar tela
adb_mirror_stop — Para o espelhamento de um dispositivo ou de todos os dispositivos
adb_mirror_status — Verifica disponibilidade do scrcpy e lista sessões de espelhamento ativas

Geração Automatizada de Testes (3 ferramentas)

adb_test_gen_from_ui — Analisa os elementos interativos da tela atual e gera um fluxo de trabalho que toca em cada um, captura telas e verifica falhas
adb_test_gen_from_intents — Analisa as atividades registradas de um pacote e gera um fluxo de trabalho que inicia cada atividade exportada com detecção de falhas
adb_test_gen_save — Salva um fluxo de trabalho gerado em JSON no diretório de fluxos de trabalho para execução posterior

Monitoramento de Atualizações OTA (3 ferramentas)

adb_ota_fingerprint — Captura a impressão digital do sistema: ID de build, versão Android, patch de segurança, bootloader, firmware de banda base, kernel, slot A/B
adb_ota_check — Compara o estado atual do sistema com uma impressão digital salva para detectar atualizações OTA. Identifica campos alterados e recomenda re-baseline
adb_ota_history — Lista todas as impressões digitais salvas para um dispositivo com progressão de versão ao longo do tempo

Interceptação de Mensagens RIL (3 ferramentas)

adb_ril_start — Inicia a captura de mensagens RIL do buffer logcat de rádio. Categoriza eventos de registro, informações de célula, sinal, rede, segurança, handover e NAS
adb_ril_poll — Recupera mensagens RIL capturadas com filtro opcional por categoria. Mostra distribuição de categorias
adb_ril_stop — Para uma sessão de captura RIL com resumo de categorias

Perfis de Dispositivo (3 ferramentas)

adb_profile_detect — Detecta e constrói automaticamente um perfil de dispositivo: ID de hardware, família de chipset, nós de modem, status de root, suporte 5G, configuração dual SIM. Compara com biblioteca integrada para peculiaridades conhecidas
adb_profile_save — Salva um perfil de dispositivo na biblioteca de perfis
adb_profile_list — Lista perfis de dispositivo integrados e salvos pelo usuário

Análise de Firmware do Modem (3 ferramentas)

adb_firmware_probe — Identificação abrangente de firmware: analisa banda base (Shannon/Qualcomm/MediaTek/Unisoc/HiSilicon/Intel), bootloader e implementação RIL em componentes estruturados. Relata kernel, patch de segurança, slot A/B, estado de boot verificado, VBMeta, hipervisor e inventário de partições OTA
adb_firmware_diff — Compara todos os componentes de firmware (banda base, bootloader, kernel, patch de segurança, ID de build, versão Android, RIL) entre impressões digitais salvas ou dispositivo ao vivo. Diffs profundos analisados para banda base e bootloader quando alterações são detectadas
adb_firmware_history — Rastreia a progressão de firmware em todas as impressões digitais OTA salvas com detecção de alterações em múltiplos componentes (banda base, bootloader, kernel, patch de segurança, ID de build, versão Android) e diffs analisados de banda base

Firmware Sem Fio (4 ferramentas)

adb_wifi_firmware — Identificação de chipset e firmware WiFi: versão do driver, versão do firmware, bandas suportadas (2.4/5/6 GHz), detecção de padrão WiFi (5/6/6E/7), informações de conexão atual. Endereço MAC apenas com consentimento
adb_bluetooth_firmware — Identificação de firmware e chipset Bluetooth: versão do firmware, versão BT (4.0–5.4 do LMP), estado do adaptador, capacidades LE (2M PHY, Coded PHY, extended advertising), perfis ativos (A2DP/HFP/HID/LE Audio), contagem de dispositivos pareados. MAC/nome apenas com consentimento
adb_nfc_firmware — Firmware do controlador NFC: tipo de controlador (NXP/Broadcom/Samsung/ST), versão do firmware, tecnologias suportadas (NFC-A/B/F/V, MIFARE), elemento seguro (eSE/UICC), suporte HCE
adb_gps_firmware — Identificação de chipset e firmware GNSS/GPS: modelo de hardware (fabricante, chip, firmware), constelações suportadas (GPS/GLONASS/Galileo/BeiDou/QZSS/NavIC/SBAS), tipos de sinal com frequências, detecção de dupla frequência (L1+L5), capacidades de medição GNSS bruta, modos A-GPS (MSB/MSA), configuração do servidor SUPL, medições de fase de portadora

Mercado de Fluxos de Trabalho (3 ferramentas)

adb_market_search — Pesquisa o mercado de fluxos de trabalho por definições compartilhadas pela comunidade com filtro por palavra-chave e tag. Mostra status de instalação
adb_market_install — Baixa, valida (estrutura JSON + integridade SHA-256) e instala um fluxo de trabalho do mercado para uso imediato com adb_workflow_run
adb_market_export — Empacota um fluxo de trabalho local com metadados de mercado (autor, versão, tags, SHA-256) e gera uma entrada de manifesto de registro para compartilhamento

Auditoria SELinux e Permissões (3 ferramentas)

adb_selinux_status — Modo de aplicação SELinux, versão da política, contexto do shell, contagem recente de negações AVC. Root fornece estatísticas de negação do dmesg do kernel
adb_selinux_denials — Lista mensagens recentes de negação AVC com contextos de origem/destino analisados, classes de permissão e operações negadas. Suporta filtro por processo
adb_permission_audit — Audita concessões de permissão em tempo de execução para um pacote agrupadas por categoria de permissão perigosa (Câmera, Localização, Telefone, SMS, etc.). Sinaliza concessões de alta sensibilidade

Perfil Térmico e de Energia (3 ferramentas)

adb_thermal_snapshot — Captura todas as temperaturas de zonas térmicas, frequências/governors por CPU, estados de dispositivos de resfriamento, temperatura/corrente/tensão/consumo de energia da bateria. Salva opcionalmente como linha de base JSON
adb_thermal_compare — Compara o estado térmico atual com uma linha de base salva com deltas de temperatura por zona e alterações de corrente da bateria
adb_battery_drain — Mede a taxa de descarga da bateria em uma duração configurável (3-60s). Relata mA médio, mW, %/hora estimado. Batterystats opcional específico de pacote

Descoberta de Rede (3 ferramentas)

adb_network_scan — Escaneia a rede local por dispositivos habilitados para ADB via tabela ARP e varredura opcional de faixa de IP. Testa portas 5555-5558 com sondas TCP paralelas em lote
adb_network_device_ip — Obtém o IP WiFi de um dispositivo conectado por múltiplos métodos. Mostra status TCP do ADB e instruções de conexão sem fio
adb_network_auto_connect — Descoberta + conexão em uma etapa: escaneia dispositivos ADB e executa automaticamente adb connect em cada listener encontrado

Acesso a Sensores de Hardware (2 ferramentas)

adb_sensor_read — Lê valores atuais de sensores de hardware via dumpsys sensorservice. Enumera todos os sensores com fornecedor, tipo, modo, faixa de taxa e capacidade de wake. Retorna últimas leituras conhecidas com timestamps e formatação rotulada por eixo. Filtro por categoria (13 categorias) e modo de descoberta listOnly. Não requer root
adb_iio_read — Lê dados brutos de hardware do subsistema Linux IIO. Descobre automaticamente dispositivos IIO, classifica por driver do kernel. Em Tensor/Exynos: expõe monitores de energia ODPM por trilho mostrando consumo de energia em tempo real por subsistema SoC. Caminho IIO genérico lida com canais brutos com escala+offset calibrados. Requer root

Handles de Resultado (3 ferramentas)

adb_result_list — Lista handles de resultado ativos no cache baseado em tempdir. Mostra ferramenta, nome, tamanho, idade e TTL restante para cada handle
adb_result_get — Recupera o conteúdo de um handle armazenado por ferramenta + nome. Retorna os blocos de conteúdo originais como a ferramenta de origem os produziu; atualiza o tempo de último acesso. Para recuperação baseada em URI, use o Recurso MCP result://{tool}/{name}
adb_result_drop — Exclui um handle de resultado armazenado, ou limpa todos os handles no namespace atual. Passe ambos tool e name para remover um handle específico, ou all: true para remover tudo. Útil antes de alterar DA_AUTH_TOKEN (que deixaria órfãos no diretório antigo de hash de token)

Recursos MCP (5)

Superfícies de estado de dispositivo somente leitura acessíveis por clientes MCP:

device://list — Lista de todos os dispositivos conectados com estado e informações de modelo
device://info/{serial} — Propriedades do dispositivo (modelo, SO, build, ABI)
device://battery/{serial} — Status da bateria analisado (nível, carregamento, temperatura, tensão)
device://telephony/{serial} — Estado do registro de telefonia para análise celular
result://{tool}/{name} — Handle de resultado de ferramenta armazenado. Resolva por URI; criado por ferramentas que optam pelo armazenamento de handles de resultado via parâmetro result_handle. Listado por adb_result_list

Prompts MCP (4)

Modelos de fluxo de trabalho pré-construídos para tarefas comuns de depuração em múltiplas etapas:

debug-crash — Limpar logcat → reiniciar o app → aguardar a reprodução → capturar o buffer de crash → analisar
deploy-and-test — Compilar → instalar → limpar logcat → iniciar o monitor → abrir → capturar tela → relatar
telephony-snapshot — Capturar estado de telefonia, SIM/operadora de rede, tipo de rede → resumir anomalias
airplane-cycle-test — Iniciar o monitor → telefonia de linha de base → alternar modo avião → comparar estado antes/depois

Principais Recursos

Cache de Dispositivos

Os resultados da descoberta de dispositivos são armazenados em cache com um TTL configurável (padrão 5s), eliminando chamadas redundantes de subprocesso adb devices durante sequências rápidas de ferramentas. O cache é invalidado automaticamente em erros de conexão e após operações de conexão/desconexão/pareamento sem fio.

Repetição de Falhas Transitórias

A ponte ADB tenta automaticamente novamente em falhas transitórias (dispositivo offline, redefinição de conexão, falha de protocolo) com contagem de tentativas configurável e backoff exponencial. Comandos de diagnóstico ignoram tentativas para revelar problemas reais imediatamente.

Proteção de Saída

Toda a saída do ADB passa pelo OutputProcessor, que normaliza finais de linha, aplica limites de caracteres configuráveis e fornece truncamento contextual em limites lógicos (quebras de linha, separadores de seção) em vez de cortar no meio da linha. Inclui analisadores estruturados para saída de bateria, meminfo e getprop.

Streaming Persistente de Logcat

Monitores de logcat em segundo plano são executados como processos gerados com acumulação de buffer circular. Cada consulta retorna apenas novas linhas desde a última leitura. Suporta múltiplas sessões concorrentes (até 10) com filtros independentes. Manipuladores de limpeza de processos evitam processos adb logcat órfãos na saída do servidor.

Análise de Hierarquia de UI

Captura completa da árvore de visualizações via uiautomator dump com extração de XML analisado. Retorna dados estruturados de elementos, incluindo texto, resource-id, content-description, nomes de classes, coordenadas de limites com pontos centrais prontos para toque e sinalizadores de interação. Extração de atributos por regex pré-compilada para análise eficiente.

Middleware de Segurança

Segurança em múltiplas camadas ativada via DA_SECURITY=true. Fornece filtragem de lista de bloqueio/permitidos de comandos, limitação de taxa (comandos por minuto) e registro de auditoria com redação automática de credenciais. As verificações de segurança são integradas em adb_shell, adb_root_shell, adb_multi_shell, adb_multi_compare, adb_input, adb_batch_actions e adb_start_activity. Configurável via variáveis de ambiente para diferentes cenários de implantação.

Saneamento de Entrada

Todas as ferramentas que interpolam parâmetros fornecidos pelo usuário em strings de comando de shell validam entradas contra metacaracteres de shell antes da execução. Nomes de pacotes, chaves de propriedades, nomes de serviços, chaves de configurações, identificadores de teste, nomes de interfaces de rede e filtros tcpdump são todos validados por meio de uma função centralizada validateShellArg() que rejeita ;, |, &, $, crases, parênteses e outros vetores de injeção. Caminhos de arquivo usam escape de shell com aspas simples para evitar substituição de comando $(). A ferramenta adb_input aplica validação específica por tipo: tap/swipe aceitam apenas coordenadas numéricas, keyevent aceita apenas keycodes alfanuméricos e text é escapado por shell para entrega literal. A ferramenta adb_batch_actions aplica a mesma validação por tipo de ação (apenas dígitos para coordenadas, alfanuméricos para keycodes, escape de shell para texto) e roteia cada comando montado pelo middleware de segurança. JSON desserializado de arquivos de snapshot é validado antes da interpolação no shell. Cada parâmetro z.number() em todas as 209 ferramentas tem limites explícitos de .min()/.max() Zod para evitar esgotamento de recursos com valores extremos. O LocalBridge tem manipuladores explícitos para cada subcomando ADB usado pelos módulos de ferramentas, evitando fallthrough sem aspas para o manipulador de shell padrão. No modo no-dispositivo, a elevação de privilégios usa uma lista de permissões congelada de 16 comandos e regex de caminho restrito — o conjunto de elevação é ReadonlySet + Object.freeze, não configurável em tempo de execução. O transporte HTTP/SSE nega solicitações de origem cruzada por padrão (configurável via DA_HTTP_CORS_ORIGIN), o registro de plugins verifica hashes de integridade SHA-256 e previne path traversal por meio de verificações de contenção de diretório, e o mecanismo de fluxo de trabalho aplica limites de contagem de etapas (200), duração de suspensão (5 min) e repetição (100). Helpers de busca aplicam um limite de 5 MB no corpo da resposta. A análise de saída do getprop lida com finais de linha \r\n do Windows via .trim() antes da correspondência regex, e as contagens de slots de SIM duplo são limitadas a 4 para evitar esgotamento de recursos com propriedades de dispositivo corrompidas.

Orquestração Multi-Dispositivo

Execute comandos, instale APKs e compare saídas em vários dispositivos conectados em paralelo. Essencial para testes comparativos entre versões do Android e modelos de dispositivos.

Snapshot/Restauração

Capture snapshots abrangentes do estado do dispositivo (pacotes, configurações em todos os namespaces, propriedades do sistema) em arquivos JSON. Compare o estado atual com snapshots salvos para detectar desvios. Restaure configurações de snapshots para ambientes de teste reproduzíveis.

Captura de Tráfego de Rede

Captura de pacotes no dispositivo via tcpdump com extração de arquivo pcap para análise no Wireshark. Inclui listagem de conexões ativas via ss/netstat com fallback para /proc/net em dispositivos sem essas ferramentas.

Integração CI/CD

Ferramentas específicas para pipelines automatizados: aguardar inicialização do dispositivo com polling, verificações de prontidão estruturadas e execução de testes instrumentados com resultados analisados de aprovação/reprovação.

Arquitetura de Plugins

Carregamento dinâmico de módulos de ferramentas a partir de um diretório de plugins configurável. Os plugins são módulos JavaScript ESM padrão que exportam uma função register(ctx) que recebe o ToolContext completo. Carregados na inicialização do servidor, permitindo contribuições da comunidade sem modificar o código principal.

Registro de Plugins da Comunidade

Pesquise, instale e gerencie plugins a partir de uma URL de registro configurável. Mostra status de instalação, comparação de versões e atualizações disponíveis. Baixa arquivos de plugin com metadados complementares no diretório de plugins para carregamento no próximo reinício. Recursos de segurança incluem verificação de integridade SHA-256 (quando fornecida pelo manifesto do registro), proteção contra path traversal e verificação de sanidade de exportação register().

Integração Baseband/Modem

Ferramentas de inspeção profunda de rádio celular para desenvolvimento e pesquisa avançados no Android. Extrai identificação de firmware do modem, parâmetros de identidade celular (CID, TAC, EARFCN, PCI), medições de sinal bruto (RSRP, RSRQ, SINR), pesquisas de células vizinhas, configuração de operadora e logs de modem de múltiplas fontes (buffer de rádio RIL, framework de telefonia, kernel dmesg). Suporta famílias de chipsets Shannon/Exynos, Qualcomm, MediaTek e Unisoc via APIs padrão de telefonia do Android. Inclui detecção de SoC Google Tensor (gs101/gs201/zuma/zumapro) para roteamento automático do caminho do modem Shannon em dispositivos Pixel 6–9. A detecção de SIM duplo relata estado do SIM por slot, operadora, tipo de rede e país para configurações DSDS, DSDA e TSTS.

Auditoria de Acessibilidade

Verificações automatizadas de acessibilidade WCAG na hierarquia de UI ao vivo. Detecta rótulos ausentes em elementos interativos, alvos de toque menores que a diretriz de 48dp (ciente da densidade), imagens sem content-descriptions, elementos clicáveis sem foco e content-descriptions duplicados. Gera relatórios estruturados com níveis de gravidade. Inclui uma visualização dedicada da árvore de acessibilidade para depuração de leitores de tela.

Detecção de Regressão

Capture linhas de base de desempenho (memória, CPU, estatísticas de frames, bateria, estado de rede) e compare execuções subsequentes com elas. Limiares de regressão configuráveis para memória (+20%), CPU (+50%) e taxa de jank (+25%). Mantém um histórico de linhas de base para análise de tendências entre versões.

Integração com Device Farm

Execução de testes baseada em nuvem via Firebase Test Lab usando a CLI gcloud. Execute testes instrumentados em vários modelos de dispositivos e níveis de API, recupere resultados estruturados e liste configurações de matriz de teste disponíveis. Fallback gracioso com instruções de configuração se o gcloud não estiver disponível.

Transporte HTTP/SSE

Alternativa ao stdio para clientes MCP baseados em navegador. Defina DA_HTTP_PORT para iniciar um servidor HTTP com streaming SSE. Fornece endpoints /sse (assinatura de cliente), /message (JSON-RPC) e /health. Solicitações de origem cruzada são negadas por padrão — defina DA_HTTP_CORS_ORIGIN para permitir explicitamente uma origem específica.

Gerenciamento de Sessões de Teste

Fluxos de trabalho de teste estruturados com etapas numeradas. Cada etapa captura uma captura de tela e um snapshot de logcat em um diretório organizado com um manifesto Markdown. Projetado para documentação de teste reproduzível.

Interface de Comandos AT

Passagem direta de comandos AT para o modem via acesso root, permitindo interrogatório bruto além do framework de telefonia do Android. Suporte multi-chipset detecta automaticamente nós de dispositivo para Samsung Shannon/Exynos, Qualcomm Snapdragon, MediaTek, Unisoc/Spreadtrum e modems USB genéricos. A validação de entrada rejeita metacaracteres de shell tanto de strings de comando AT quanto de caminhos de nós de dispositivo antes da interpolação no shell root. Uma lista de bloqueio de segurança impede a execução acidental de comandos perigosos (AT+CFUN=0, AT+EGMR, etc.) com uma substituição forçada explícita.

Diff de Capturas de Tela

Detecção de regressão visual verdadeira em nível de pixel. Captura linhas de base nomeadas de capturas de tela e compara o estado atual da tela decodificando dados de pixel PNG (análise IHDR, descompressão IDAT, todos os 5 tipos de filtro PNG) e comparando valores RGB reais. Relata contagem e porcentagem de pixels alterados, caixa delimitadora da região alterada com posição vertical da tela e deltas de dimensão/tamanho. Suporta um parâmetro tolerancePercent (0–100) que absorve mudanças dinâmicas menores, como exibições de relógio ou notificações — uma tolerância de 1% absorve de forma confiável mudanças do relógio da barra de navegação (~0,5% dos pixels) enquanto captura qualquer regressão real de UI. Caminho rápido SHA-256 para correspondências exatas. Zero dependências externas.

Orquestração de Fluxos de Trabalho

Mecanismo de fluxo de trabalho JSON declarativo para operações repetíveis de múltiplas etapas em dispositivos. Suporta substituição de variáveis ({{pkg}}), etapas condicionais (expressões if com ==, !=, contains), loops (repeat, limitados a 100 iterações) e captura de resultados em variáveis para etapas posteriores. As ações mapeiam diretamente para operações da ponte ADB com aplicação completa do middleware de segurança. A validação de fluxo de trabalho aplica um máximo de 200 etapas e limite de suspensão de 5 minutos por etapa para evitar esgotamento de recursos com definições de fluxo de trabalho maliciosas ou malformadas.

Gerenciamento de APK Divididos

Suporte para formatos modernos de entrega do Android. Instale app bundles via install-multiple, inspecione a estrutura de APK dividido (base + divisões de configuração para idioma, densidade, ABI), extraia todas as divisões localmente para análise e liste módulos APEX.

Espelhamento de Dispositivos

Espelhamento de tela ao vivo via integração scrcpy. Suporta modo janela para feedback visual e modo headless para fluxos de trabalho apenas de gravação. O rastreamento de sessão por dispositivo permite espelhamento simultâneo de vários dispositivos conectados. Manipuladores de limpeza de processos evitam processos scrcpy órfãos.

Geração Automatizada de Testes

Analisa a hierarquia de UI ao vivo e registros de intenção de pacotes para gerar automaticamente JSON de fluxo de trabalho de teste compatível com o mecanismo de orquestração de fluxo de trabalho. A geração baseada em UI toca cada elemento interativo, captura telas e verifica crashes. A geração baseada em intenção inicia cada atividade exportada com detecção de crash.

Monitoramento de Atualizações OTA

Rastreia impressão digital abrangente do sistema (ID de compilação, versão do Android, patch de segurança, bootloader, firmware baseband, versão do kernel, slot de partição A/B) entre sessões. Compara o estado atual com impressões digitais salvas para detectar atualizações OTA. Identifica exatamente quais campos mudaram e recomenda re-baselinar métricas de desempenho e capturas de tela após atualizações.

Interceptação de Mensagens RIL

Captura persistente de mensagens da Interface de Rádio (RIL) a partir do buffer logcat de rádio do Android. Inicia um processo em segundo plano que acumula e categoriza mensagens RIL em: registro, cell_info, sinal, rede, segurança, handover, dados, radio_state, SMS e eventos NAS. Recuperação baseada em polling com filtragem por categoria. Útil para monitoramento passivo da comunicação baseband-framework para diagnósticos de rádio e pesquisa de redes celulares. Limite de sessão (5) e manipuladores de limpeza de processo previnem esgotamento de recursos.

Biblioteca de Perfis de Dispositivo

Base de conhecimento específica de dispositivo contendo identificação de hardware, família de chipset, nós de modem conhecidos, compatibilidade com comandos AT, requisitos de root, contagem de slots dual SIM e peculiaridades. Detecta automaticamente perfis de dispositivos conectados e os compara com uma biblioteca integrada de dispositivos conhecidos. Perfis salvos persistem entre sessões e melhoram a precisão da auto-detecção para ferramentas como adb_at_detect. Extensível pela comunidade através de arquivos de perfil salvos.

Transporte WebSocket

Alternativa a stdio e HTTP/SSE para clientes MCP que se beneficiam de streaming bidirecional verdadeiro. Menor latência que polling SSE com melhor compatibilidade com frameworks web. Requer o pacote npm ws como dependência opcional. Defina DA_WS_PORT para habilitar.

Análise de Firmware de Modem

Identificação abrangente de firmware multi-componente, diffing e rastreamento de histórico. Analisa strings de versão baseband para 6 famílias de chipset: Shannon/Exynos (incluindo formato Google Pixel/Tensor g5123b-* e formato clássico Samsung S5123AP_CL*), branch/versão/build Qualcomm MPSS, branch/release/milestone MediaTek MOLY, modelo/versão SoC Unisoc/Spreadtrum, modelo/código de operadora HiSilicon/Kirin e modelo/branch Intel XMM. Também analisa versões de bootloader (codinome/versão/build Pixel, modelo/operadora/revisão Samsung) e strings de implementação RIL (fornecedor/id/API/data de build Samsung S.LSI, Qualcomm, MediaTek). A sonda de firmware relata 8 seções: baseband, bootloader, RIL, kernel, segurança/build, partição/boot (slot A/B, boot seguro, boot verificado, bloqueio de flash), integridade VBMeta e inventário de partição OTA. A ferramenta de diff compara todos os componentes de firmware entre impressões digitais salvas ou estado de dispositivo ao vivo, com sub-diffs profundos analisados para baseband e bootloader. A ferramenta de histórico rastreia a progressão de firmware multi-componente através de impressões digitais OTA.

Marketplace de Workflows

Camada de compartilhamento comunitário para o motor de orquestração de workflows. Pesquise um registro de workflows de teste, sequências de diagnóstico e procedimentos de auditoria contribuídos pela comunidade. Baixe e instale workflows diretamente para execução imediata com adb_workflow_run. Exporte workflows locais com metadados de marketplace e entradas de manifesto de registro geradas automaticamente para submissão. Verificação de integridade SHA-256 no download.

API GraphQL

Endpoint HTTP opcional servindo uma API GraphQL para consultas compostas de dispositivo. Permite que clientes busquem informações de dispositivo, bateria, rede e propriedades arbitrárias em uma única solicitação em vez de múltiplas chamadas de ferramenta MCP. Tamanho do corpo POST limitado a 1 MB. Propriedades de dispositivo são pré-buscadas uma vez por resolução para minimizar chamadas de subprocesso. Requer o pacote npm graphql como dependência opcional. Defina DA_GRAPHQL_PORT para habilitar.

Auditoria SELinux e Permissões

Inspeciona o modo de enforcement SELinux, consulta negações AVC de logcat e logs de auditoria do kernel, e audita concessões de permissão em tempo de execução por pacote. Agrupa permissões concedidas por categoria perigosa (Câmera, Localização, Telefone, SMS, etc.) e sinaliza concessões de alta sensibilidade como localização em segundo plano e gerenciar-armazenamento-externo. Estende a superfície de auditoria de segurança para a camada de permissões do SO.

Perfil Térmico e de Energia

Captura temperaturas de zonas térmicas de sysfs, estados de escalonamento de frequência por CPU e governadores, atividade de dispositivos de resfriamento e taxas de dreno de bateria. Complementa a detecção de regressão com linhas de base térmicas/de energia para problemas que se manifestam como calor ou dreno de bateria em vez de quedas de quadros. Inclui medição de dreno cronometrada com cálculos de mA/mW/%-por-hora estimado.

Descoberta de Dispositivos de Rede

Escaneia a rede local para dispositivos habilitados para ADB via consultas de tabela ARP e varreduras opcionais de faixa IP. Testa portas ADB comuns (5555-5558) com tentativas de conexão TCP paralelas em lote. Extrai IPs WiFi de dispositivos via múltiplos métodos. Modo de conexão automática descobre e conecta a dispositivos em uma única etapa. Otimiza fluxos de trabalho de depuração sem fio.

Virtualização QEMU/KVM

Gerenciamento de máquinas virtuais no dispositivo usando QEMU com aceleração de hardware KVM. Permite executar VMs Android convidadas diretamente no dispositivo físico — uma capacidade única do DeepADB. Alocação dinâmica de recursos auto-detecta núcleos de CPU do host e RAM física, reservando 1 núcleo e 35% da memória para o SO host para prevenir inanição. Suporte a múltiplas VMs rastreia consumo de recursos entre VMs concorrentes, recusando novas VMs quando o pool está esgotado em vez de degradar o desempenho do host. Gerenciamento de imagens de disco com formatos qcow2 (esparso, com capacidade de snapshot) e raw. Encaminhamento de porta ADB para VMs convidadas permite que o conjunto completo de ferramentas do DeepADB atinja dispositivos host e convidados simultaneamente. Ciclo de vida de processo rastreado via registro centralizado de limpeza com desligamento SIGTERM/SIGKILL. Verificação de contenção de caminho em todas as operações de imagem previne travessia de diretório.

Arquitetura ToolContext

Todos os 49 módulos de ferramenta recebem um pacote de dependências unificado ToolContext contendo servidor, ponte, gerenciador de dispositivos, logger, segurança e configuração. Adicionar novas dependências transversais não requer mudanças de assinatura de módulo.

Variáveis de Ambiente

Variável	Padrão	Descrição
`DA_LOCAL`	Auto-detect	Força modo no-dispositivo (`true`/`false`). Auto-detecta via `/system/build.prop`
`ADB_PATH`	Auto-detect	Caminho para o binário ADB (ignorado no modo no-dispositivo)
`DA_TIMEOUT`	`30000`	Timeout padrão de comando em milissegundos
`DA_MAX_OUTPUT`	`50000`	Máximo de caracteres de saída antes da truncagem
`DA_MAX_LOGCAT`	`500`	Máximo de linhas logcat por snapshot
`DA_DEVICE`	(auto)	Serial padrão do dispositivo (auto-seleciona se dispositivo único)
`DA_TEMP_DIR`	Temp do SO	Diretório temporário para screenshots, arquivos puxados, relatórios de bug, sessões de teste, snapshots
`DA_CACHE_TTL`	`5000`	TTL do cache da lista de dispositivos em milissegundos (0 = desabilitado)
`DA_RETRY_COUNT`	`1`	Número de tentativas para falhas transitórias de ADB
`DA_RETRY_DELAY`	`500`	Atraso base de tentativa em ms (dobra a cada tentativa)
`DA_LOG_LEVEL`	`info`	Nível de log: debug, info, warn, error
`DA_ASCII_ONLY`	(auto-detect)	Defina para `1` para forçar saída somente ASCII no banner de aviso de inicialização. Padrão auto-detecta via `WT_SESSION`/`TERM_PROGRAM`/`TERM` para terminais com suporte a Unicode; cai para ASCII em `cmd.exe` legado.
`DA_RESOURCE_CACHE_TTL_MS`	`0` (desabilitado)	TTL do cache de recursos MCP em ms. Defina para um valor positivo para armazenar em cache leituras de recursos (device://info, device://battery, etc.) por essa duração.
`DA_RESULT_HANDLE_DIR`	`{tempDir}/result-handles`	Raiz de armazenamento para manipuladores de resultado de ferramenta com backup em tempdir. Substitua para realocar o armazenamento fora do diretório temporário padrão.
`DA_RESULT_HANDLE_TTL`	`43200` (12h)	TTL por manipulador em segundos. Manipuladores mais antigos que isso são removidos na varredura de inicialização e durante remoção periódica. Limitado a [60, 7 dias].
`DA_RESULT_HANDLE_MAX_BYTES`	`5242880` (5 MB)	Limite de tamanho por manipulador. Ferramentas que tentam armazenar um bloco de conteúdo maior que isso falham com erro.
`DA_RESULT_HANDLE_TOTAL_BYTES`	`104857600` (100 MB)	Limite total de tamanho do armazenamento de manipuladores de resultado em todos os manipuladores. Aciona remoção LRU quando excedido.
`DA_RESULT_HANDLE_MAX_COUNT`	`100`	Número máximo de manipuladores ativos. Aciona remoção LRU quando excedido.
`DA_SECURITY`	`false`	Habilita middleware de segurança (filtragem de comandos, limitação de taxa)
`DA_BLOCKED_COMMANDS`	(nenhum)	Lista separada por vírgulas de substrings de comandos shell bloqueados
`DA_ALLOWED_COMMANDS`	(nenhum)	Lista de permissões separada por vírgulas (se definida, apenas comandos correspondentes são executados)
`DA_RATE_LIMIT`	`0`	Máximo de comandos por minuto (0 = ilimitado)
`DA_CI_PING_TARGET`	`1.1.1.1`	Alvo de alcance de rede usado por `adb_ci_device_ready` (alcance de rede é uma das verificações de prontidão junto com conclusão de boot, autorização ADB e disponibilidade do gerenciador de pacotes). Substitua para apontar para um alvo interno se `1.1.1.1` estiver atrás de firewall.
`DA_AUDIT_LOG`	`true`	Registra todos os comandos executados para trilha de auditoria (defina para `false` para desabilitar)
`DA_PLUGIN_DIR`	`{tempDir}/plugins`	Diretório para escanear módulos .js de plugin na inicialização
`DA_REGISTRY_URL`	Padrão GitHub	URL do manifesto JSON do registro de plugins da comunidade
`DA_HTTP_PORT`	(desabilitado)	Defina para um número de porta para habilitar modo de transporte HTTP/SSE
`DA_HTTP_HOST`	`127.0.0.1`	Endereço de bind para servidores HTTP/SSE, WebSocket e GraphQL
`DA_AUTH_TOKEN`	(nenhum — aberto)	Token Bearer para transportes de rede. Quando definido, todas as solicitações HTTP/SSE/WS/GraphQL exigem cabeçalho `Authorization: Bearer <token>`. Endpoints de saúde isentos.
`DA_HTTP_CORS_ORIGIN`	(nenhum — negar)	Origem CORS permitida para HTTP/SSE
`DA_WS_PORT`	(desabilitado)	Defina para um número de porta para habilitar modo de transporte WebSocket (requer `npm install ws`)
`DA_WS_CORS_ORIGIN`	(nenhum — negar)	Origem CORS permitida para endpoint de saúde WebSocket
`DA_GRAPHQL_PORT`	(desabilitado)	Defina para um número de porta para habilitar o endpoint da API GraphQL (requer `npm install graphql`)
`DA_GRAPHQL_CORS_ORIGIN`	(nenhum — negar)	Origem CORS permitida para API GraphQL
`DA_WORKFLOW_REGISTRY_URL`	(derivado de DA_REGISTRY_URL)	URL do manifesto JSON do marketplace de workflows
`DA_TEST_PIN`	(nenhum)	PIN numérico usado por `tests/test-ui-control.mjs` para exercitar testes de bloqueio/desbloqueio de tela. Sem ele, os 4 testes de estado de bloqueio são pulados. Formato: `DA_TEST_PIN=0000 npm test`.

Estrutura do Projeto

DeepADB/
├── src/
│   ├── index.ts                # Entry point — stdio, HTTP/SSE, WebSocket, or GraphQL transport
│   ├── server.ts               # MCP server wiring, config, module registration (exports CreateServerResult)
│   ├── http-transport.ts       # HTTP/SSE transport server for browser clients
│   ├── ws-transport.ts         # WebSocket transport (optional `ws` peer dependency)
│   ├── graphql-api.ts          # GraphQL API endpoint (optional `graphql` peer dependency)
│   ├── tool-context.ts         # Unified dependency bundle (ToolContext interface)
│   ├── bridge/
│   │   ├── adb-bridge.ts       # Core ADB subprocess wrapper, retry logic, error types
│   │   ├── local-bridge.ts     # On-device direct execution bridge with privilege escalation (Termux/local mode)
│   │   └── device-manager.ts   # Device discovery, TTL cache, serial routing
│   ├── tools/
│   │   ├── health.ts           # Toolchain health check (1 tool)
│   │   ├── runtime-audit.ts    # Unified read-only runtime readiness audit (1 tool)
│   │   ├── device.ts           # Device info and properties (3 tools)
│   │   ├── shell.ts            # Shell and root command execution (2 tools)
│   │   ├── packages.ts         # App lifecycle, install, permissions, intents (12 tools)
│   │   ├── database-inspector.ts # Package-scoped read-only Room/SQLite inspection (1 tool)
│   │   ├── files.ts            # File operations — push, pull, write, find, grep, replace, stat, checksum, chmod, chown, touch, fsinfo (18 tools)
│   │   ├── logs.ts             # Logcat snapshots — filtered (3 tools)
│   │   ├── logcat-watch.ts     # Persistent logcat with ring buffer and poll (4 tools)
│   │   ├── diagnostics.ts      # dumpsys, telephony, battery, network, perf, bugreport, crash logs, heap dump (9 tools)
│   │   ├── ui.ts               # Screenshots, input, activity, UI hierarchy, annotated screencap, screen state (8 tools)
│   │   ├── input-gestures.ts   # Drag, long press, double tap, text, URL, orientation, clipboard, tap-element, wait-element, wait-stable, scroll-until, compressed screenshot, batch actions, fling, pinch, screen size, device state, notifications (18 tools)
│   │   ├── screen-record.ts    # Screen video recording start/stop (2 tools)
│   │   ├── control.ts          # Airplane, WiFi, data, location, screen, settings, reboot (9 tools)
│   │   ├── wireless.ts         # WiFi pairing, connect, disconnect, TCP/IP (4 tools)
│   │   ├── forwarding.ts       # Port forwarding — forward, reverse, list, remove, managed tunnels with auto-port-pick (8 tools)
│   │   ├── emulator.ts         # AVD list, start, stop with on-device KVM/QEMU detection (3 tools)
│   │   ├── qemu.ts             # QEMU/KVM VM management — setup, images, start, stop, status, guest ADB connect/disconnect/shell (8 tools)
│   │   ├── testing.ts          # Structured test sessions with numbered steps (3 tools)
│   │   ├── multi-device.ts     # Multi-device shell, install, compare, comparative testing (4 tools)
│   │   ├── snapshot.ts         # Device state capture, compare, restore (3 tools)
│   │   ├── network-capture.ts  # tcpdump start/stop, network connections (3 tools)
│   │   ├── ci.ts               # CI wait-boot, device-ready, run-tests (3 tools)
│   │   ├── plugins.ts          # Plugin loader, info, and dynamic tool loading (2 tools)
│   │   ├── baseband.ts         # Modem/baseband inspection and radio diagnostics (6 tools)
│   │   ├── accessibility.ts    # Automated WCAG accessibility auditing (3 tools)
│   │   ├── regression.ts       # Performance baseline and regression detection (3 tools)
│   │   ├── device-farm.ts      # Firebase Test Lab integration via gcloud (3 tools)
│   │   ├── registry.ts         # Community plugin registry search/install (3 tools)
│   │   ├── at-commands.ts      # AT command modem interface, Shannon session, cross-validation (6 tools)
│   │   ├── screenshot-diff.ts  # Visual regression — screenshot baseline/diff (3 tools)
│   │   ├── workflow.ts         # Declarative workflow orchestration engine (3 tools)
│   │   ├── split-apk.ts        # App bundles, split APKs, APEX modules (4 tools)
│   │   ├── mirroring.ts        # Live screen mirroring via scrcpy (3 tools)
│   │   ├── test-gen.ts         # Automated test workflow generation (3 tools)
│   │   ├── ota-monitor.ts      # OTA update monitoring and fingerprinting (3 tools)
│   │   ├── ril-intercept.ts    # RIL message interception from radio buffer (3 tools)
│   │   ├── device-profiles.ts  # Device profile library with built-in entries (3 tools)
│   │   ├── firmware-analysis.ts # Modem firmware version parsing and diffing (3 tools)
│   │   ├── workflow-market.ts  # Workflow marketplace — search, install, export (3 tools)
│   │   ├── selinux-audit.ts    # SELinux status, AVC denials, permission auditing (3 tools)
│   │   ├── thermal-power.ts    # Thermal zones, CPU frequency, battery drain (3 tools)
│   │   ├── network-discovery.ts # ADB-over-network scanning and auto-connect (3 tools)
│   │   ├── app-network.ts      # Per-app UID routing and network-policy context (1 tool)
│   │   ├── wear.ts             # Wear OS Data Layer phone/watch preflight (1 tool)
│   │   ├── sensors.ts          # Hardware sensor enumeration, IIO power monitor reading (2 tools)
│   │   ├── result-handles.ts   # Tempdir-backed result handle store — list, drop, drop-all (3 tools) + the result://{tool}/{name} resource
│   │   ├── wireless-firmware.ts # WiFi, Bluetooth, NFC, GPS firmware identification (4 tools)
│   │   ├── build.ts            # Gradle build and install (2 tools)
│   │   ├── resources.ts        # MCP Resources — 4 device-state surfaces: device://info|battery|telephony|list (5th, result://, lives in result-handles.ts)
│   │   └── prompts.ts          # MCP Prompts — workflow templates (4 prompts)
│   ├── middleware/
│   │   ├── auth.ts             # Bearer token authentication for network transports (DA_AUTH_TOKEN)
│   │   ├── output-processor.ts # Contextual truncation, structured parsers, settledValue helper
│   │   ├── security.ts         # Command filtering, rate limiting, audit logging with redaction
│   │   ├── sanitize.ts         # Shell injection prevention — validateShellArg/validateShellArgs/shellEscape
│   │   ├── chipset.ts          # Shared chipset family detection, modem path mapping, SIM config detection
│   │   ├── fetch-utils.ts      # Shared HTTP helpers with 5 MB streaming response size limit
│   │   ├── png-utils.ts        # Zero-dependency PNG decode/encode/draw primitives for screenshot annotation and diffing
│   │   ├── ui-dump.ts          # Shared uiautomator XML capture with concurrent-safe paths, on-device /data/local/tmp routing, and cleanup
│   │   ├── cleanup.ts          # Centralized process cleanup registry for SIGINT/SIGTERM/exit
│   │   ├── logger.ts           # stderr-safe logging (MCP-compliant)
│   │   ├── fs-utils.ts         # Filename sanitization, atomic write, private-dir helpers, within-dir containment check
│   │   ├── parse-utils.ts      # Shared parseIntSafe for env-var numeric parsing (single source of truth)
│   │   └── result-handle.ts    # Tempdir-backed tool result content cache with TTL, LRU, and token-hash isolation
│   └── config/
│       └── config.ts           # Configuration, env vars, startup validation
├── package.json
├── tsconfig.json
├── server.json                  # MCP Registry metadata (io.github.fullread/deepadb)
├── .gitignore
├── README.md
├── SECURITY.md                  # Threat model, security architecture, deployment hardening, vulnerability reporting
├── CHANGELOG.md                 # Version history from v0.1.0 to current
├── LICENSE                      # Apache 2.0 license
└── tests/
    ├── run-all.mjs              # Run all test suites sequentially with summary (tracks skipped counts)
    ├── test-hw.mjs              # Hardware core: health, identity, baseband, thermal, profiles, wireless firmware, crash analysis (34 tests)
    ├── test-shell-files.mjs     # Shell, filesystem, packages, diagnostics (24 tests)
    ├── test-ui-control.mjs      # UI hierarchy, screenshots, settings, input gestures, UI automation, device awareness, accessibility, screen lock/unlock, multi-touch (46 tests)
    ├── test-monitoring.mjs      # Logcat watchers, snapshots, OTA, regression, workflows (43 tests)
    ├── test-security.mjs        # Input sanitization, shell injection, AT command safety, QEMU shell escaping, heap-dump validation (116 on-device, 105 host)
    ├── test-lifecycle.mjs       # App lifecycle, file push/pull, input, port forwarding, screen recording, test sessions (24 tests)
    ├── test-analysis.mjs        # Thermal/snapshot/regression comparison, firmware diff, screenshot diff, test gen, RIL intercept, AT cross-validation, permission management (23 tests)
    ├── test-boundaries.mjs      # Zod bounds enforcement, input injection, error paths, sensitive data protection, wireless ADB coverage, multi-device basics, tunnel automation, device-free coverage boundaries (78 tests)
    ├── test-sensors.mjs         # HAL sensors, IIO power monitors, category filters, formatting, wake-up, rate display (30 tests)
    ├── test-files-extended.mjs  # File tool coverage — write, find, stat, checksum, mkdir, rm, move, copy, chmod, touch, fsinfo, chown, grep, replace; push safety; sed-escape regression (95 tests)
    ├── test-result-handles.mjs # Result handle store — listing, retrieval, drop, isolation, eviction (19 tests)
    ├── test-qemu.mjs            # QEMU/KVM setup, image management, VM status, guest connectivity errors (13 on-device tests)
    ├── test-qemu-boot.mjs       # QEMU Alpine VM boot with auto-fetch of kernel/initrd, KVM acceleration, topology detection, guest ADB connectivity (17 on-device tests)
    ├── test-supply-chain.mjs    # Supply-chain hardening checks for fetch and network paths (24 tests)
    ├── test-sanitize-fuzz.mjs   # Property-based fuzzing of shell sanitizers — shellQuote/shellEscape round-trip, validateShellArg rejection (19 tests)
    ├── test-transports.mjs      # Transport smoke — HTTP/SSE + WebSocket MCP round-trip, GraphQL health query (8 tests)
    └── lib/
        └── harness.mjs          # Shared test harness (stdio JSON-RPC transport, assertion primitives)

Pilha Tecnológica

Runtime: Node.js ≥22 (ES2024, ESM; Node 22.12+ para cobertura)
Linguagem: TypeScript 6.0 (modo estrito, resolução de módulo NodeNext)
SDK MCP: @modelcontextprotocol/sdk ^1.24.0 (atualmente resolve para 1.30.0)
Validação: Zod ^4.4.3
Transporte: stdio (JSON-RPC), HTTP/SSE, WebSocket (opcional ws), API GraphQL (opcional graphql)

Licença

Apache License 2.0 — veja LICENSE e NOTICE. O lançamento v1.1.2 migrou de MIT para Apache 2.0 para a concessão explícita de patente e requisitos de atribuição de contribuidores; forks/instalações existentes permanecem válidos sob os termos MIT anteriores.