Programa do celular com OpenCode: guia passo a passo a partir de um VPS

E se você pudesse deixar a sua IA trabalhando enquanto está na rua, sem notebook e sem depender de estar em casa? Parece papo furado, mas não é. Dá sim para rodar OpenCode num VPS, acessar do celular por uma interface web decente e deixar tudo funcionando 24/7 sem pagar assinatura extra só por causa de app móvel.

E tem duas armadilhas que eu já quero te poupar de cara: usar só terminal no celular é sofrido e um VPS muito fraco fica curto rapidinho. Eu testei com um servidor de 2 GB de RAM e até funciona para fuçar, mas no momento em que você pede várias coisas ao mesmo tempo, começa o lag, o CPU dispara e a experiência deixa de ser agradável.

Então neste post a gente vai fazer do jeito certo: com interface web, configuração sincronizada, sem expor portas na internet e com o serviço continuando de pé mesmo depois que você fecha a sessão SSH.

O que vamos montar exatamente

A ideia é bem simples:

OpenCode instalado num VPS para o trabalho pesado acontecer na nuvem.
Interface web do OpenCode para você usar do celular sem sofrer com terminal em tela pequena.
Sincronização de configuração entre o seu computador e o servidor para não duplicar ajustes, modelos e plugins.
Tailscale para acesso privado, sem abrir portas para a internet.
systemd para o OpenCode continuar rodando mesmo que você feche o SSH ou reinicie o servidor.

O resultado final é uma URL privada do tipo http://seu-hostname-tailscale:4096 que só funciona dentro da sua rede Tailscale. Você abre no navegador do celular e pronto.

O que você precisa antes de começar

Antes de mexer em qualquer coisa, deixa isto preparado:

Um VPS com Linux. Se puder, vá de 4 GB de RAM ou mais. Com 2 GB ele pode até iniciar, mas eu não chamaria isso de um setup bom para trabalhar a sério com agentes.
Seu computador principal com OpenCode já configurado, se quiser aproveitar a sincronização.
Uma conta no GitHub para o plugin de sync.
Uma conta no Tailscale para colocar o celular e o servidor na mesma rede privada.
O app do Tailscale no celular.

Se você ainda não tem servidor, aqui vão dois posts do blog que encaixam perfeito:

Dica: se o orçamento estiver apertado, economize em disco antes de economizar em RAM. Para usar OpenCode com conforto no celular, o primeiro gargalo vai ser a memória.

Passo 1: Instale o OpenCode no VPS

Primeiro, instale o OpenCode no servidor.

curl -fsSL https://opencode.ai/install | bash

Quando terminar, confira onde o binário foi parar:

which opencode

Deve devolver algo parecido com isto:

/root/.opencode/bin/opencode

Guarde esse caminho porque vamos usá-lo depois no serviço do systemd.

Atenção: na gravação teve um detalhe importante. Logo depois da instalação, which opencode não devolvia o caminho certo até fechar a sessão SSH e entrar outra vez. Se acontecer com você, não complica: reconecta e testa de novo.

Se quiser também verificar se o comando responde:

opencode --version

Passo 2: Prepare a sincronização da configuração

Esta é uma das partes mais úteis e menos explicadas. Se você já usa OpenCode no computador, não faz sentido configurar modelos, provedores e preferências tudo de novo no VPS.

A ideia é usar o plugin de sincronização para que a sua configuração viva num repositório privado do GitHub e você possa ligá-la a qualquer máquina.

2.1 Instale o GitHub CLI no VPS

No Ubuntu ou Debian dá para fazer assim:

sudo apt update
sudo apt install -y gh

Depois faça login:

gh auth login

Escolha GitHub.com, HTTPS e o método de autenticação que você preferir. No vídeo isso é feito com token pessoal, o que funciona muito bem se você quer deixar o VPS pronto com acesso completo aos seus repositórios.

2.2 Ative o plugin de sync no OpenCode

No VPS, crie ou edite este arquivo:

mkdir -p ~/.config/opencode
nano ~/.config/opencode/opencode.json

Cole isto:

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["opencode-synced"]
}

Agora abra o OpenCode uma vez para ele gerar os arquivos e detectar o plugin:

opencode

Saia quando ele terminar de inicializar e pronto.

2.3 Ative o mesmo plugin no seu computador principal

Faça exatamente a mesma coisa na sua máquina principal: abra o arquivo global do OpenCode e adicione o plugin opencode-synced.

Se o arquivo não existir, crie. A estrutura é a mesma:

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["opencode-synced"]
}

2.4 Inicialize a sincronização a partir do seu computador principal

É aqui que faz sentido criar o repositório privado, porque é no seu computador principal que a configuração boa já existe.

Abra o OpenCode na sua máquina principal e rode o comando de sync. Dependendo da versão ou do plugin, ele pode aparecer como comando com slash ou como comando normal. Se você digitar sync dentro do OpenCode, o próprio cliente deve sugerir o nome certo.

O mais comum é usar uma destas formas:

/sync-init meu-opencode-config

ou:

sync init meu-opencode-config

Isso vai criar um repositório privado no GitHub com a sua configuração.

Depois envie as alterações iniciais:

/sync-push

ou:

sync push

2.5 Ligue o VPS a esse repositório

Agora volte ao VPS, abra o OpenCode e ligue a configuração remota:

/sync-link

ou:

sync link

Se correr tudo bem, o VPS puxa a sua configuração e você não precisa repetir provedores, modelos nem ajustes.

Nota importante: na transcrição dá para ver que o plugin até sugere inicializar segredos depois da ligação. Leia isso com calma antes de aceitar tudo no automático. Sincronizar configuração faz sentido. Sincronizar segredos e sessões já depende muito de como você trabalha.

Passo 3: Instale o Tailscale e coloque o VPS na sua rede privada

Agora vem a parte crítica de segurança. Nada de abrir portas na internet para expor o OpenCode. O que a gente quer é que o serviço exista só dentro da sua rede privada.

Instale o Tailscale:

curl -fsSL https://tailscale.com/install.sh | sh

E suba o serviço:

sudo tailscale up

Ele vai devolver uma URL para você iniciar sessão. Abra, autentique e o servidor passa a fazer parte da sua rede Tailscale.

No celular, faça o mesmo pela app oficial do Tailscale. Instale no iPhone ou Android, entre com a mesma conta que usou no VPS e deixe a ligação ativa. Não tem segredo, mas é importante que ambos os dispositivos fiquem dentro da mesma rede privada para que depois a interface web do OpenCode responda sem expor nada para fora.

Agora pegue o hostname Tailscale do servidor:

tailscale status --json 2>/dev/null | grep -o '"DNSName": "[^"]*"' | head -1

Deve devolver algo parecido com isto:

"DNSName": "meu-vps.tailxxxxx.ts.net."

Copie isso porque daqui a pouco vamos usar no navegador do celular.

Por que isso importa tanto: com Tailscale você não expõe a porta 4096 à internet pública. Só dispositivos autenticados dentro da mesma rede privada conseguem chegar ao OpenCode.

Passo 4: Deixe o OpenCode em modo web e rodando 24/7

É aqui que a gente sai da demo e entra em algo realmente útil. Vamos executá-lo como serviço de utilizador com systemd para que continue de pé mesmo depois de fechar a sessão SSH.

4.1 Crie a pasta de serviços do utilizador

mkdir -p ~/.config/systemd/user

4.2 Crie o arquivo do serviço

nano ~/.config/systemd/user/opencode-web.service

Cole isto dentro e troque o caminho de ExecStart pelo que which opencode devolveu:

[Unit]
Description=OpenCode Web Server
After=network.target

[Service]
Type=simple
WorkingDirectory=%h
ExecStart=/CAMINHO/REAL/PARA/opencode web --port 4096 --hostname 0.0.0.0
Restart=on-failure
RestartSec=5
Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin

[Install]
WantedBy=default.target

Detalhes importantes:

ExecStart tem de usar o seu caminho real, não o meu nem o do exemplo.
--port 4096 você pode mudar, mas use uma porta livre.
--hostname 0.0.0.0 é necessário para que o serviço fique acessível via Tailscale.
Restart=on-failure faz com que ele volte a subir se cair.

4.3 Ative o linger do seu utilizador

Este passo é obrigatório se você quer que o serviço continue vivo depois de fechar o SSH:

loginctl enable-linger $USER

Sem isso, você fecha a sessão e o Linux mata os processos do utilizador. Aí todo o setup perde o sentido.

4.4 Recarregue, habilite e inicie o serviço

systemctl --user daemon-reload
systemctl --user enable opencode-web
systemctl --user start opencode-web

4.5 Verifique se está rodando

systemctl --user status opencode-web

Você deve ver algo como:

Active: active (running)

E para confirmar que a interface realmente responde:

curl -s http://localhost:4096/global/health

Se tudo correu bem, deve devolver:

{"healthy":true}

Passo 5: Adicione utilizador e senha se quiser uma camada extra

O Tailscale já protege bastante, mas se você é do tipo que dorme mais tranquilo com mais uma fechadura na porta, dá para ativar autenticação básica na interface web.

Edite o serviço novamente:

nano ~/.config/systemd/user/opencode-web.service

Dentro de [Service], adicione estas linhas:

Environment=OPENCODE_SERVER_USERNAME=seuusuario
Environment=OPENCODE_SERVER_PASSWORD=suasenha

Depois recarregue e reinicie:

systemctl --user daemon-reload
systemctl --user restart opencode-web

Na próxima vez que abrir a interface web, ela vai pedir utilizador e senha.

Minha opinião: se o celular é um dispositivo que anda com você para todo lado, essa camada extra faz todo o sentido.

Passo 6: Acesse pelo celular

Com o Tailscale ativo no celular, abra o navegador e entre em:

http://SEU_HOSTNAME_TAILSCALE:4096

Por exemplo:

http://meu-vps.tailxxxxx.ts.net:4096

E pronto, você já tem a interface web do OpenCode no celular.

Se configurou utilizador e senha, ele vai pedir. Se não, você entra direto desde que continue ligado ao Tailscale.

O ponto importante aqui é este: essa URL não está exposta ao mundo. Ela só funciona dentro da sua rede privada Tailscale, então ninguém de fora vai entrar por acaso.

Problemas comuns e as coisas que ninguém te conta

1. Um VPS com 2 GB de RAM pode ficar curto

Isto não é teoria. Se você começar a pedir várias tarefas ou usar modelos mais pesados, o servidor engasga. A minha recomendação é simples: se quer algo realmente útil, vá de 4 GB ou mais.

2. Programar a partir de um terminal no celular é tortura

Dá para fazer? Dá. Mas no momento em que você quer revisar mudanças, ler diffs ou navegar pelos arquivos, vira sofrimento. Por isso a interface web é a peça-chave deste setup.

3. Se `which opencode` não devolver nada, reconecte por SSH

Acontece às vezes logo depois da instalação. Feche a sessão, entre de novo e teste outra vez.

4. O plugin de sync vale a pena, mas revise o que sincroniza

Sincronizar configuração é ótimo. Sincronizar segredos já depende do seu nível de paranoia, se você compartilha máquinas e de quão limpo quer manter cada ambiente.

5. `loginctl enable-linger $USER` não é opcional

Se você pular isso, fecha o SSH, o processo morre e começa a achar que o systemd te odeia. Não odeia. O problema é esse comando que faltou.

O lado bom de ter isto montado

Quando isso começa a funcionar, é aí que a parte interessante aparece. Não é só a graça de abrir do celular, mas a liberdade de pedir mudanças rápidas num projeto, revisar implementações quando você está fora, lançar um commit pequeno ou até ligar MCPs para fazer deploy e inspecionar ambientes sem depender sempre do notebook. E se uma tarefa vai demorar, você deixa rodando na nuvem enquanto faz outra coisa.

No vídeo tem um caso que eu gosto especialmente: ligar um MCP do Coolify para conseguir fazer deploy para um ambiente de staging a partir do celular e validar se o que foi mudado realmente funciona. Para tarefas mais longas ou delicadas, eu continuo preferindo o computador, claro. Mas para mudanças pequenas, acompanhamento ou validação rápida, isso abre muitas possibilidades.

Se você ainda não domina MCP, fica também este recurso do blog:

O que são servidores MCP e por que eles importam?

Todos os comandos do tutorial juntos, prontos para copiar

Aqui vai a cola rápida na ordem lógica:

# Instalar OpenCode
curl -fsSL https://opencode.ai/install | bash
which opencode
opencode --version

# Instalar GitHub CLI para sincronização
sudo apt update
sudo apt install -y gh
gh auth login

# Criar config global do OpenCode com o plugin de sync
mkdir -p ~/.config/opencode
nano ~/.config/opencode/opencode.json
opencode

# Instalar Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
tailscale status --json 2>/dev/null | grep -o '"DNSName": "[^"]*"' | head -1

# Criar serviço de utilizador para o OpenCode Web
mkdir -p ~/.config/systemd/user
nano ~/.config/systemd/user/opencode-web.service
loginctl enable-linger $USER
systemctl --user daemon-reload
systemctl --user enable opencode-web
systemctl --user start opencode-web
systemctl --user status opencode-web
curl -s http://localhost:4096/global/health

# Opcional: depois de adicionar utilizador/senha ao serviço
systemctl --user daemon-reload
systemctl --user restart opencode-web

E dentro do OpenCode, dependendo da versão do plugin:

/sync-init meu-opencode-config
/sync-push
/sync-link

ou:

sync init meu-opencode-config
sync push
sync link

Conclusão

Sinceramente, este é daqueles setups que à primeira vista parecem capricho e depois você percebe que fazem muito sentido. Não porque agora vai programar sempre da praia como num anúncio, mas porque isso te dá liberdade real: você pode revisar coisas, lançar tarefas e manter projetos andando sem depender sempre de ter o notebook à frente.

E se fizer isso com OpenCode, um VPS decente, Tailscale e systemd, o resultado fica muito redondo: seguro, privado, sincronizado e sempre ligado.

Se você quiser, num próximo post eu posso trazer uma versão mais avançada com hardening extra do servidor, firewall, SSH com chaves e um fluxo mais sério de deploy com MCP.

O que você achou?

Deixe sua opinião, pergunta ou sugestão. Os comentários são sincronizados com GitHub Discussions .