SilbercueSwift

SilbercueSwift

O servidor MCP mais rápido e completo para desenvolvimento iOS. Um único binário Swift, 58 ferramentas, zero dependências. SilbercueSwift tem o conjunto de ferramentas mais completo de qualquer alternativa disponível.

Construído para Claude Code, Cursor e qualquer agente de IA compatível com MCP.

Procurando uma alternativa aos servidores MCP iOS existentes? SilbercueSwift cobre todo o conjunto de recursos do XcodeBuildMCP, Appium-MCP e iosef em um único binário — além de análise de xcresult, automação de UI, cobertura de código e capturas de tela até 75x mais rápidas. Veja a comparação abaixo.

Por que SilbercueSwift?

Todo servidor MCP iOS tem o mesmo problema: a saída bruta do xcodebuild é inútil para agentes de IA. 500 linhas de log de build, ruído de stderr confundido com erros, nenhum resultado de teste estruturado. Agentes perdem minutos analisando o que um humano vê em segundos.

SilbercueSwift resolve isso. Ele analisa pacotes .xcresult — os mesmos dados estruturados que o Xcode usa internamente — e retorna exatamente o que o agente precisa: contagens de passou/falhou, mensagens de falha com arquivo:linha, cobertura de código por arquivo e capturas de tela de falhas.

O que você obtém	XcodeBuildMCP	Appium-MCP	iosef	SilbercueSwift
Latência de captura de tela	~1127ms	~77ms	~83ms	~316ms ( ~15ms, 75x)
Hierarquia de visualização	~259ms	~938ms	~44ms	~31ms ( ~5ms)
Encontrar elemento	—	76ms	50ms	31ms ( <1ms + rolagem automática)
Toque (coordenadas)	235ms	470ms	48ms	16ms ( 4ms)
Deslizar	1284ms	2685ms	262ms	~250ms
Build para simulador	Sim	—	—	Sim
Build + Executar em uma chamada	Sim (sequencial)	—	—	Sim (paralelo, ~9s mais rápido)
Resultados de teste estruturados	Parcial	—	—	JSON xcresult completo
Capturas de tela de falha do xcresult	—	—	—	Exportadas automaticamente
Cobertura de código por arquivo	Básico	—	—	Ordenado, filtrável
Diagnóstico de erro de build	Análise de stderr	—	—	JSON xcresult com arquivo:linha
Navegar (encontrar + tocar + verificar)	—	—	—	1 chamada (~380ms)
Toque duplo	—	—	—	~60ms
Arrastar e soltar	—	Somente coordenadas (3 chamadas)	—	Elemento a elemento (1 chamada)
Rolar até elemento	—	Loop manual de deslize	—	SmartScroll (1 chamada)
Tratamento de alertas	—	Alerta único	—	Busca em 3 níveis + aceitar_todos em lote
Diálogo ContactsUI do iOS 18	—	—	—	Suportado
Automação de UI em lote	—	—	—	run_plan: planos de múltiplas etapas com decisões adaptativas
Filtragem de logs	Somente subsistema	—	Parcial	Filtrado por tópico: 90% menos tokens
Log de console por teste falho	—	—	—	Opcional
Aguardar padrão de log	—	—	—	Regex + timeout
Regressão visual	—	—	—	Baseline + diff de pixels
Verificação multi-dispositivo	—	—	—	Modo Escuro, Paisagem, iPad
Multi-plataforma (Android)	—	Sim	—	—
Ferramentas	77 (Rust)	61 (Node.js + Appium)	15 (Swift)	58 (Swift nativo, 8,5MB)
Inicialização a frio	~400ms	~1000ms	~100ms	~50ms

Onde SilbercueSwift realmente se destaca

Capturas de tela até 75x mais rápidas — ~316ms ( ~15ms)

Capturas de tela no nível gratuito (~316ms) são mais rápidas que o XcodeBuildMCP (~1127ms) e a maioria das alternativas. O Pro reduz a latência para ~15ms — 5x mais rápido que o Appium, 75x mais rápido que o XcodeBuildMCP. Agentes podem tirar capturas de tela livremente sem penalidade em qualquer nível.

Resultados de teste estruturados de pacotes xcresult — zero adivinhação em falhas

Quando um teste falha, o agente recebe a mensagem de erro, o arquivo:linha exato, uma captura de tela do estado de falha e, opcionalmente, a saída do console — tudo analisado do formato .xcresult da Apple. Sem adivinhação a partir de 500 linhas de stderr do xcodebuild. Essa é a diferença entre "agente sabe o que quebrou" e "agente adivinha o que quebrou".

Binário único, zero dependências — 58 ferramentas, instalação em 10 segundos

brew install silbercueswift — pronto. Binário Swift nativo de 8,5MB. Sem Node.js, sem npm, sem servidor Appium, sem Python, sem Java, sem toolchain Rust. Inicialização a frio em ~50ms. A maneira mais rápida de ter um servidor MCP iOS funcionando.

O agente lê apenas o que importa — 90% menos tokens, zero chamadas desperdiçadas (filtragem por tópico )

O nível gratuito já remove ruído: 15 processos de ruído conhecidos são excluídos no momento da captura, e linhas duplicadas são colapsadas (redução de 79% de I/O). O Pro adiciona filtragem por tópico — read_logs categoriza linhas em 8 tópicos e mostra apenas app + crashes por padrão, com um menu: network(87) lifecycle(12) springboard(8). O agente abre tópicos específicos em uma chamada — sem adivinhação, sem iteração.

Uma chamada para dispensar todos os diálogos de permissão — 3 alertas em 1 roundtrip

Todo app mostra 2–3 diálogos de permissão no primeiro lançamento. Outros servidores exigem que o agente capture a tela → encontre o botão → clique, por diálogo. handle_alert(action: "accept_all") limpa todos em uma única chamada, pesquisando em SpringBoard, ContactsUI e no app ativo. O nível gratuito trata alertas individualmente com accept / dismiss.

Arrastar e soltar com IDs de elemento — 1 chamada em vez de 3

"Arrastar item A acima do item B" é uma única chamada: drag_and_drop(source_element: "el-0", target_element: "el-1"). A concorrência só suporta coordenadas brutas, forçando o agente a encontrar ambos os elementos, extrair seus frames e construir uma sequência de Ações W3C — no mínimo 3 chamadas.

Rolagem automática para elementos fora da tela — sem mais loops manuais de deslize

find_element(using: "accessibility id", value: "Save", scroll: true) rola automaticamente até o elemento aparecer. O SmartScroll lida com UIKit, SwiftUI e listas com carregamento preguiçoso — sem adivinhar a direção da rolagem.

Hierarquia de visualização em ~31ms (Grátis) / ~5ms (Pro) — inspeção de elementos até 188x mais rápida

get_source retorna a árvore de UI completa em ~31ms (Grátis) ou ~5ms (Pro). O concorrente mais rápido leva 44ms, a maioria leva 250ms+. Isso torna a inspeção de elementos praticamente gratuita para agentes.

Navegar em uma chamada — encontrar + tocar + estabilizar + capturar tela em ~380ms

navigate(to: "Settings") encontra o elemento, toca nele, aguarda a tela estabilizar e retorna uma captura de tela de verificação — tudo em uma única chamada. Nenhum concorrente oferece isso. Agentes economizam 3-4 chamadas de ferramenta por etapa de navegação.

Automação de UI em lote — run_plan executa planos de múltiplas etapas com decisões adaptativas

run_plan recebe uma sequência de etapas de UI e as executa no servidor. Quando uma etapa precisa de uma decisão (diálogo inesperado, elemento não encontrado), ela recorre a 4 níveis — de amostragem MCP a pausa e retomada. Sem mais sobrecarga de "uma chamada de ferramenta por toque".

Início Rápido

Instalar via Homebrew

brew tap silbercue/silbercue
brew install silbercueswift

Ou compilar a partir do código-fonte

git clone https://github.com/silbercue/SilbercueSwift.git
cd SilbercueSwift
swift build -c release
cp .build/release/SilbercueSwift /usr/local/bin/

Configurar no Claude Code

Um comando — instala globalmente para todos os projetos:

claude mcp add --scope user SilbercueSwift /opt/homebrew/bin/SilbercueSwift

Nota: Use o caminho completo (/opt/homebrew/bin/SilbercueSwift). O Claude Code inicia servidores MCP sem um PATH de shell completo, então nomes de comandos simples não serão encontrados.

Configurar no Cursor

Adicione ao ~/.cursor/mcp.json:

{
  "mcpServers": {
    "SilbercueSwift": {
      "command": "/opt/homebrew/bin/SilbercueSwift"
    }
  }
}

Configurar em outros clientes MCP (Cline, Continue, etc.)

Qualquer cliente que suporte servidores MCP stdio: aponte para /opt/homebrew/bin/SilbercueSwift sem argumentos.

Desinstalar

claude mcp remove --scope user SilbercueSwift
brew uninstall silbercueswift
brew untap silbercue/silbercue

Grátis vs Pro

SilbercueSwift oferece 49 ferramentas gratuitas — build, teste, simulação, automação de UI, captura de logs e capturas de tela. Sem limite de tempo, sem cadastro.

O Pro adiciona 9 ferramentas e internals mais rápidos para equipes e usuários avançados que precisam do quadro completo.

	Grátis	Pro
Build, teste, gerenciamento de simulador	49 ferramentas	58 ferramentas
Captura de tela	~316ms	~15ms (75x mais rápido)
Resultados de teste estruturados (xcresult)	Sim	Sim
Encontrar elemento	31ms	<1ms
Hierarquia de visualização	31ms	~5ms
Toque (coordenadas)	16ms	4ms
Clique / digitar / deslizar / toque duplo / pressionar longo / arrastar e soltar	Sim	Sim
Navegar (encontrar + tocar + verificar)	Sim	Sim
Automação de UI em lote (run_plan)	Sim	Sim
Tratamento de alertas	Aceitar/dispensar único	+ Aceitar_todos / dispensar_todos em lote
Captura de logs	Inteligente + detalhado	+ Modo App, filtragem por tópico
Captura de console, ferramentas git	Sim	Sim
Rolar até elemento	—	SmartScroll
Regressão visual	—	Baseline + diff de pixels
Verificação multi-dispositivo	—	Modo Escuro, Paisagem, iPad
Verificação de acessibilidade	—	Renderização de Dynamic Type
Verificação de localização	—	Multi-idioma + RTL
Pinça / zoom	—	Sim

O Pro custa 12 EUR/mês. Obtenha uma licença no Polar.sh, depois:

silbercueswift activate <YOUR-LICENSE-KEY>

58 Ferramentas em 14 Categorias

Build (5 ferramentas)

Ferramenta	Descrição
build_sim	Build para iOS Simulator — retorna erros estruturados + armazena em cache o bundle ID e o caminho do app
build_run_sim	Build + boot + instalar + lançar em uma chamada — pipeline paralelo de 2 fases, ~9s mais rápido que sequencial
clean	Limpar artefatos de build
discover_projects	Encontrar arquivos .xcodeproj/.xcworkspace
list_schemes	Listar schemes disponíveis

Testes e Diagnóstico (4 ferramentas)

Ferramenta	Descrição
test_sim	Executar testes + resumo estruturado de xcresult (passou/falhou/duração)
test_failures	Testes falhos com mensagens de erro, arquivo:linha e capturas de tela de falha
test_coverage	Cobertura de código por arquivo, ordenada e filtrável
build_and_diagnose	Build + erros/avisos estruturados do xcresult

Simulador (12 ferramentas)

Ferramenta	Descrição
list_sims	Listar simuladores disponíveis
boot_sim	Iniciar um simulador
shutdown_sim	Desligar um simulador
install_app	Instalar pacote .app
launch_app	Lançar app pelo bundle ID
terminate_app	Encerrar app em execução
clone_sim	Clonar um simulador existente
erase_sim	Apagar conteúdo e configurações do simulador
delete_sim	Excluir um simulador
set_orientation	Rotacionar dispositivo (PORTRAIT, LANDSCAPE_LEFT, LANDSCAPE_RIGHT) via WDA
sim_status	Estado do simulador (iniciado/desligado, tipo de dispositivo, runtime)
sim_inspect	Informações detalhadas do simulador (caminho de dados, caminho de log, UDID)

Automação de UI (16 ferramentas)

Entrada nativa para gestos, WDA para consultas de elementos e alertas — sem Appium, sem Node.js, sem Python.

Ferramenta	Descrição	Latência
handle_alert	Aceitar, dispensar ou gerenciar em lote alertas do sistema e do aplicativo	~200ms
find_element / find_elements	Encontra elementos por ID de acessibilidade, predicado, cadeia de classes. scroll: true rola automaticamente até o elemento aparecer (SmartScroll — 3 estratégias de fallback)	31ms ( <1ms)
click_element	Tocar em um elemento de interface	~75ms
tap_coordinates	Toque baseado em coordenadas	~16ms ( ~4ms)
double_tap / long_press	Toque duplo ou toque longo em coordenadas	~60ms / ~1000ms
swipe	Deslize direcional	~250ms
pinch	Zoom para dentro/fora	~400ms
drag_and_drop	Arrastar da origem ao destino — elemento a elemento, coordenadas ou misto. Padrões inteligentes para listas reordenáveis, quadros Kanban, controles deslizantes	~1.3s
navigate	Encontrar + tocar + estabilizar + capturar tela em 1 chamada — economiza 3-4 idas e voltas	~380ms
type_text / get_text	Digitar em ou ler de elementos	~100-300ms
get_source	Hierarquia completa da visualização (JSON/XML)	~31ms ( ~5ms)
wda_status / wda_create_session	Verificação de integridade do WDA e gerenciamento de sessão	~50-100ms

handle_alert — o manipulador de alertas mais inteligente

# Accept a single alert with smart defaults
handle_alert(action: "accept")

# Dismiss with a specific button label
handle_alert(action: "dismiss", button_label: "Not Now")

# Batch-accept ALL alerts after app launch (unique to SilbercueSwift)
handle_alert(action: "accept_all")

Busca de alertas em 3 níveis — encontra alertas em:

1. Springboard — diálogos de permissão do sistema (Localização, Câmera, Rastreamento)
2. ContactsUI — diálogo de "Acesso Limitado" de Contatos no iOS 18+ (processo separado)
3. Aplicativo ativo — diálogos UIAlertController dentro do aplicativo

Padrões inteligentes — sabe qual botão tocar:

• Aceitar: "Permitir" → "Permitir enquanto uso o app" → "OK" → "Continuar" → último botão
• Dispensar: "Não permitir" (lida com Unicode U+2019) → "Cancelar" → "Agora não" → primeiro botão

Modo lote — accept_all / dismiss_all percorre vários alertas sequenciais no servidor. Uma ida e volta HTTP em vez de N. Retorna detalhes de cada alerta tratado.

Essas capacidades vão além do que outros servidores MCP para iOS oferecem atualmente.

Capturas de tela (1 ferramenta)

Ferramenta	Latência
screenshot	Grátis: ~316ms / Pro: ~15ms

Logs (4 ferramentas)

Ferramenta	Descrição
start_log_capture	Fluxo os_log com filtro inteligente — 3 modos: smart (padrão, filtragem por tópico ativada), app (fluxo restrito, detecção automática), verbose (sem filtro). Remove duplicatas de linhas repetitivas.
stop_log_capture	Parar captura
read_logs	Leitura com filtro por tópico — padrão: app + falhas apenas. A resposta inclui menu de tópicos com contagem de linhas. Adicione tópicos via parâmetro include.
wait_for_log	Aguardar padrão regex com tempo limite — elimina hacks de sleep()

Filtragem inteligente de logs — 4 camadas, zero configuração

# Start capture (default: smart mode — broad stream, topic filtering enabled)
start_log_capture()

# Read logs — default shows only app logs + crashes + topic menu
read_logs()
# → --- 230 buffered, 42 shown [app, crashes] ---
# → Topics: app(35) crashes(2) | network(87) lifecycle(12) springboard(8) widgets(0) background(3) system(83)
# → Hint: include=["network"] to add SSL/TLS + background transfer logs
# → ---
# → [42 filtered lines]

# Agent sees network(87) and wants SSL details — one call:
read_logs(include: ["network"])

# Narrow stream for production monitoring:
start_log_capture(mode: "app")

# Bypass mode logic with explicit predicate:
start_log_capture(subsystem: "com.apple.SwiftUI")

4 camadas de filtro:

1. Exclusão de ruído no fluxo — 15 processos de ruído conhecidos + exclusões de subsistema/categoria removidas antes do buffer. Filtragem no servidor em logd — redução de 79% de I/O.
2. 3 modos de captura — smart (padrão, fluxo amplo para filtragem por tópico), app (restrito, ID do pacote + nome do processo detectados automaticamente), verbose (sem filtro).
3. Filtragem por tópico na leitura — read_logs categoriza cada linha em buffer em 8 tópicos (app, falhas, rede, ciclo de vida, springboard, widgets, segundo plano, sistema). O padrão mostra apenas app + falhas. O agente adiciona tópicos conforme necessário — sem estado por chamada.
4. Desduplicação de buffer — 60 linhas idênticas de heartbeat viram 2: a linha em si + ... repeated 59x.

8 tópicos com menu otimizado para LLM:

Tópico	Correspondências	Caso de uso
app (sempre ativo)	subsistema == bundleId OU processo == nomeDoApp	Seu app: os_log, print(), NSLog()
crashes (sempre ativo)	logs de nível fault	Falhas de qualquer processo
network	trustd, nsurlsessiond	Certificados SSL/TLS, transferências em segundo plano
lifecycle	runningboardd, com.apple.runningboard.*	Jetsam, pressão de memória, encerramentos de app
springboard	SpringBoard	Notificações push, estado do app
widgets	chronod	Linha do tempo do WidgetKit, orçamento de atualização
background	com.apple.xpc.activity.*	BGTaskScheduler, busca em segundo plano
system	todo o resto	AVISO: volume alto

Console (3 ferramentas)

Ferramenta	Descrição
launch_app_console	Iniciar app com captura de stdout/stderr
read_app_console	Ler saída do console
stop_app_console	Parar captura do console

Git (5 ferramentas)

Ferramenta	Descrição
git_status / git_diff / git_log	Operações de leitura
git_commit / git_branch	Operações de escrita

Regressão visual (2 ferramentas)

Ferramenta	Descrição
save_visual_baseline	Salvar uma captura de tela como linha de base nomeada
compare_visual	Comparar a tela atual com a linha de base — diff de pixels + pontuação de correspondência

Multi-dispositivo (1 ferramenta)

Ferramenta	Descrição
multi_device_check	Executar verificações visuais em vários simuladores (Modo Escuro, Paisagem, iPad) — retorna pontuações de layout

Acessibilidade (1 ferramenta)

Ferramenta	Descrição
accessibility_check	Renderizar telas em categorias de tamanho de conteúdo Dynamic Type — detecta truncamento e problemas de layout

Localização (1 ferramenta)

Ferramenta	Descrição
localization_check	Renderizar telas em vários idiomas, incluindo RTL (árabe, hebraico) — detecta quebras de layout

Automação (2 ferramentas)

Ferramenta	Descrição
run_plan	Executar um plano de automação de interface em várias etapas no servidor — decisões adaptativas com fallback em 4 níveis
run_plan_decide	Retomar um plano pausado com uma decisão — para clientes sem amostragem MCP

Sessão (1 ferramenta)

Ferramenta	Descrição
set_defaults	Definir projeto, esquema e simulador padrão — evita repetir parâmetros

Análise de xcresult — O Recurso Matador

O Problema

Todo servidor MCP do Xcode retorna saída xcodebuild bruta. Para uma execução de teste, são 500+ linhas de ruído. Agentes de IA não conseguem extrair de forma confiável quais testes falharam e por quê.

A Solução

SilbercueSwift usa xcresulttool para analisar o pacote .xcresult — os mesmos dados estruturados que o Navegador de Testes do Xcode usa.

# One call, structured result
test_sim(project: "MyApp.xcodeproj", scheme: "MyApp")

→ Tests FAILED in 15.2s
  12 total, 10 passed, 2 FAILED
  FAIL: Login shows error message
    LoginTests.swift:47: XCTAssertTrue failed
  FAIL: Profile image loads
    ProfileTests.swift:112: Expected non-nil value

  Failure screenshots (2):
    /tmp/ss-attachments/LoginTests_failure.png
    /tmp/ss-attachments/ProfileTests_failure.png

  Device: iPhone 16 Pro (18.2)
  xcresult: /tmp/ss-test-1774607917.xcresult

O agente recebe:

• Contagens de aprovação/reprovação — visão geral imediata
• Mensagens de falha com arquivo:linha — acionáveis
• Capturas de tela de falha — contexto visual (Claude é multimodal)
• Caminho do xcresult — reutilizável para test_failures ou test_coverage

Análise Profunda de Falhas

test_failures(xcresult_path: "/tmp/ss-test-*.xcresult", include_console: true)

→ FAIL: Login shows error message [LoginTests/testErrorMessage()]
    LoginTests.swift:47: XCTAssertTrue failed
    Screenshot: /tmp/ss-attachments/LoginTests_failure.png
    Console:
      [LoginService] Network timeout after 5.0s
      [LoginService] Retrying with fallback URL...
      ✘ Test "Login shows error message" failed after 6.2s

Cobertura de Código

test_coverage(project: "MyApp.xcodeproj", scheme: "MyApp", min_coverage: 80)

→ Overall coverage: 72.3%

  Target: MyApp.app (74.1%)
      0.0% AnalyticsService.swift
     45.2% LoginViewModel.swift
     67.8% ProfileManager.swift

  Target: MyAppTests.xctest (62.0%)
     ...

Benchmarks

Medidos em M3 MacBook Pro, Simulador iOS 26.4. Todos os valores são mediana de 5 execuções após 2 aquecimentos.

Ação	iosef	XcodeBuildMCP	Appium-MCP	SS Free	SS Pro
Captura de tela	83ms	1127ms	77ms	316ms	15ms
Encontrar elemento	50ms	N/A	76ms	31ms	<1ms
Toque (coordenadas)	48ms	235ms	470ms	16ms	4ms
Deslize	262ms	1284ms	2685ms	~250ms	~250ms
Hierarquia de visualização	44ms	259ms	938ms	31ms	5ms
Navegar (1 chamada)	—	—	—	~380ms	~380ms
Toque duplo	—	—	—	~84ms	~60ms
Arrastar e soltar	—	apenas coordenadas	—	~1.3s	~1.3s
Tratar alerta	—	—	118ms	~200ms	~200ms
Tratar 3 alertas (lote)	—	—	3 chamadas	~800ms (1 chamada)	~800ms (1 chamada)
Rolar até elemento	—	—	loop de deslize	—	Automático
Build (limpo)	—	2501ms	—	3188ms	1800ms
Lista de simuladores	12ms	567ms	—	15ms	15ms
Início a frio	~100ms	~400ms	~1000ms	~50ms	~50ms
Tamanho do binário	~5MB	~4MB	~200MB	8.5MB	8.5MB

Comparação com outros servidores MCP

Veja a tabela de comparação de recursos acima para um detalhamento vs XcodeBuildMCP, Appium-MCP e iosef. Todos os três são projetos excelentes que pioneiraram as ferramentas MCP para iOS. SilbercueSwift combina todos os seus conjuntos de recursos com integração mais profunda em um único binário nativo. A única desvantagem: SilbercueSwift é exclusivo para iOS (sem Android, watchOS, tvOS ou visionOS).

Arquitetura

SilbercueSwift (8.5MB Swift binary)
├── MCP SDK (modelcontextprotocol/swift-sdk)
├── StdioTransport (JSON-RPC)
└── 58 Tools in 14 Categories
    Build · Test · Simulator · Screenshot · UI Automation
    Logs · Console · Visual Regression · Multi-Device
    Accessibility · Localization · Automation · Git · Session

Sem Node.js. Sem Python. Sem servidor Appium. Sem Selenium. Um binário.

Requisitos

• macOS 13+
• Xcode 15+ (para xcresulttool e simctl)
• Swift 6.0+ (para compilar a partir do código-fonte)
• WebDriverAgent instalado no simulador (para ferramentas de automação de interface)

Licença

O binário principal e todas as 49 ferramentas gratuitas são licenciados sob MIT — veja LICENSE. Use-os como quiser, comercialmente ou não.

As ferramentas Pro (9 ferramentas adicionais + internos mais rápidos) exigem uma licença paga. O código de validação de licença (LicenseManager.swift) está incluído no código-fonte para transparência — você pode ver exatamente o que ele verifica e quando.

Contribuindo

Issues e pull requests são bem-vindos. Veja CONTRIBUTING.md para diretrizes.

Privacidade

SilbercueSwift é executado inteiramente no seu Mac e não coleta dados do usuário. Veja PRIVACY.md para detalhes.