> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zapbip.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Conector local

> Os comandos zapbip connect, listen e channel: opções, variável de ambiente, isolamento do despertar e logs.

Normalmente sua IA só lê o WhatsApp quando já está trabalhando. Se você escreve enquanto ela está parada, sua mensagem fica esperando.

O conector do zapbip resolve isso. É um programa pequeno que fica aberto no seu computador. Quando você escreve no WhatsApp, ele acorda a sessão de IA que você já usava, entrega sua mensagem e deixa a IA te responder. Leva cerca de 7 segundos no Claude Code e 6 no Codex.

Funciona com o Claude Code e o Codex. Seu computador precisa estar ligado e acordado, e o conector precisa estar rodando.

## Comandos

| Comando | O que faz |
| - | - |
| `connect` | Acorda uma sessão fechada quando você escreve. Aceita `--client`, `--cwd` e `--session`. |
| `listen` | Imprime uma linha JSON por mensagem, para um agente que acompanha um comando em segundo plano. |
| `channel` | Roda um canal MCP local que coloca cada mensagem numa sessão aberta do Claude Code. |

`ZAPBIP_CONNECTION_URL` guarda o link de conexão. `connect` e `listen` pedem o link quando a variável não está definida.

## O que você precisa

* Claude Code ou Codex, já conectado ao zapbip.
* Pelo menos uma sessão anterior na pasta em que você quer que a IA trabalhe.
* Node 24 ou mais novo.
* Seu link de conexão, o mesmo `https://.../c/<secret>/mcp` que sua IA usa para falar com o zapbip. Trate como uma senha.

## Como iniciar

Abra um terminal na pasta em que você usa sua IA e rode um destes:

```bash theme={null}
export ZAPBIP_CONNECTION_URL='https://<host>/c/<secret>/mcp'
npx zapbip@0.1.0 connect --client claude-code
```

```bash theme={null}
export ZAPBIP_CONNECTION_URL='https://<host>/c/<secret>/mcp'
npx zapbip@0.1.0 connect --client codex
```

Se você não definir `ZAPBIP_CONNECTION_URL`, o conector pergunta o link. Ele nunca aceita o link como argumento, porque argumentos aparecem no histórico do terminal e na lista de processos.

Deixe o terminal aberto. O conector imprime uma linha para cada evento e para quando você aperta `Ctrl+C`. Para mantê-lo rodando sem terminal, veja [Rodar em segundo plano](https://docs.zapbip.com/pt-br/developers/background-running.md).

## O que acontece quando você escreve

1. Você escreve para sua IA no WhatsApp.
2. O conector recebe sua mensagem e acorda a sessão mais recente da pasta.
3. A IA lê sua mensagem e responde no WhatsApp.
4. Se várias mensagens chegarem juntas, elas são tratadas uma por vez, em ordem.

Se você estava sem conexão ou o conector estava parado, suas mensagens não se perdem. Quando ele conecta de novo, pega todas as que não foram respondidas.

## Escolha a sessão

Por padrão o conector usa a sessão mais recente da pasta. Se a mesma pasta estiver aberta em outra janela, um despertar pode acrescentar àquela conversa. Para evitar, fixe uma sessão:

```bash theme={null}
npx zapbip@0.1.0 connect --client claude-code --session <session-id>
```

| Opção | O que faz |
| - | - |
| `--client` | `claude-code` ou `codex`. Obrigatória. |
| `--cwd` | A pasta de trabalho. O padrão é a pasta em que você rodou o comando. |
| `--session` | Um id de sessão (UUID) para sempre retomar, em vez da mais recente. |

## O que a IA pode fazer quando é acordada

Só uma coisa: te mandar uma mensagem de volta. O conector entrega à IA uma configuração privada que contém só o zapbip, então as ferramentas dos seus outros servidores MCP não ficam disponíveis para ela. O Claude Code também roda sem os seus arquivos de configuração e com todas as ferramentas internas desligadas, e o Codex roda com um sandbox somente leitura e com os outros servidores MCP que encontra nos seus arquivos de configuração do Codex desligados. Se não consegue ler um desses arquivos, não acorda o Codex e deixa a mensagem sem ler. Também recusa quando um arquivo gerenciado do Codex define qualquer chave fora de uma lista curta de chaves inofensivas, quando um perfil define sandbox, aprovação, ferramentas ou recursos (ou qualquer chave fora dessa lista), quando um arquivo liga uma chave de busca na web, ou quando `zapbip` é definido fora do `config.toml` da sua pasta do Codex. A busca na web do Codex fica desligada. O que sobra para o Codex é `send_message` e um shell somente leitura; apps e conectores da sua conta do Codex não são desligados, e as preferências gerenciadas do macOS `com.openai.codex` e as configurações de política gerenciada do Claude Code continuam valendo. Sua mensagem chega como uma mensagem sua, marcada como verificada. Uma mensagem que você encaminhou de outra pessoa chega marcada como não verificada, com um rótulo de encaminhada, e a IA não a trata como uma instrução sua.

Se o app do Codex já estiver com a conversa aberta, o Codex recusa retomá-la. O conector então abre uma única sessão nova na mesma pasta, que começa sem a conversa anterior, e passa a usá-la.

## Mantenha uma sessão aberta ouvindo

O `connect` acorda uma sessão que está fechada. Para uma sessão que você tem aberta agora, o Claude Code pode te ouvir na hora, sem acordar e sem esperar. Há duas formas, e a primeira é a melhor.

O canal é a primeira escolha. É um programa pequeno que o próprio Claude Code inicia, do mesmo jeito que inicia qualquer outra ferramenta. Ele coloca cada mensagem que você escreve no WhatsApp direto na sessão aberta, como uma mensagem sua, marcada como verificada (uma mensagem encaminhada vem marcada como não verificada). Defina `ZAPBIP_CONNECTION_URL` no ambiente em que o Claude Code roda, e o Claude Code o inicia com:

```bash theme={null}
npx zapbip@0.1.0 channel
```

O canal não consegue te perguntar o link, então só o lê de `ZAPBIP_CONNECTION_URL`. Ele não aceita argumentos.

Declare os dois servidores no `.mcp.json` da pasta em que você trabalha. O canal traz suas mensagens; o servidor HTTP do zapbip, sob outra chave, dá à sessão a ferramenta `send_message` com que ela responde:

```json theme={null}
{
  "mcpServers": {
    "zapbip-channel": {
      "command": "npx",
      "args": ["zapbip@0.1.0", "channel"],
      "env": { "ZAPBIP_CONNECTION_URL": "https://<host>/c/<secret>/mcp" }
    },
    "zapbip": {
      "type": "http",
      "url": "https://<host>/c/<secret>/mcp"
    }
  }
}
```

A sessão responde pelo `zapbip`. Sem ele a sessão te ouve, mas não tem como responder. Depois inicie o Claude Code com:

```bash theme={null}
claude --dangerously-load-development-channels server:zapbip-channel
```

`zapbip` é a chave do servidor do canal no `.mcp.json`. A linha de inicialização mostra `Channels (experimental)`. O Claude Code pede para você aceitar o canal de desenvolvimento e o servidor MCP do projeto; aceite os dois.

O ouvinte é o plano B. Ele imprime uma linha para cada mensagem que você escreve, e o Claude Code vigia essas linhas com a ferramenta `Monitor`. Cada linha acorda a sessão aberta, e nada é gasto enquanto você está em silêncio:

```bash theme={null}
export ZAPBIP_CONNECTION_URL='https://<host>/c/<secret>/mcp'
npx zapbip@0.1.0 listen
```

Cada linha é um JSON com o id da mensagem, o tipo, `"sender":"owner"`, `"verified"` (`true` para uma mensagem sua, `false` para uma encaminhada), `"forwarded"` e o texto. Uma vigia do `Monitor` dura até 30 minutos, então a IA a inicia de novo a cada vez que uma termina. Outros agentes que conseguem manter um comando rodando em segundo plano e reagir à saída dele, como o OpenClaw e o Hermes, podem usar `npx zapbip@0.1.0 listen` do mesmo jeito.

Os dois programas ficam abertos e reconectam sozinhos, como o `connect`. Os dois só marcam uma mensagem como tratada depois de repassá-la, então uma mensagem nunca se perde e nunca aparece duas vezes. Os logs deles vão para a saída de erro e nunca trazem suas mensagens nem seu link.

Então as três formas se completam: o canal para uma sessão aberta, o `listen` como alternativa a ele e o `connect` para uma sessão fechada.

## Um conector por conexão

Se você iniciar um segundo conector para a mesma conexão, o primeiro termina o acordar que está rodando e para. Rode em um computador por vez. Se uma mensagem chegar no momento da troca, os dois conectores podem acordar sua IA para essa mesma mensagem uma vez; o zapbip entrega pelo menos uma vez, nunca zero.

Enquanto um conector está ligado, o zapbip acorda sua IA por ele. Quando ele fecha, o zapbip volta à configuração que você tinha antes.

## O que ele imprime

Cada linha é um JSON com a hora e um evento, como `wake_started` e `wake_finished`. As linhas trazem ids, tipos, resultados e tempos. Nunca trazem suas mensagens, as respostas da IA nem seu link de conexão.

## Quando algo não funciona

| O que você vê | O que significa |
| - | - |
| O conector sai na hora | O link é desconhecido ou foi revogado. Peça um novo. |
| Sua mensagem fica sem resposta | Ainda não há sessão na pasta, ou `claude` ou `codex` não está instalado onde o conector roda. Abra a IA uma vez nessa pasta. |
| Ele reconecta sem parar | Sua rede caiu. Ele tenta de novo com esperas crescentes, até 30 segundos, e continua de onde parou. |
| Ele parou sozinho | Você iniciou outro conector para a mesma conexão. |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.