Vibe MCP

Vibe MCP - Automação de Navegador para Agentes de IA

Servidor MCP para Vibe AI Browser — controle seu Chrome real e conectado a partir de qualquer cliente MCP, incluindo agentes rodando em uma máquina diferente sem porta de entrada aberta.

⚠️ Segurança — trate sua URL de relay/UUID como uma senha. Uma URL de relay ou UUID de extensão (wss://relay.api.vibebrowser.app/<uuid>) concede controle ao vivo da sua sessão de navegador (ler suas abas, tirar capturas de tela, ler conteúdo de páginas). Nunca compartilhe, cole em um chat com partes não confiáveis ou envie para um repositório. Todo UUID de exemplo nesta documentação é um espaço reservado não roteável (YOUR-EXTENSION-UUID ou 00000000-0000-0000-0000-000000000000) — substitua pelo seu próprio valor secreto localmente e mantenha-o fora do controle de versão.

Prompt de instalação para agentes de IA (OpenClaw / Hermes)

Cole o bloco abaixo no seu agente OpenClaw ou Hermes. Substitua a última linha pelo seu valor remoto — a URL do conector (https://relay.api.vibebrowser.app/mcp/<uuid>) mostrada nas configurações da extensão Vibe em Configurações → Controle de Agente de IA → Remoto (internet) → Acesso via relay (um UUID simples ou uma URL de relay wss:// também funcionam). Essa é a única edição que você faz.

You are setting yourself up to control my real Chrome through Vibe Browser. Work through the steps in order, and after each step confirm it worked before moving on. Do not claim a step is done until you have proven it.

1. Install the "vibebrowser" skill for your runtime:
   - OpenClaw:  npx -y skills add VibeTechnologies/vibe-mcp -s vibebrowser -a openclaw -g -y --copy --dangerously-accept-openclaw-risks
                then run `openclaw skills list` and confirm a "vibebrowser" row shows "ready" as installer registration.
   - Hermes:    npx -y skills add VibeTechnologies/vibe-mcp -s vibebrowser -y
                optional installer registration check: `npx -y skills list` shows a "vibebrowser" row.

2. Remember my remote so I only give it to you once. Save it to a file `vibebrowser-cli.md` in your persistent agent workspace root (the directory that holds your `memory/` folder — not the shell's working dir, not $HOME unless they are the same) as a line `remote: <value>`; if your runtime can also write memory keys, additionally store it under `vibebrowser_remote`. On every later command — including the first message of a new conversation — load it back from that file and reuse it without asking me again.

3. Record a standing rule so you route correctly later: whenever I ask you to do anything in MY browser / MY Chrome / MY tabs / the page I'm on, use this vibebrowser skill (`npx -y @vibebrowser/cli@latest` with my saved remote) to drive my REAL browser — never your built-in, headless, or in-pod browser, never web-fetch instead, and never run `vibebrowser`. Save this rule wherever your standing instructions/memory live so it applies in future conversations.

4. Confirm you can control my Chrome, retrying on "Extension reconnecting" (wait 3s, up to 5x):
   npx -y @vibebrowser/cli@latest --remote "<my remote>" --json status --wait-for-extension --wait-timeout 20000
   npx -y @vibebrowser/cli@latest --remote "<my remote>" --json snapshot --format aria

Then report: (1) is extensionConnected true, (2) did the snapshot return my real page content?

My remote: <PASTE YOUR CONNECTOR URL, UUID, OR wss:// URL HERE>

Por que o Vibe MCP?

O espaço MCP de automação de navegador evoluiu rápido. A maior parte do que costumava nos diferenciar agora é pré-requisito básico — então aqui está um placar honesto. Onde um concorrente nos iguala, a coluna diz Sim.

Duas linhas são exclusivamente nossas:

• Controle externo entre máquinas. A extensão Vibe abre um WebSocket de saída para um relay (wss://relay.api.vibebrowser.app/<uuid>). Nada escuta na máquina do usuário, nada é encaminhado por porta, e o agente pode viver em um pod, um cron job ou um chatbot. Nenhum concorrente documenta uma conexão de saída iniciada por extensão para um servidor MCP remoto.
• Perfil real sem o custo do diálogo. O Chrome DevTools MCP exige aprovação para cada conexão WebSocket ao Chrome (#1794, aberto; persistência foi fechado como won't-fix). A solução alternativa do mantenedor — --remote-debugging-port com um --user-data-dir dedicado — evita o diálogo abrindo mão do seu perfil conectado. Então: pule o diálogo, ou use seu perfil real — não ambos.

Também vale saber:

• Aprisionamento de fornecedor. O Claude for Chrome está em GA, clica e digita via permissão debugger, e suporta tarefas agendadas — é o concorrente mais próximo. Mas ele só controla as próprias superfícies da Anthropic (painel lateral, conector Claude Desktop, Cowork, Claude Code). Não há API pública ou superfície MCP, então Codex, OpenCode, Hermes e OpenClaw não podem usá-lo. O Vibe MCP é agnóstico de agente.
• Estabilidade. O Chrome DevTools MCP é explicitamente experimental e atualmente carrega problemas abertos de vazamento de memória (#2431, #2291, #2456) e concorrência (#1763, #1921).

Arquitetura Multi-Agente

Execute Claude Desktop, Cursor, VS Code Copilot e OpenCode ao mesmo tempo — eles compartilham o controle de um navegador através do relay, que multiplexa requisições e roteia cada resposta de volta ao agente que perguntou.

Claude Desktop       Cursor          VS Code         OpenCode
     |                  |                |               |
     v                  v                v               v
 [vibebrowser-mcp] [vibebrowser-mcp] [vibebrowser-mcp] [vibebrowser-mcp]
     |                  |                |               |
     +------------------+----------------+---------------+
                        |
                        v
                  [Relay Daemon]  <-- Auto-spawned, handles multiplexing
                        |
                        v
                 [Vibe Extension]
                        |
                        v
                   [Your Chrome]

Recursos

• Pronto para Multi-Agente - Execute Claude, Cursor, VS Code e mais simultaneamente contra um navegador
• Usa Seu Navegador - Sem instância separada de navegador, usa seu Chrome existente com todos os seus logins
• Capaz de Remoto - A extensão conecta para fora a um relay, então o agente pode rodar em outra máquina sem porta de entrada
• Local por padrão - No modo local, tudo permanece em 127.0.0.1; apenas o modo relay remoto roteia tráfego através de relay.api.vibebrowser.app
• Modo Chrome DevTools direto - Ferramentas de extensão permanecem primárias por padrão; use --devtools para controlar seu Chrome real em execução diretamente pelo Protocolo DevTools (sem extensão necessária)

Início Rápido

1. Instale a Extensão Vibe

Instale a extensão Vibe AI Browser no Chrome, Brave ou qualquer navegador Chromium:

Opção A: Chrome Web Store (Recomendado)

1. Visite a Chrome Web Store
2. Clique em "Adicionar ao Chrome"
3. O ícone Vibe aparecerá na sua barra de ferramentas

Opção B: Versão para Desenvolvedores

1. Baixe o ZIP da versão mais recente
2. Extraia para uma pasta permanente
3. Vá para chrome://extensions, ative o Modo de Desenvolvedor
4. Clique em "Carregar sem compactação" e selecione a pasta extraída

Para instruções detalhadas, veja o guia de instalação.

2. Configure Seu Aplicativo de IA

{
  "mcpServers": {
    "vibe": {
      "command": "npx",
      "args": ["-y", "@vibebrowser/mcp"]
    }
  }
}

{
  "vibe": {
    "command": "npx",
    "args": ["-y", "@vibebrowser/mcp"]
  }
}

{
  "github.copilot.chat.mcpServers": {
    "vibe": {
      "command": "npx",
      "args": ["-y", "@vibebrowser/mcp"]
    }
  }
}

{
  "mcpServers": {
    "vibe": {
      "command": "npx",
      "args": ["-y", "@vibebrowser/mcp"]
    }
  }
}

{
  "mcp": {
    "servers": {
      "vibe": {
        "command": "npx",
        "args": ["-y", "@vibebrowser/mcp"]
      }
    }
  }
}

{
  "mcpServers": {
    "vibe": {
      "command": "npx",
      "args": ["-y", "@vibebrowser/mcp"]
    }
  }
}

codex mcp add vibe -- npx -y @vibebrowser/mcp

[mcp_servers.vibe]
command = "npx"
args = ["-y", "@vibebrowser/mcp"]

Formas de comando MCP

Use a invocação direta de pacote mais curta para o servidor MCP:

npx -y @vibebrowser/mcp@latest --help
npx -y @vibebrowser/mcp@latest start --transport http
npx -y @vibebrowser/mcp@latest openclaw --remote "$VIBE_REMOTE_URL"

Aliases compatíveis com versões anteriores ainda funcionam quando você precisa de binários explícitos:

npx -y -p @vibebrowser/mcp@latest vibebrowser-mcp --help
npx -y -p @vibebrowser/mcp@latest vibe-mcp --help

Conector remoto (assistentes hospedados — sem instalação)

Tudo acima assume que o cliente pode iniciar um processo local. Assistentes hospedados não podem: Claude na web / no Cowork / no mobile, e ChatGPT na web, rodam na nuvem do fornecedor sem acesso à sua máquina. Eles aceitam uma URL de servidor MCP remoto e nada mais — sem comando, sem argumentos e sem cabeçalhos de requisição personalizados.

Para esses, pule @vibebrowser/mcp completamente. A extensão sozinha é suficiente:

https://relay.api.vibebrowser.app/mcp/<your-extension-uuid>

Encontre <your-extension-uuid> na extensão: Ícone Vibe → Configurações → Controle de Agente de IA → Remoto (internet) → Acesso via relay. Esse painel mostra esta URL exata de conector, e a mesma string agora é o valor preferido para a flag --remote do CLI/servidor — cole nos dois lugares, sem tradução necessária:

VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
npx -y @vibebrowser/mcp@latest start --remote "$VIBE_REMOTE_URL"

Um UUID simples de extensão ou uma URL de relay wss://relay.api.vibebrowser.app/<uuid> ainda são aceitos como formas avançadas/de compatibilidade — veja a tabela de valores aceitos de --remote em "OpenClaw na Nuvem -> Navegador Local" abaixo.

Este é um endpoint MCP Streamable HTTP simples. Não há fluxo de consentimento OAuth, nem registro dinâmico de cliente, nem configuração de escopos neste caminho — o UUID na URL (ou cabeçalho, abaixo) é a credencial inteira. Se um cliente insistir em um login OAuth antes de adicionar o servidor, esse cliente não é suportado aqui; use o caminho stdio local.

Onde colar:

Conectores personalizados são um recurso de plano pago nos produtos Claude e ChatGPT.

Codex Desktop, Codex CLI e a extensão IDE Codex podem iniciar um processo local, e todos compartilham ~/.codex/config.toml. Prefira a entrada stdio local acima — ela mantém o tráfego em 127.0.0.1 e mantém o UUID fora de uma URL. Use codex mcp add vibe --url … apenas quando o navegador que você quer controlar estiver em uma máquina diferente do Codex. O aplicativo de desktop do ChatGPT é baseado em Codex e lê a mesma configuração, então também é uma superfície stdio local; apenas o ChatGPT web precisa da URL hospedada.

Migrando do guia aposentado de conector estilo OAuth

Versões anteriores destes documentos (e a pesquisa de submissão de diretório de ago/2026 mantida em worklog/) descreviam um fluxo de consentimento OAuth 2.1 + DCR aposentado em um /mcp simples. Esse caminho está aposentado e não é suportado para usuários. Se você adicionou o Vibe como conector anteriormente e foi enviado a uma tela de consentimento aposentada, remova esse conector e adicione-o novamente com a URL https://relay.api.vibebrowser.app/mcp/<uuid> direta acima. Nada para autorizar, nada para registrar, nenhum escopo para escolher.

O relay também aceita o UUID como cabeçalho X-Remote-Session ou Authorization: Bearer em um POST /mcp simples. Use a forma de cabeçalho de qualquer coisa que possa enviar um (Codex CLI, scripts) — ela mantém a credencial fora de URLs, logs e histórico do navegador. A forma de caminho existe especificamente para as interfaces que não podem enviar um cabeçalho.

Duas coisas que este caminho custa a você, ditas claramente:

1. A URL é uma credencial. Qualquer um que tenha esse UUID pode controlar seu navegador conectado — ler seu e-mail, agir como você em qualquer site em que você esteja conectado. Trate exatamente como uma senha: nunca envie para um repositório, nunca cole em um chat compartilhado, uma issue, um README ou uma captura de tela. Se vazar, revogue a sessão na extensão e gere uma nova. (Isso não é hipotético: o UUID de uma máquina de desenvolvimento uma vez foi enviado nestes próprios documentos.)
2. O conteúdo da página sai da sua máquina. No caminho STDIO local, chamadas de ferramenta e conteúdo de página nunca saem de 127.0.0.1. No caminho de conector remoto, eles atravessam relay.api.vibebrowser.app, porque o assistente está na nuvem do fornecedor e não tem outra rota para o seu navegador. Se você precisar apenas no dispositivo, use um cliente desktop com o servidor local.

3. Conecte a Extensão

1. Abra o Chrome com a extensão Vibe instalada
2. Clique no ícone da extensão Vibe na barra de ferramentas
3. Vá para Configurações e ative "Controle Externo MCP"
4. O status deve mostrar "Conectado"

Se a extensão não estiver conectada, vibebrowser-mcp pode opcionalmente recorrer a chrome-devtools-mcp (iniciado no modo --autoConnect) quando esse pacote estiver instalado. Esse fallback é executado uma vez no daemon de relay local compartilhado (seguro para multi-agente), então tanto vibebrowser-mcp quanto vibebrowser-cli usam a mesma instância de backend. Quando a extensão está conectada, as ferramentas da extensão são autoritativas.

Modo --devtools (controle seu Chrome real via CDP)

Passe --devtools para qualquer CLI para ignorar completamente o roteamento de relay/extensão e controlar seu Chrome real em execução diretamente pelo Chrome DevTools Protocol. Este backend (portado da skill chrome-use) lê o arquivo DevToolsActivePort do Chrome e se conecta automaticamente ao seu perfil ativo — sem extensão, sem servidor MCP externo, zero dependências extras. Requer Chrome 144+; o diálogo de permissão é exibido uma vez por perfil.

--devtools expõe um conjunto de ferramentas focado: navigate, snapshot (árvore de acessibilidade com referências @eN), click, fill, type, press_key, hover, scroll, screenshot, eval, get_text, get_url, get_title e gerenciamento de abas (list_tabs, new_tab, select_tab, close_tab). Use snapshot para obter referências de elementos @eN e depois passe-as como seletores para click/fill/type.

Substitua o perfil/canal do Chrome com VIBE_CHROME_USER_DATA_DIR e VIBE_CHROME_CHANNEL (stable | canary | beta | dev).

Ainda não coberto pelo --devtools v1 (adicionável depois conforme mais domínios CDP forem conectados): inspeção de requisições de rede, logs de console, traces de performance, Lighthouse, snapshots de memória, emulação de dispositivos, tratamento de diálogos, upload de arquivos e arrastar.

Ferramentas Disponíveis

Como Funciona

Modo local padrão (sem flags):

Claude / Cursor / VS Code (stdio)
            │
            ▼
   [vibebrowser-mcp]
            │  ws://127.0.0.1:19888
            ▼
     Local Relay (auto-spawned)
            │  ws://127.0.0.1:19889
            ▼
     Vibe Extension (Chrome)

1. Aplicações de IA conectam via MCP sobre stdio
2. vibebrowser-mcp conecta ao relay local na porta 19888
3. O relay encaminha comandos para a extensão na porta 19889
4. Os resultados retornam ao agente

Duas pernas, dois protocolos

Não os confunda — o transporte para o servidor MCP é configurável, o transporte para a extensão não é.

MCP client ──stdio──┐
                    ├──> [vibebrowser-mcp] ──ws──> [relay] ──ws──> [extension]
MCP client ──http───┘

HTTP streamable permite que um agente remoto ou hospedado — que não pode iniciar um subprocesso stdio — fale com o servidor por uma URL:

npx -y @vibebrowser/mcp@latest start --transport http
# serves POST/GET http://127.0.0.1:8788/mcp

Padrões: --host 127.0.0.1, --http-port 8788, --http-path /mcp. Adicione --allow-host <host> (repetível) se você o colocar atrás de um proxy ou vinculá-lo além de localhost.

Modo Multi-Agente

Quando vários agentes se conectam, o Vibe MCP inicia automaticamente um daemon de relay:

• O primeiro agente inicia o relay (escuta nas portas 19888 e 19889)
• Agentes adicionais conectam ao relay como clientes
• O relay multiplexa todas as requisições dos agentes para a única conexão da extensão
• Cada agente recebe apenas suas próprias respostas

Cloud OpenClaw -> Navegador Local

⚠️ Segurança: O valor --remote abaixo é uma credencial viva — uma URL de relay/UUID/URL de conector concede controle total da sessão do navegador alvo. É a única credencial de portador (não há fator de segunda autenticação). Trate-a como uma senha: mantenha-a em segredo, nunca a envie para commits ou cole em logs, e se vazar, regenere-a nas Configurações da extensão Vibe.

Valores aceitos de --remote

--remote (e a ferramenta MCP set_remote) aceitam três formas, todas normalizadas para a mesma conexão de relay:

Relays auto-hospedados ou locais derivam da mesma forma: https://your-host/vibe/mcp/<uuid> → relay wss://your-host/vibe; um conector de loopback como http://127.0.0.1:19889/mcp/<uuid> → ws://127.0.0.1:19889 (somente relay auto-hospedado/local — hosts não-loopback devem usar https:///wss://).

Rejeitados: um UUID inválido; uma URL com credenciais embutidas, query string ou fragmento; http:///ws:// em texto puro para um host não-loopback; e qualquer URL HTTP(S) que não termine no sufixo exato /mcp/<uuid>.

Se seu agente roda na nuvem mas você quer que ele controle o navegador local real do usuário, execute vibebrowser-mcp no modo HTTP e conecte-o à extensão Vibe no modo relay remoto. Passe a URL de conector (preferida), o UUID da extensão ou a URL completa do relay WebSocket para --remote.

VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
npx -y @vibebrowser/mcp@latest start --transport http --remote "$VIBE_REMOTE_URL"

Isso expõe um endpoint MCP local em http://127.0.0.1:8788/mcp por padrão.

Quando o OpenClaw roda em uma máquina diferente (por exemplo, hospedado na nuvem), forneça uma URL acessível:

VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
PUBLIC_MCP_URL="https://browser-bridge.example.com/mcp"
npx -y @vibebrowser/mcp@latest openclaw --remote "$VIBE_REMOTE_URL" --public-url "$PUBLIC_MCP_URL"

Você pode imprimir a configuração exata amigável ao OpenClaw com:

VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
npx -y @vibebrowser/mcp@latest openclaw --remote "$VIBE_REMOTE_URL"

Use a URL de conector (preferida) com o relay público padrão, um UUID puro (relay público padrão) ou uma URL wss:// quando precisar de um endpoint de relay explícito. Qualquer forma que você usar é a única credencial — nunca a compartilhe, registre em logs ou cole em um chat não confiável.

Para verificações diretas do CLI do navegador, sempre use npx -y @vibebrowser/cli@latest:

VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" --json status

A URL de conector usa o relay público padrão. --remote <uuid> também usa o relay público padrão. --remote <full-ws-url> aponta para um endpoint de relay explícito. Nenhum segredo de segundo fator é necessário ou aceito — qualquer forma que você passar é a única credencial que autoriza a sessão.

Para o passo a passo completo, veja docs/openclaw-local-browser.md.

CLI de Navegador Compatível com OpenClaw

npx -y @vibebrowser/cli@latest espelha o formato do CLI de navegador do OpenClaw para o caminho real do navegador local:

npx -y @vibebrowser/cli@latest sessions
VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" status
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" tabs
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" open https://example.com
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" snapshot
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" click 12
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" type 23 "hello" --submit
npx -y @vibebrowser/cli@latest --devtools status

Use o pacote MCP para fluxos de trabalho de servidor MCP e o pacote CLI para controle direto do navegador:

• vibebrowser-mcp para servidor MCP, ponte HTTP e comandos auxiliares
• npx -y @vibebrowser/cli@latest para controle de navegador inspirado no OpenClaw contra a sessão real conectada ao Vibe

@vibebrowser/cli aceita a flag --browser-profile no estilo OpenClaw para compatibilidade e suporta --json para saída legível por máquina. Diferente do perfil de navegador gerenciado openclaw do OpenClaw, este CLI sempre aponta para a sessão real do navegador conectado ao Vibe.

Seleção de sessão local:

• npx -y @vibebrowser/cli@latest sessions lista as sessões de navegador locais conectadas.
• npx -y @vibebrowser/cli@latest --session <id> ... aponta para uma sessão local específica.
• Se --session for omitido no modo local, o CLI usa a primeira sessão conectada.
• No modo remoto, passe a URL de conector (preferida), um --remote <uuid> puro para usar o relay público padrão, ou --remote <full-ws-url> para usar um endpoint de relay explícito.

O comportamento de snapshot é somente por ferramenta (sem atalho RPC de snapshot legado):

• snapshot (padrão --format markdown; alias legado --format ai) resolve via ferramenta take_md_snapshot — usa o extrator de markdown na página do content script. Rápido e legível, mas pode retornar vazio para abas em segundo plano ou SPAs complexos (Notion, Gmail) onde o content script está inacessível ou o layout não é calculado. Quando o backend expõe apenas take_snapshot, o CLI envia format: "markdown" (ai é mapeado para markdown antes da chamada).
• snapshot --format aria resolve via ferramenta take_a11y_snapshot — usa o Chrome DevTools Protocol Accessibility.getFullAXTree diretamente. Confiável para todas as abas, incluindo abas em segundo plano e SPAs. Use como fallback quando o formato padrão retornar vazio ou apenas um título de página.

Isso mantém o comportamento do CLI alinhado com as ferramentas suportadas pela extensão e garante que o direcionamento de páginas funcione consistentemente com --page-id/--pageId.

Para operações de navegação, as respostas agora incluem o conteúdo da página quando o estado da página muda:

• CLI open / navigate incluem pageContent na saída JSON.
• Chamadas de ferramentas MCP para ferramentas de navegação retornam conteúdo de texto que inclui o estado atual da página (com fallback de snapshot quando necessário).

Prompt de Instalação para Agentes de IA (OpenClaw / Hermes)

Use o prompt único canônico de copiar e colar no topo deste README: Prompt de instalação para agentes de IA (OpenClaw / Hermes). Ele instala a skill vibebrowser, salva seu remoto para que você só o forneça uma vez e prova o controle do seu Chrome real.

Para uma definição mais profunda da skill (quando preferir isso a um navegador gerenciado/headless, as regras de recall remoto, orientações de seletor/snapshot), instale openclaw/vibebrowser/SKILL.md no diretório de skills do agente.

Integração com OpenClaw

Há duas maneiras de usar o Vibe com o OpenClaw:

Opção A: OpenClaw na nuvem controlando navegador local

Se o OpenClaw roda na nuvem mas você quer que ele controle seu navegador local:

1. Instale a extensão Vibe e ative o modo Remoto (veja docs/openclaw-local-browser.md)
2. Inicie a ponte HTTP local: vibebrowser-mcp openclaw --remote "$VIBE_REMOTE_URL" [--public-url "$PUBLIC_MCP_URL"]
3. Registre a URL MCP no OpenClaw

Opção B: Skill OpenClaw para agentes locais

Para agentes OpenClaw que precisam do contexto real do seu navegador (sessões logadas, abas existentes):

1. Copie a skill Vibe deste pacote para sua pasta de skills do OpenClaw
2. Use a URL de conector (preferida), o UUID da extensão ou a URL completa do relay WebSocket com --remote
3. Use comandos npx -y @vibebrowser/cli@latest nos prompts do seu agente

A skill está localizada em openclaw/vibebrowser/SKILL.md e fornece:

• Comandos CLI completos compatíveis com OpenClaw (status, tabs, snapshot, click, type, etc.)
• Comandos seguros com fallback para fluxos baseados em DevTools (resize, upload, dialog)
• Saída --json para análise por máquina
• Configuração baseada em ambiente

Veja docs/openclaw-local-browser.md para o passo a passo completo.

LLM Local: Comando serve

Execute um LLM local com um único comando — sem chaves de API em nuvem. Instala automaticamente o Ollama, baixa o modelo e começa a servir uma API compatível com OpenAI.

npx -y @vibebrowser/mcp@latest serve qwen3.5

É isso. Funciona em macOS, Linux e Windows.

O que ele faz

1. Detecta o Ollama → instala se estiver ausente (via brew, curl ou winget)
2. Inicia o servidor → executa ollama serve em segundo plano
3. Baixa o modelo → transmite o progresso do download para seu terminal
4. Imprime informações de conexão → pronto para usar com o VibeBrowser ou qualquer cliente compatível com OpenAI

Modelos recomendados

npx -y @vibebrowser/mcp@latest serve qwen3.5      # Best overall for agentic tasks
npx -y @vibebrowser/mcp@latest serve llama4        # Strong general reasoning
npx -y @vibebrowser/mcp@latest serve deepseek-r1   # Reasoning chains
npx -y @vibebrowser/mcp@latest serve mistral       # Lightweight & fast (7B)

Opções

npx -y @vibebrowser/mcp@latest serve <model> [options]

Options:
  -p, --port <number>  Ollama API port (default: 11434)
  -y, --yes            Skip install confirmation prompts
  -d, --debug          Enable debug logging

Usando com a extensão VibeBrowser

Após serve concluir, configure a extensão:

• Provedor de modelo → ollama
• Nome do modelo → o modelo que você serviu (ex.: qwen3.5)

A extensão conecta a http://localhost:11434/v1 automaticamente.

Opções de CLI

npx -y @vibebrowser/mcp@latest --help
npx -y @vibebrowser/cli@latest --help

# MCP server (default)
npx -y @vibebrowser/mcp@latest [start] [options]
  -p, --port <number>  WebSocket port for local relay (agent) connection (default: 19888)
  -d, --debug          Enable debug logging
  --transport <mode>   MCP transport to expose: stdio or http (default: stdio)
  --host <host>        Host to bind the HTTP server to (default: 127.0.0.1)
  --http-port <number> Port for streamable HTTP MCP transport (default: 8788)
  --http-path <path>   Path for streamable HTTP MCP transport (default: /mcp)
  --allow-host <host>  Allowed host header for HTTP transport (repeatable)
  -r, --remote <uuid-or-url>  Connect to a remote extension via relay. Accepts the connector URL from extension Settings (https://relay.api.vibebrowser.app/mcp/<uuid>), a bare extension UUID, or a ws(s) relay URL. This value is the sole bearer credential — treat it like a password; regenerate it in extension Settings if exposed.
  --devtools           Drive your real running Chrome directly over the DevTools Protocol (bypasses the extension relay)

# MCP server tool
set_remote { "url": "https://relay.api.vibebrowser.app/mcp/<extension-uuid>" }

A ferramenta MCP do servidor set_remote reconecta a quente o servidor MCP em execução a um relay remoto diferente. É uma ferramenta MCP, não um subcomando CLI do navegador. Ela aceita as mesmas três formas que --remote (URL do conector preferida, UUID simples ou URL wss://). O valor é a única credencial — nunca o coloque em logs compartilhados com partes não confiáveis; regenere-o nas Configurações da extensão se for exposto.

# OpenClaw helper
VIBE_REMOTE_URL="https://relay.api.vibebrowser.app/mcp/00000000-0000-0000-0000-000000000000"
PUBLIC_MCP_URL="https://browser-bridge.example.com/mcp"
npx -y @vibebrowser/mcp@latest openclaw --remote "$VIBE_REMOTE_URL" --public-url "$PUBLIC_MCP_URL"

# OpenClaw-compatible browser CLI
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" status
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" status --wait-for-extension --wait-timeout 10000
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" tabs
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" snapshot --json
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" click 12
npx -y @vibebrowser/cli@latest --remote "$VIBE_REMOTE_URL" type 23 "hello" --submit
npx -y @vibebrowser/cli@latest --devtools tabs

# Local LLM server
MODEL="qwen3.5"
npx -y @vibebrowser/mcp@latest serve "$MODEL"
  -p, --port <number>  Ollama API port (default: 11434)
  -y, --yes            Skip confirmation prompts
  -d, --debug          Enable debug logging

Solução de problemas

"Sem conexão com a extensão Vibe"

1. Garanta que a extensão Vibe esteja instalada no Chrome
2. Clique no ícone da extensão e habilite "Controle Externo MCP" nas Configurações
3. Verifique se nenhum firewall está bloqueando conexões localhost

"OpenClaw não consegue alcançar minha ponte de navegador local"

1. Inicie o vibebrowser-mcp no modo HTTP em vez de stdio
2. Certifique-se de que o processo da ponte ainda esteja em execução na máquina do usuário
3. Confirme que a extensão está no modo Remote e conectada
4. Verifique se a URL MCP no OpenClaw corresponde à URL da ponte. Se o OpenClaw estiver hospedado na nuvem, não use 127.0.0.1; use openclaw --public-url com um host acessível.

Modo de depuração

Habilite o registro de depuração para diagnosticar problemas:

{
  "mcpServers": {
    "vibe": {
      "command": "npx",
      "args": ["-y", "@vibebrowser/mcp", "--debug"]
    }
  }
}

Desenvolvimento

git clone https://github.com/VibeTechnologies/vibe-mcp.git
cd vibe-mcp
npm install
npm run build
node dist/cli.js --debug

Palavras-chave

automação de navegador, servidor mcp, protocolo de contexto de modelo, controle de navegador por IA, navegador de desktop claude, automação de navegador cursor, automação web, automação chrome, agente de navegador por IA, controle de navegador multiagente, alternativa ao playwright, alternativa ao puppeteer, navegador mcp, raspagem web por IA, agente web por IA

Licença

Apache-2.0

Links

• Navegador Vibe AI - Produto principal
• Documentação - Documentação completa
• Extensão Chrome - Instalar extensão
• Problemas no GitHub - Reportar bugs
• Pacote npm - Registro npm