Programa desde el móvil con OpenCode: guía paso a paso desde un VPS

¿Y si pudieras dejar a tu IA programando mientras tu estas por ahi, sin portatil y sin depender de estar en casa? Pues no, no es humo. Se puede montar OpenCode en un VPS, acceder desde el movil con una interfaz web decente y tenerlo funcionando las 24 horas sin pagar una suscripcion extra solo por la app movil.

Y ojo, aqui hay dos trampas que quiero ahorrarte desde ya: usar solo terminal en el movil es un dolor y un VPS demasiado justo se te puede quedar corto enseguida. Yo probe con uno de 2 GB de RAM y para trastear vale, pero en cuanto le pides varias cosas a la vez empieza el lag, sube el consumo de CPU y la experiencia deja de ser agradable.

Asi que en este post vamos a hacerlo bien: con interfaz web, sincronizando tu configuracion habitual, sin exponer puertos a internet y dejando el servicio corriendo aunque cierres la sesion SSH.

Lo que vamos a montar exactamente

La idea es muy simple:

OpenCode instalado en un VPS para que haga el trabajo pesado.
Interfaz web de OpenCode para entrar desde el movil sin sufrir con una terminal en una pantalla pequena.
Sincronizacion de configuracion entre tu ordenador y el servidor para no duplicar ajustes, modelos y plugins.
Tailscale para acceder de forma privada, sin abrir puertos al mundo.
systemd para que OpenCode siga vivo aunque cierres SSH o reinicies el servidor.

El resultado final es una URL privada tipo http://tu-hostname-tailscale:4096 que solo funciona dentro de tu red Tailscale. Abres el navegador en el movil, entras y listo.

Que necesitas antes de empezar

Antes de tocar nada, prepara esto:

Un VPS con Linux. Si puedes, vete a 4 GB de RAM o mas. Con 2 GB puede arrancar, pero no es la experiencia que yo recomendaria para trabajar en serio con agentes.
Tu ordenador habitual con OpenCode ya configurado, si quieres aprovechar la sincronizacion.
Una cuenta de GitHub para el plugin de sync.
Una cuenta de Tailscale para conectar movil y servidor dentro de la misma red privada.
La app de Tailscale en el movil.

Si aun no tienes servidor, te dejo dos recursos del blog que te vienen de lujo:

Consejo: si vas justo de presupuesto, mejor recortar en disco antes que en RAM. Para usar OpenCode de forma comoda desde movil, la RAM te va a doler antes.

Paso 1: Instala OpenCode en el VPS

Lo primero es instalar OpenCode en el servidor.

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

Cuando termine, comprueba donde ha quedado el binario:

which opencode

Deberia devolverte algo parecido a esto:

/root/.opencode/bin/opencode

Guardate esa ruta porque la vamos a usar luego en el servicio de systemd.

Ojo: en la grabacion hubo un detalle importante. Justo despues de instalar, which opencode no devolvia bien la ruta hasta cerrar sesion SSH y volver a entrar. Si te pasa, no te rayes: reconecta y prueba otra vez.

Si quieres verificar tambien que el comando responde:

opencode --version

Paso 2: Prepara la sincronizacion de tu configuracion

Esta parte es de las mas utiles y de las menos explicadas. Si ya usas OpenCode en tu ordenador, no tiene sentido volver a configurar modelos, proveedores y preferencias desde cero en el VPS.

La idea es usar el plugin de sincronizacion para que tu configuracion viva en un repo privado de GitHub y puedas enlazarla desde cualquier maquina.

2.1 Instala GitHub CLI en el VPS

En Ubuntu o Debian puedes hacerlo asi:

sudo apt update
sudo apt install -y gh

Luego inicia sesion:

gh auth login

Escoge GitHub.com, HTTPS y el metodo de autenticacion que prefieras. En el video se hace con token personal, que va perfecto si quieres dejar el VPS listo con acceso completo a tus repositorios.

2.2 Activa el plugin de sync en OpenCode

En el VPS crea o edita este archivo:

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

Y pega esto:

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

Ahora abre OpenCode una vez para que genere sus archivos y detecte el plugin:

opencode

Sales cuando termine de inicializar y listo.

2.3 Activa el mismo plugin en tu ordenador principal

Haz exactamente lo mismo en tu equipo principal: abre tu archivo global de OpenCode y anade el plugin opencode-synced.

Si no tienes el archivo, crealo. La estructura es la misma:

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

2.4 Inicializa la sincronizacion desde tu ordenador principal

Aqui es donde tiene sentido crear el repositorio privado, porque en tu ordenador es donde ya tienes la configuracion buena.

Abre OpenCode en tu equipo principal y lanza el comando de sync. Segun la version o el plugin, puede aparecerte como comando con slash o como comando normal. Si escribes sync en OpenCode, el propio cliente te sugerira el nombre correcto.

Lo habitual es usar una de estas formas:

/sync-init mi-opencode-config

sync init mi-opencode-config

Esto te creara un repositorio privado en GitHub con tu configuracion.

Despues sube los cambios iniciales:

/sync-push

sync push

2.5 Enlaza el VPS con ese repositorio

Ahora vuelves al VPS, abres OpenCode y enlazas la configuracion remota:

/sync-link

sync link

Si todo va bien, el VPS se trae tu configuracion y ya no tienes que repetir proveedores, modelos ni ajustes.

Nota importante: en la transcripcion se ve que el plugin incluso propone inicializar secretos despues del enlace. Revisa con calma que realmente quieres sincronizar antes de aceptarlo todo a ciegas. Configuracion si, pero secretos y sesiones depende mucho de como trabajes.

Paso 3: Instala Tailscale y mete el VPS en tu red privada

Ahora viene la parte critica de seguridad. Nada de abrir puertos a internet para exponer OpenCode. Lo que queremos es que el servicio solo exista dentro de tu red privada.

Instala Tailscale:

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

Y levantalo:

sudo tailscale up

Te devolvera una URL para iniciar sesion. La abres, autenticas y el servidor ya queda unido a tu red Tailscale.

En el movil repites la jugada desde la app oficial de Tailscale. La instalas en iPhone o Android, entras con la misma cuenta que has usado en el VPS y dejas la conexion activa. No tiene mas misterio, pero es importante que ambos queden dentro de la misma red privada para que luego la web de OpenCode responda sin exponer nada hacia fuera.

Y ahora saca el hostname Tailscale del servidor:

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

Te devolvera algo parecido a esto:

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

Copialo porque en un rato lo usaremos desde el navegador del movil.

Por que esto importa tanto: con Tailscale no expones el puerto 4096 al publico. Solo tus dispositivos autenticados dentro de la misma red privada pueden alcanzar OpenCode.

Paso 4: Deja OpenCode en modo web y funcionando 24/7

Aqui es donde pasamos de la demo a algo util de verdad. Lo vamos a ejecutar como servicio de usuario con systemd para que siga levantado aunque cierres la sesion SSH.

4.1 Crea la carpeta de servicios de usuario

mkdir -p ~/.config/systemd/user

4.2 Crea el fichero del servicio

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

Pega esto dentro y cambia la ruta de ExecStart por la que te devolvio which opencode:

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

[Service]
Type=simple
WorkingDirectory=%h
ExecStart=/RUTA/REAL/A/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

Detalles importantes:

ExecStart tiene que usar tu ruta real, no la mia ni la del ejemplo.
--port 4096 lo puedes cambiar, pero usa uno libre.
--hostname 0.0.0.0 hace falta para que el servicio sea accesible desde Tailscale.
Restart=on-failure hace que vuelva a levantarse si se cae.

4.3 Activa el linger de tu usuario

Este paso es obligatorio si quieres que el servicio siga vivo al cerrar SSH:

loginctl enable-linger $USER

Sin esto, cierras sesion y Linux se lleva por delante tus procesos de usuario. Y entonces todo este montaje no sirve de nada.

4.4 Recarga, habilita e inicia el servicio

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

4.5 Verifica que esta corriendo

systemctl --user status opencode-web

Deberias ver algo como:

Active: active (running)

Y para comprobar que la interfaz responde realmente:

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

Si todo ha ido bien, deberia devolverte:

{"healthy":true}

Paso 5: Anade usuario y contrasena si quieres una capa extra

Tailscale ya protege bastante, pero si eres de los que prefieren dormir aun mas tranquilos, puedes poner autenticacion basica en la interfaz web.

Vuelve a editar el servicio:

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

Y dentro de [Service] anade estas lineas:

Environment=OPENCODE_SERVER_USERNAME=tuusuario
Environment=OPENCODE_SERVER_PASSWORD=tucontrasena

Luego recarga e reinicia:

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

La proxima vez que abras la web te pedira usuario y contrasena.

Mi opinion: si el movil es un dispositivo que sacas mucho de casa, esta capa extra tiene todo el sentido del mundo.

Paso 6: Entra desde el movil

Con Tailscale activo en el movil, abre el navegador y entra en:

http://TU_HOSTNAME_TAILSCALE:4096

Por ejemplo:

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

Y listo, ya tienes la interfaz web de OpenCode en el movil.

Si has configurado usuario y contrasena, te los pedira. Si no, entraras directo mientras sigas conectado a Tailscale.

Lo importante aqui es esto: esa URL no esta expuesta al mundo. Solo funciona dentro de tu red privada Tailscale, asi que nadie desde fuera puede entrar por casualidad.

Problemas habituales y cosas que no te cuentan

1. Un VPS de 2 GB de RAM se puede quedar corto

Esto no es teoria. Si le empiezas a pedir varias tareas o usas modelos mas pesados, el servidor se atraganta. Mi recomendacion es clara: si quieres algo realmente util, sube a 4 GB o mas.

2. Programar desde una terminal en movil es una tortura

Se puede hacer, si. Pero en cuanto quieres revisar cambios, leer diffs o moverte por archivos, se vuelve incomodisimo. Por eso la interfaz web es la clave de todo este montaje.

3. Si `which opencode` no devuelve nada, reconecta por SSH

Pasa a veces justo despues de instalar. Cierra sesion, vuelve a entrar y prueba otra vez.

4. El plugin de sync merece la pena, pero revisa lo que sincronizas

Sincronizar configuracion es una maravilla. Sincronizar secretos ya depende de tu nivel de paranoia, de si compartes maquinas y de como de limpio quieres tener cada entorno.

5. `loginctl enable-linger $USER` no es opcional

Si te saltas este paso, luego cierras SSH, el proceso muere y empiezas a pensar que systemd te odia. No. El problema es ese comando que faltaba.

Lo bueno de tener esto montado

Una vez lo tienes funcionando, empiezan las cosas interesantes. Ya no es solo la gracia de entrar desde el movil, sino la libertad de poder pedir cambios rapidos al proyecto, revisar implementaciones cuando estas fuera, lanzar algun commit sencillo o incluso conectar MCPs para desplegar y revisar entornos sin depender siempre del portatil. Y si hay una tarea que va para largo, la dejas corriendo en la nube mientras tu sigues con otra cosa.

En el video se menciona un caso que me parece especialmente bueno: conectar un MCP de Coolify para poder desplegar desde el propio movil a un entorno previo y validar si lo que ha tocado funciona. Para tareas largas o mas delicadas, obviamente sigo prefiriendo el ordenador. Pero para cambios pequenos, seguimiento o validacion rapida, esto abre muchisimas posibilidades.

Si no controlas aun el tema MCP, te dejo tambien este recurso del blog:

Que son los servidores MCP y por que importan

Comandos del tutorial juntos, por si quieres copiar y pegar

Te dejo aqui la chuleta rapida en el orden logico:

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

# Instalar GitHub CLI para la sincronizacion
sudo apt update
sudo apt install -y gh
gh auth login

# Crear config global de OpenCode con 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

# Crear servicio de usuario para 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: tras anadir usuario/contrasena al servicio
systemctl --user daemon-reload
systemctl --user restart opencode-web

Y dentro de OpenCode, segun la version del plugin:

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

sync init mi-opencode-config
sync push
sync link

Conclusion

Sinceramente, esta es una de esas configuraciones que al principio parecen un capricho y luego te das cuenta de que tienen muchisimo sentido. No porque ahora vayas a programar siempre desde la playa como un anuncio de stock, sino porque te da libertad real: puedes revisar, lanzar tareas y seguir proyectos sin depender siempre de tener el portatil delante.

Y encima, si lo haces con OpenCode, un VPS decente, Tailscale y systemd, te queda un montaje bastante fino: seguro, privado, sincronizado y siempre encendido.

Si quieres, en otro post puedo traerte una version mas avanzada con hardening extra del servidor, firewall, SSH con llaves y algun flujo mas serio con despliegues desde MCP.

¿Qué te ha parecido?

Déjame tu opinión, pregunta o sugerencia. Los comentarios se sincronizan con GitHub Discussions .