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

# OpenClaw

> Controle o seu espaço de trabalho do Social media studio a partir do agente de IA pessoal OpenClaw

O Social media studio é distribuído como uma **skill do OpenClaw incluída no pacote npm [`@social-media-scheduler/cli`](https://www.npmjs.com/package/@social-media-scheduler/cli)** — instale a CLI uma vez e o OpenClaw descobre a skill automaticamente.

## Instalação

**1. Instale o OpenClaw na sua máquina**

Siga o [guia de instalação do OpenClaw](https://github.com/openclaw/openclaw). Requer Node.js 22+.

```bash theme={null}
npm install -g openclaw@latest
openclaw onboard --install-daemon
```

**2. Instale a CLI do Social media studio (que traz a skill)**

```bash theme={null}
npm install -g @social-media-scheduler/cli
```

O pacote `@social-media-scheduler/cli` inclui:

* O binário da CLI `so-me`
* `SKILL.md` — o corpo da skill do OpenClaw
* `tools.md` — catálogo gerado automaticamente das 205 ferramentas
* `examples/` — três transcrições de exemplo (`schedule-post.md`, `reply-dm.md`, `weekly-report.md`)

**3. Autentique**

Crie uma chave de API em [so-me.studio/settings?tab=api](https://so-me.studio/settings?tab=api) e exporte-a:

```bash theme={null}
export SOME_API_KEY=sk_live_...
```

O OpenClaw verifica a elegibilidade automaticamente. Confirme com:

```bash theme={null}
openclaw skills list --eligible | grep so-me-studio
```

Depois de pareado, você pode conversar com o agente pelo Discord, Slack, WhatsApp, Telegram ou qualquer um dos [22 mensageiros compatíveis](#converse-por-qualquer-mensageiro).

## Ou pelo ClawHub

A skill está publicada no ClawHub. Instale com um dos comandos canônicos:

```bash theme={null}
# OpenClaw-native (recommended)
openclaw skills install yasin047/so-me-studio

# ClawHub package-manager path
npx clawhub@latest install so-me-studio
```

Ambos baixam o mesmo pacote da skill. O mecanismo por trás é o `@social-media-scheduler/cli` no npm — o ClawHub indexa o pacote npm publicado.

Página da skill: [clawhub.ai/yasin047/so-me-studio](https://clawhub.ai/yasin047/so-me-studio)

## O que você pode pedir

Depois de instalar, escreva para o agente em linguagem natural:

| Pedido | O que acontece |
| - | - |
| *"Quais contas sociais eu tenho conectadas?"* | Chama `accounts:list` e resume por plataforma. |
| *"Schedule a tweet saying hello at 5pm tomorrow."* | Calcula o timestamp ISO e chama `posts:create`. |
| *"Responda essa DM com meu modelo salvo 'pricing'."* | Busca a resposta salva e chama `inbox:reply`. |
| *"Como foram meus posts no Twitter na semana passada?"* | Chama `analytics:platform` com `--days 7`. |
| *"Gere uma legenda de lançamento de produto para o LinkedIn na sexta-feira e agende."* | Chama `ai:generate-and-schedule` de ponta a ponta. |

O agente tem acesso a **todas as 205 ferramentas MCP do Social media studio** — toda ação disponível no painel está disponível aqui.

## Converse por qualquer mensageiro

O OpenClaw é compatível com **22 canais de mensagens** — envie mensagens diretas ao agente por qualquer um que você já use. Depois de pareado, todos os canais usam o mesmo agente e a mesma skill `so-me-studio`, então você recebe as mesmas respostas pelo Discord, WhatsApp ou Slack.

### Pré-requisito da primeira vez

Antes de adicionar qualquer canal, o OpenClaw precisa de uma configuração inicial em `~/.openclaw/openclaw.json`:

```bash theme={null}
openclaw onboard          # interactive — recommended
# or:  openclaw setup --non-interactive --accept-risk
```

Pular esta etapa faz o `openclaw gateway` falhar com `Missing config. Run openclaw setup or set gateway.mode=local`.

### O padrão (vale para qualquer canal)

```bash theme={null}
# 1. Get a credential from the platform you want to use
# 2. Wire it into OpenClaw
openclaw config set channels.<slug>.<field> <value>
openclaw config set channels.<slug>.enabled true --strict-json

# 3. Register the channel + run the gateway
openclaw channels add --channel <slug>
openclaw gateway
```

O comando `gateway` inicia um daemon local que escuta todos os canais ativados e encaminha as mensagens para as skills instaladas.

### Os 7 principais — configuração completa

**Discord**

**1. Crie um aplicativo do Discord**

1. Acesse [discord.com/developers/applications](https://discord.com/developers/applications) → **New Application**
2. Aba **Bot** → **Add Bot** → clique em "Copy" em TOKEN (mantenha em segredo)
3. Aba **Bot** → **INTENT SETTINGS** → ative **Message Content Intent** ⚠️ obrigatório
4. *(Opcional, para uso em servidor)* **OAuth2 → URL Generator** → escopo `bot`, permissões `Send Messages`, `Read Message History`, `Embed Links`, `Attach Files` → abra a URL para convidar o bot para um servidor. Para uso apenas por DM, pule esta etapa.

**2. Conecte o token ao OpenClaw**

```bash theme={null}
export DISCORD_BOT_TOKEN="your_bot_token_here"

openclaw config set channels.discord.token \
  --ref-provider default --ref-source env --ref-id DISCORD_BOT_TOKEN
openclaw config set channels.discord.enabled true --strict-json
```

**3. Registre o canal**

```bash theme={null}
openclaw channels add --channel discord
```

O assistente pede um identificador de conta — use o seu ID de usuário ou nome de usuário do Discord.

**4. Execute o gateway e faça um teste rápido**

```bash theme={null}
openclaw gateway
```

Depois, no Discord, envie uma DM ao seu bot:

> "List my connected social accounts"

A primeira mensagem gera um código de pareamento exibido no terminal do OpenClaw. Aprove com `openclaw admin pair-code <code>`.

**Slack**

**1. Crie um app do Slack**

1. Acesse [api.slack.com/apps](https://api.slack.com/apps) → **Create New App** → **From scratch** → escolha o seu workspace
2. **OAuth & Permissions** → adicione estes **Bot Token Scopes**:
   * `app_mentions:read`, `chat:write`, `channels:read`, `groups:read`, `im:read`
   * `channels:history`, `groups:history`, `im:history`, `mpim:history`
   * `files:read`, `files:write`
3. Aba **Socket Mode** → ative-o (recomendado — não precisa de URL pública de webhook)
4. **Basic Information** → gere um **App-Level Token** com o escopo `connections:write` (`xapp-…`)
5. **Install to Workspace** → copie o **Bot User OAuth Token** (`xoxb-…`)

**2. Conecte os tokens ao OpenClaw**

```bash theme={null}
export SLACK_BOT_TOKEN="xoxb-..."
export SLACK_APP_TOKEN="xapp-..."

openclaw config set channels.slack.botToken "$SLACK_BOT_TOKEN"
openclaw config set channels.slack.appToken "$SLACK_APP_TOKEN"
openclaw config set channels.slack.mode "socket"
openclaw config set channels.slack.enabled true --strict-json
```

**3. Registre o canal**

```bash theme={null}
openclaw channels add --channel slack
```

**4. Execute o gateway e faça um teste rápido**

```bash theme={null}
openclaw gateway
```

Envie uma DM ao seu bot do Slack:

> "List my connected social accounts"

Aprove o código de pareamento (mesmo fluxo do Discord).

**WhatsApp**

O WhatsApp usa o [Baileys](https://github.com/WhiskeySockets/Baileys) para o pareamento por QR code — você não precisa de uma conta da API do Meta Business, apenas de um celular com o WhatsApp instalado.

**1. Ative o canal**

```bash theme={null}
openclaw config set channels.whatsapp.enabled true --strict-json
```

**2. Registre e escaneie o QR code**

```bash theme={null}
openclaw channels add --channel whatsapp
```

O OpenClaw exibe um QR code no terminal. No seu celular:

1. Abra o WhatsApp → **Settings** → **Linked Devices** → **Link a Device**
2. Escaneie o QR code mostrado no seu terminal

Depois de pareado, a sua conta passa a ser a ponte do OpenClaw — as DMs que você enviar para si mesmo ou para contatos serão encaminhadas ao agente.

**3. Execute o gateway e faça um teste rápido**

```bash theme={null}
openclaw gateway
```

Envie uma DM para si mesmo ou peça a um amigo para enviar uma para você:

> "List my connected social accounts"

A primeira mensagem gera um pedido de código de pareamento no terminal. Aprove com `openclaw admin pair-code <code>`.

> [!TIP]
>
> A integração do Baileys com o WhatsApp roda em uma conta real — trate-a como uma sessão de celular pessoal. Não compartilhe a sessão do seu terminal e não execute várias instâncias do OpenClaw na mesma conta do WhatsApp.

**Telegram**

O Telegram é o canal **mais rápido** de configurar — apenas um token de bot, sem escopos, sem intents.

**1. Crie um bot com o @BotFather**

1. Abra o Telegram e envie uma mensagem para o [@BotFather](https://t.me/BotFather)
2. Envie `/newbot` e siga as instruções (nome + nome de usuário)
3. Copie o token do bot que o BotFather enviar (parecido com `1234567890:ABC...`)

**2. Conecte o token**

```bash theme={null}
export TELEGRAM_BOT_TOKEN="1234567890:ABC..."

openclaw config set channels.telegram.token \
  --ref-provider default --ref-source env --ref-id TELEGRAM_BOT_TOKEN
openclaw config set channels.telegram.enabled true --strict-json
```

**3. Registre o canal**

```bash theme={null}
openclaw channels add --channel telegram
```

**4. Execute o gateway e faça um teste rápido**

```bash theme={null}
openclaw gateway
```

Encontre o seu bot no Telegram (busque pelo nome de usuário que você definiu), toque em **Start** e envie:

> "List my connected social accounts"

Aprove o código de pareamento no terminal.

**iMessage**

O suporte ao iMessage exige um Mac rodando o [BlueBubbles Server](https://bluebubbles.app) — a Apple não expõe o iMessage em outras plataformas, então a única forma é fazer a ponte por um Mac que você controla.

**1. Instale o BlueBubbles Server no seu Mac**

1. Baixe em [bluebubbles.app](https://bluebubbles.app) e siga o instalador
2. Entre com o Apple ID associado ao iMessage nesse Mac
3. Nas configurações do BlueBubbles Server, copie a **URL do servidor** (por exemplo, `http://192.168.1.20:1234`) e a **senha**

**2. Conecte o BlueBubbles ao OpenClaw**

```bash theme={null}
export BLUEBUBBLES_SERVER_URL="http://192.168.1.20:1234"
export BLUEBUBBLES_PASSWORD="your-bluebubbles-password"

openclaw config set channels.bluebubbles.serverUrl "$BLUEBUBBLES_SERVER_URL"
openclaw config set channels.bluebubbles.password "$BLUEBUBBLES_PASSWORD"
openclaw config set channels.bluebubbles.enabled true --strict-json
```

**3. Registre o canal**

```bash theme={null}
openclaw channels add --channel bluebubbles
```

**4. Execute o gateway e faça um teste rápido**

```bash theme={null}
openclaw gateway
```

Envie um iMessage para si mesmo ou para outro contato:

> "List my connected social accounts"

Aprove o código de pareamento no terminal.

> [!NOTE]
>
> O Mac que roda o BlueBubbles precisa ficar ativo e com a sessão iniciada para o roteamento do iMessage funcionar. O slug de canal legado `imessage` está **obsoleto** — use `bluebubbles`.

**MS Teams**

O Microsoft Teams usa o [Bot Framework](https://dev.botframework.com/) — registre o seu bot uma vez e depois conecte o Teams como canal.

**1. Registre um recurso Azure Bot**

1. No [Azure Portal](https://portal.azure.com/), crie um novo recurso **Azure Bot**
2. Anote o **Microsoft App ID** e crie um novo **client secret** em **Certificates & secrets**
3. Em **Channels**, adicione o **Microsoft Teams** como canal ativado
4. Em **Configuration**, defina o endpoint de mensagens — para o gateway do OpenClaw, use a URL pública da sua instância local exposta por túnel (por exemplo, com o [ngrok](https://ngrok.com): `https://abc.ngrok.io/teams/messages`)

**2. Conecte as credenciais ao OpenClaw**

```bash theme={null}
export MSTEAMS_APP_ID="<your-app-id>"
export MSTEAMS_APP_PASSWORD="<your-client-secret>"

openclaw config set channels.msteams.appId "$MSTEAMS_APP_ID"
openclaw config set channels.msteams.appPassword "$MSTEAMS_APP_PASSWORD"
openclaw config set channels.msteams.enabled true --strict-json
```

**3. Registre e execute**

```bash theme={null}
openclaw channels add --channel msteams
openclaw gateway
```

**4. Adicione o bot a um chat do Teams**

No seu cliente do Teams, busque o bot pelo nome e inicie um chat 1:1. Envie:

> "List my connected social accounts"

Aprove o código de pareamento no terminal.

> [!TIP]
>
> O Microsoft Teams exige um endpoint HTTPS acessível publicamente. Em desenvolvimento, use o ngrok ou o Cloudflare Tunnel; em produção, hospede o gateway atrás de uma URL estável.

**Google Chat**

O Google Chat usa um webhook HTTP — sem OAuth, apenas uma URL de webhook.

**1. Crie um app do Google Chat**

1. No [Google Cloud Console](https://console.cloud.google.com), ative a **Google Chat API**
2. Vá em **Google Chat API → Configuration** e defina:
   * Nome do app + avatar
   * **Connection settings** → HTTP endpoint → cole a URL pública do gateway do OpenClaw (por exemplo, `https://abc.ngrok.io/googlechat/messages`)
   * **Visibility** → disponibilize para a sua organização ou para usuários específicos

**2. Conecte o segredo do webhook ao OpenClaw**

```bash theme={null}
export GOOGLECHAT_WEBHOOK_SECRET="<your-shared-secret>"

openclaw config set channels.googlechat.webhookSecret "$GOOGLECHAT_WEBHOOK_SECRET"
openclaw config set channels.googlechat.enabled true --strict-json
```

**3. Registre e execute**

```bash theme={null}
openclaw channels add --channel googlechat
openclaw gateway
```

**4. Envie uma DM ao bot pelo Google Chat**

No Google Chat, encontre o seu app em **Apps** e inicie uma mensagem direta:

> "List my connected social accounts"

Aprove o código de pareamento no terminal.

> [!NOTE]
>
> **Por que não há WebChat?** Tutoriais antigos do OpenClaw citavam um canal `webchat` — ele não é um canal real voltado ao usuário na CLI atual (é uma constante interna de roteamento). `openclaw channels add --channel webchat` retorna `unknown channel id: webchat`. Para um teste rápido, sem precisar de conta, use o **Telegram** acima (cerca de 1 minuto pelo [@BotFather](https://t.me/BotFather)).

### Mais 15 canais (+ 1 em breve)

> **Canais de cauda longa (indicações de configuração em uma linha)**
>
> | Canal | Slug | Configuração |
> | - | - | - |
> | Feishu / Lark | `feishu` | Bot por WebSocket — [docs](https://docs.openclaw.ai/channels/feishu) |
> | LINE | `line` | Credenciais de bot da Messaging API — [docs](https://docs.openclaw.ai/channels/line) |
> | Matrix | `matrix` | URL do homeserver + token de acesso — [docs](https://docs.openclaw.ai/channels/matrix) |
> | Mattermost | `mattermost` | Bot API + WebSocket — [docs](https://docs.openclaw.ai/channels/mattermost) |
> | Nextcloud Talk | `nextcloud-talk` | Nextcloud auto-hospedado — [docs](https://docs.openclaw.ai/channels/nextcloud-talk) |
> | Signal | `signal` | Pareamento via `signal-cli` — [docs](https://docs.openclaw.ai/channels/signal) |
> | Twitch | `twitch` | Ponte IRC — [docs](https://docs.openclaw.ai/channels/twitch) |
> | Zalo | `zalo` | Bot API — [docs](https://docs.openclaw.ai/channels/zalo) |
> | Zalo Personal | `zalouser` | Login por QR — [docs](https://docs.openclaw.ai/channels/zalouser) |
> | Tlon | `tlon` | Conta baseada em Urbit — [docs](https://docs.openclaw.ai/channels/tlon) |
> | QQ | `qqbot` | Tencent QQ Bot API — [docs](https://docs.openclaw.ai/channels/qqbot) |
> | Nostr | `nostr` | DMs NIP-04 — [docs](https://docs.openclaw.ai/channels/nostr) |
> | IRC | `irc` | Endereço do servidor + pareamento — [docs](https://docs.openclaw.ai/channels/irc) |
> | Synology Chat | `synology-chat` | Webhook do NAS — [docs](https://docs.openclaw.ai/channels/synology-chat) |
> | iMessage (legado) | `imessage` | **Obsoleto** — use `bluebubbles` no lugar |
> | WeChat | `wechat` | 🚧 **Não está na CLI atual** — consta no README do OpenClaw, mas `openclaw channels add --channel wechat` retorna `Unknown channel`. Acompanhe o suporte no [repositório do OpenClaw](https://github.com/openclaw/openclaw). |

### O que você pode pedir depois do pareamento

Os mesmos pedidos funcionam em todos os canais:

* *"Quais contas sociais eu tenho conectadas?"*
* *"Agende um tweet 'launching today' para amanhã às 9h UTC."*
* *"Gere uma legenda de lançamento de produto para o LinkedIn na sexta-feira e agende para as 17h."*
* *"Como foram meus posts no Twitter na semana passada?"*
* *"Responda essa DM com meu modelo salvo 'pricing'."*

Veja a lista completa de pedidos em [O que você pode pedir](#o-que-você-pode-pedir).

### Solução de problemas geral

* **`Missing config` no `openclaw gateway`:** você pulou o pré-requisito — execute `openclaw onboard` (ou `openclaw setup --non-interactive --accept-risk`) antes de adicionar qualquer canal.
* **O bot não responde de jeito nenhum:** confirme que o `openclaw gateway` está em execução. Ele é o daemon que escuta todos os canais — se não estiver rodando, nenhuma mensagem passa.
* **Primeira mensagem travada:** o OpenClaw exige pareamento no primeiro uso. A primeira DM gera um código exibido no terminal; aprove com `openclaw admin pair-code <code>`.
* **Específico do Discord:** o *Message Content Intent* precisa estar ativado no portal do desenvolvedor, senão o bot não consegue ler DMs.
* **Específico do Slack:** faltam escopos OAuth (`im:history`, `im:read`, `chat:write`); reinstale o app no seu workspace depois de adicionar os escopos.
* **Skill não elegível:** `openclaw skills list --eligible` deve incluir `so-me-studio`. Se não incluir, a `SOME_API_KEY` não está visível para o shell do gateway — exporte-a no mesmo terminal em que você executa o `openclaw gateway`.
* **Nem todos os canais funcionam ao mesmo tempo:** cada canal tem a própria flag `enabled`; confira o status com `openclaw channels status`.
* **MS Teams ou Google Chat inacessíveis:** eles exigem um endpoint HTTPS público para o gateway do OpenClaw. Use o [ngrok](https://ngrok.com) ou o Cloudflare Tunnel durante o desenvolvimento.

## Como funciona

```
┌──────────────────┐
│  OpenClaw agent  │
└────────┬─────────┘
         │ reads SKILL.md from @social-media-scheduler/cli's npm install
         ▼
┌──────────────────┐
│  SKILL.md +      │
│  tools.md +      │
│  examples/       │
└────────┬─────────┘
         │ invokes
         ▼
┌──────────────────┐         ┌────────────────────────┐
│  CLI (so-me)     │ ──────► │  api.so-me.studio/v1   │
└──────────────────┘         └────────────────────────┘
```

O corpo da skill (`SKILL.md`) é uma extensão do prompt de sistema que ensina o agente a usar a CLI `so-me`. A CLI retorna JSON estruturado em cada operação, para que o agente consiga interpretar, raciocinar e encadear chamadas.

## Regras rígidas incorporadas à skill

* Nunca inventar IDs de conta / publicação / conversa — sempre buscá-los primeiro.
* `scheduledAt` é ISO 8601 em UTC e estritamente no futuro.
* Tarefas de várias etapas (por exemplo, imagem com IA → publicação) são encadeadas em sequência.
* Nunca revelar chaves de API ou segredos de webhook, mesmo quando pedido.

## Atualizações

Quando novas ferramentas chegam ao Social media studio, o SKILL.md e o `tools.md` são regenerados e o `@social-media-scheduler/cli` é republicado. Os usuários executam `npm install -g @social-media-scheduler/cli` novamente para obter a versão mais recente.

## Código-fonte

O código-fonte da skill fica no monorepo do Social media studio, em [`apps/cli/SKILL.md`](https://github.com/7t1-studio/schedular-app/blob/main/apps/cli/SKILL.md). Pull requests são bem-vindos.

## Outros agentes?

Se você usa outro runtime de agente:

* **Hermes 4** — veja a [integração com o Hermes](/pt-BR/integrations/hermes.md), que usa o mesmo backend MCP via `npm install -g @so-me/hermes-agent`.
* **Claude Desktop / Cursor / OpenCode** — aponte-os diretamente para o nosso [servidor MCP](/pt-BR/mcp/overview.md). Não precisa de skill nem de runtime.
* **Qualquer outro (LangGraph, CrewAI, OpenAI Assistants, Anthropic API)** — gere um arquivo de definição de ferramentas no formato preferido deles:
  ```bash theme={null}
  so-me agent export-tools --format openai --out tools.openai.json
  so-me agent export-tools --format anthropic --out tools.anthropic.json
  so-me agent export-tools --format mcp --out tools.mcp.json
  ```


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