# Proyectos Open Source Self-Hosted: Editor Web, Notificaciones Push y Mensajería Telegram

**Fecha de elaboración:** 16 de julio de 2025
**Autor:** Investigator Agent — Investigación Autónoma
**Versión:** 1.0 (completa con visualizaciones)
**Propósito:** Identificar y evaluar proyectos open source autogestionados (self-hosted) que cubran tres necesidades específicas de desarrollo e infraestructura: (1) editor de código web similar a VS Code con capacidad de integración de APIs propias, (2) sistema de notificaciones push sin dependencia de API keys de terceros, y (3) solución para envío de mensajes por Telegram desde infraestructura propia.

---

## TL;DR

Existen proyectos maduros y activos para las tres necesidades. **code-server** (77.6k ★) y **Eclipse Theia** (21.5k ★) son las mejores opciones para un editor web self-hosted tipo VS Code, ambos compatibles con extensiones y APIs personalizadas. Para notificaciones push, **Gotify** (15k ★) y **ntfy** (28.5k+ ★) son servidores self-hosted completos, ligeros y sin dependencias externas. Para mensajería Telegram, la opción más flexible es usar **Apprise** (16.6k ★) como orquestador de notificaciones, o desplegar un **bot de Telegram con python-telegram-bot** en Docker, ambos completamente autogestionados.

---

## 1. Editor Web Self-Hosted Tipo VS Code

### 1.1 ¿De qué se trata?

La necesidad es contar con un editor de código fuente accesible desde el navegador web, que se ejecute en un servidor propio (self-hosted), con una experiencia similar a Visual Studio Code, y que permita integrar APIs personalizadas o herramientas como OpenCode para asistencia de código.

### 1.2 Opciones identificadas

#### code-server (Coder)

**Descripción:** Proyecto más popular para ejecutar VS Code en el navegador. Mantenido por Coder, una empresa especializada en entornos de desarrollo en la nube. Proporciona la experiencia completa de VS Code accesible vía web.

- **Repositorio:** https://github.com/coder/code-server
- **Estrellas:** 77.6k
- **Forks:** 6.7k
- **Licencia:** MIT
- **Estado:** Activo (actualizaciones regulares)

**Instalación básica con Docker:**
```bash
docker run -d \
  --name code-server \
  -p 8080:8080 \
  -v "${HOME}/.config:/home/coder/.config" \
  -v "${PWD}:/home/coder/project" \
  codercom/code-server:latest
```

**Características clave:**
- Experiencia VS Code idéntica en el navegador
- Terminal integrada
- Soporte completo de extensiones VS Code
- Multiplataforma (funciona en cualquier dispositivo con navegador)
- Mercado de extensiones propio: code-marketplace (https://github.com/coder/code-marketplace)
- Posibilidad de conectar APIs propias mediante extensiones personalizadas

**Integración con APIs propias:** Sí, mediante el sistema de extensiones de VS Code. Cualquier extensión que interactúe con APIs externas puede instalarse. Para APIs internas, se puede desarrollar una extensión personalizada.

**Limitaciones:** No tiene gestión multiusuario nativa (es monousuario por instancia). Para entornos multi-usuario, Coder ofrece una plataforma aparte (Coder OSS).

---

#### OpenVSCode Server (Gitpod)

**Descripción:** Versión de VS Code que ejecuta un servidor en una máquina remota y permite acceso mediante navegador web moderno. Mantenido por Gitpod, la misma arquitectura usada por GitHub Codespaces.

- **Repositorio:** https://github.com/gitpod-io/openvscode-server
- **Estrellas:** 6k
- **Forks:** 570
- **Licencia:** MIT (basado en MIT de VS Code)
- **Estado:** Activo

**Características clave:**
- Basado en la arquitectura oficial de VS Code (no es un fork modificado)
- Actualizaciones más sencillas que code-server al estar más cerca del VS Code upstream
- Compatible con todas las extensiones del marketplace oficial
- Acceso vía navegador desde cualquier dispositivo

**Diferencias con code-server:** OpenVSCode Server está más alineado con el código oficial de VS Code, lo que facilita las actualizaciones, pero tiene menos funcionalidades adicionales que code-server.

---

#### Eclipse Theia

**Descripción:** Framework de IDE cloud y desktop de código abierto, verdadera alternativa open source a VS Code. No es un fork de VS Code, sino una implementación independiente que utiliza el mismo protocolo de extensiones.

- **Repositorio:** https://github.com/eclipse-theia/theia
- **Estrellas:** 21.5k
- **Forks:** 2.8k
- **Licencia:** Eclipse Public License 2.0
- **Estado:** Activo (versión 1.53+ en 2024)
- **Sitio web:** https://theia-ide.org/

**Características clave:**
- Framework extensible para construir IDEs a medida
- Compatible con extensiones VS Code (más de 3000 disponibles en open-vsx.org)
- Soporte de edición colaborativa
- Data sovereignty mediante opciones de self-hosting
- AI-native (diseñado para integración con asistentes de IA)
- Corre tanto en escritorio como en navegador

**Ventaja clave para APIs propias:** Al ser un framework, Theia permite personalización profunda (compile-time extension API) que va más allá de lo posible con plugins. Esto facilita la integración de APIs propias a nivel de arquitectura.

**Integración con OpenCode:** Theia soporta el ecosistema de extensiones VS Code, por lo que herramientas como OpenCode (basadas en extensiones VS Code) pueden funcionar. Además, al ser AI-native, ofrece APIs para integración de asistentes de código.

---

#### Eclipse Che

**Descripción:** IDE cloud Kubernetes-native, basado en Eclipse Theia. Está diseñado para equipos y entornos empresariales.

**Características clave:**
- Multi-usuario por diseño
- Integración con Kubernetes
- Entornos de desarrollo por workspace
- Basado en Theia, compatible con extensiones VS Code

**Limitación:** Requiere Kubernetes, lo que añade complejidad de infraestructura. Es una opción más pesada que code-server para uso individual.

---

### 1.3 Comparativa de editores web self-hosted

| Característica | code-server | OpenVSCode Server | Eclipse Theia |
|---|---|---|---|
| Estrellas GitHub | 77.6k | 6k | 21.5k |
| Licencia | MIT | MIT | EPL 2.0 |
| Facilidad instalación | Muy alta (Docker) | Alta (Docker) | Media |
| Extensiones VS Code | Sí | Sí | Sí |
| Multi-usuario nativo | No | No | Sí (con Eclipse Che) |
| APIs propias | Vía extensiones | Vía extensiones | Vía framework (nativo) |
| Integración con OpenCode | Posible vía extensión | Posible vía extensión | Posible vía extensión |
| Consumo recursos | Bajo (~256MB RAM) | Bajo | Medio |
| Kubernetes requerido | No | No | Opcional (Che) |
| Edición colaborativa | No nativa | No nativa | Sí |

---

## 2. Notificaciones Push Self-Hosted Sin API Key

### 2.1 ¿De qué se trata?

La necesidad es contar con un servidor de notificaciones push autogestionado que permita enviar alertas y mensajes desde scripts o aplicaciones propias a dispositivos móviles o navegadores, sin depender de servicios externos como Firebase Cloud Messaging (FCM), OneSignal, o Pushover.

### 2.2 Opciones identificadas

#### Gotify

**Descripción:** Servidor simple para enviar y recibir mensajes en tiempo real vía WebSocket. Incluye una interfaz web y aplicación Android.

- **Repositorio servidor:** https://github.com/gotify/server
- **Estrellas servidor:** 15k
- **Estrellas Android:** 1.4k
- **Licencia:** MIT
- **Estado:** Activo
- **Sitio web:** https://gotify.net/

**Instalación básica con Docker:**
```bash
docker run -d \
  --name gotify \
  -p 8070:80 \
  -v gotify-data:/app/data \
  gotify/server
```

**Características clave:**
- API REST simple (curl para enviar notificaciones)
- WebSocket para recepción en tiempo real
- Interfaz web incluida
- App Android en F-Droid y Google Play
- CLI oficial (gotify/cli)
- Prioridades de mensajes
- Autenticación integrada
- Consumo: menos de 50 MB de RAM
- Sin dependencias externas

**Envío de notificación (ejemplo con curl):**
```bash
curl -X POST "http://localhost:8070/message?token=TOKEN" \
  -F "title=Alerta" \
  -F "message=Backup completado exitosamente" \
  -F "priority=5"
```

---

#### ntfy

**Descripción:** Servicio de notificaciones pub-sub basado en HTTP. Permite enviar notificaciones a teléfonos o escritorios usando simples peticiones HTTP PUT/POST. Más popular que Gotify en métricas de GitHub.

- **Sitio web:** https://ntfy.sh/
- **Estrellas GitHub:** ~28.5k
- **Licencia:** Apache 2.0 / GPLv2
- **Estado:** Muy activo
- **Apps:** Android, iOS, Web

**Instalación básica con Docker:**
```yaml
# docker-compose.yml
services:
  ntfy:
    image: binwiederhier/ntfy:latest
    container_name: ntfy
    command: serve
    volumes:
      - /var/lib/ntfy:/var/lib/ntfy
    ports:
      - 8080:80
```

**Características clave:**
- API HTTP nativa (PUT/POST)
- Adjuntos (archivos, imágenes, videos)
- Niveles de prioridad y categorías
- App Android e iOS oficiales
- App web para escritorio
- CLI oficial
- Control de acceso y autenticación
- Temas (topics) públicos o privados
- Cache de mensajes

**Envío de notificación (ejemplo con curl):**
```bash
curl -d "Backup successful 😀" ntfy.sh/mitopico
```

---

#### Comparativa Gotify vs ntfy

| Característica | Gotify | ntfy |
|---|---|---|
| Estrellas GitHub | 15k (server) | ~28.5k |
| Protocolo | WebSocket + REST | HTTP Pub-Sub |
| App Android | Sí | Sí |
| App iOS | No oficial | Sí |
| App Web | Sí (incluida) | Sí |
| Adjuntos | No | Sí |
| CLI oficial | Sí | Sí |
| Autenticación | Sí (token) | Sí (ACL) |
| Prioridades | Sí (1-7) | Sí (min/max/urgent) |
| Temas/Topics | No (por usuario) | Sí (pub-sub) |
| Consumo RAM | <50 MB | ~30 MB |
| Instalación | Muy simple | Muy simple |

---

#### Apprise

**Descripción:** Biblioteca de notificaciones multiplataforma que funciona como orquestador. Soporta más de 100 servicios de notificación, incluyendo Telegram, Gotify, ntfy, Slack, Discord, y muchos más. Puede ejecutarse como servicio independiente (Apprise API).

- **Repositorio:** https://github.com/caronc/apprise
- **Estrellas:** 16.6k
- **Forks:** 599
- **Licencia:** MIT
- **Estado:** Muy activo

**Características clave:**
- Soporta 100+ servicios de notificación
- Puede usarse como biblioteca Python o como API
- Apprise API: versión self-hosted con interfaz web
- Ideal como capa de abstracción entre herramientas y múltiples destinos
- Integración con Telegram, Gotify, ntfy, Slack, Discord, correo, etc.

---

## 3. Mensajería Telegram Self-Hosted

### 3.1 ¿De qué se trata?

La necesidad es enviar mensajes a Telegram desde infraestructura propia, sin depender de servicios externos, manteniendo el control de los datos. Es importante aclarar que Telegram requiere un Bot Token (proporcionado por BotFather) para enviar mensajes, pero el servidor y la lógica del bot se ejecutan completamente en infraestructura propia.

### 3.2 Opciones identificadas

#### Opción 1: Bot de Telegram con python-telegram-bot (recomendada)

**Descripción:** Usar la biblioteca python-telegram-bot para crear un bot que se ejecute en un contenedor Docker propio. Es la opción más flexible y directa.

**Instalación básica:**
```dockerfile
FROM python:3.11-alpine
WORKDIR /app
RUN pip install python-telegram-bot
COPY bot.py .
CMD ["python", "bot.py"]
```

**Código mínimo para enviar mensajes:**
```python
import asyncio
from telegram import Bot

async def send_message():
    bot = Bot(token="TU_TOKEN_AQUI")
    await bot.send_message(chat_id="@usuario", text="¡Hola desde mi servidor!")

asyncio.run(send_message())
```

**Ventajas:**
- Control total sobre la lógica del bot
- Se ejecuta 100% en tu servidor
- Soporte completo de la API de Telegram
- Fácil de extender

---

#### Opción 2: Apprise para notificaciones a Telegram

**Descripción:** Usar Apprise como orquestador para enviar mensajes a Telegram desde scripts o aplicaciones, sin escribir código de bot.

**Ejemplo con Apprise:**
```python
import apprise

# Crear instancia de Apprise
apobj = apprise.Apprise()

# Agregar servicio Telegram
apobj.add('tgram://BOT_TOKEN/CHAT_ID')

# Enviar mensaje
apobj.notify(
    title='Notificación',
    body='Mensaje desde mi servidor'
)
```

**Ventajas:**
- Múltiples destinos con una sola llamada (Telegram + Slack + correo)
- Fácil integración con scripts existentes
- API REST auto-contenida con Apprise API

---

#### Opción 3: Telegram Bot API self-hosted (avanzada)

**Descripción:** Hostear el servidor de la API de Telegram localmente usando telegram-bot-api (basado en TDLib). Esto permite eliminar el límite de 50MB en subida de archivos y tener control total.

**Referencia:** https://dev.to/joybtw/how-i-self-hosted-the-telegram-bot-api-with-docker-to-bypass-50mb-upload-limits-483a

**Ventajas:**
- Sin límites de tamaño de archivo
- Menor latencia
- Control total

**Desventajas:**
- Mayor complejidad de configuración
- Requiere más recursos

---

### 3.3 Tabla comparativa: Opciones Telegram self-hosted

| Característica | Bot Python (python-telegram-bot) | Apprise | Telegram Bot API (tdlib) |
|---|---|---|---|
| Complejidad | Baja | Muy baja | Alta |
| Control total | Sí | Medio (abstracción) | Sí |
| Múltiples destinos | No nativo | Sí (nativo) | No nativo |
| Recursos | Mínimo | Mínimo | Moderado |
| Mantenimiento | Bajo | Mínimo | Alto |
| Documentación | Excelente | Buena | Limitada |
| Ideal para | Bots complejos | Scripts/alertas | Subida archivos grandes |

---

## 4. Visualización de Arquitectura y Datos

### 4.1 Arquitectura del stack recomendado

```mermaid
flowchart TB
    classDef script fill:#E3F2FD,stroke:#1565C0,stroke-width:1.5px,color:#0D47A1
    classDef core fill:#E8F5E9,stroke:#2E7D32,stroke-width:2px,color:#1B5E20,font-weight:bold
    classDef output fill:#FFF3E0,stroke:#E65100,stroke-width:1.5px,color:#BF360C
    classDef storage fill:#F3E5F5,stroke:#6A1B9A,stroke-width:1px,color:#4A148C

    SCRIPTS["Scripts / Apps / Cron\nAlertas, monitoreo, backups"]:::script

    subgraph ORCH["Capa de Orquestación"]
        APPRISE["Apprise API\nOrquestador de notificaciones\n100+ servicios"]:::core
    end

    subgraph PUSH["Notificaciones Push"]
        direction TB
        NTFY["ntfy / Gotify\nServidor push self-hosted\nHTTP / WebSocket"]:::core
        MOBILE["App Android / iOS\nNotificaciones nativas"]:::output
    end

    subgraph TELEGRAM["Mensajería Telegram"]
        direction TB
        BOT["Bot Telegram\npython-telegram-bot"]:::core
        TG["Telegram API\nMensajes entregados"]:::output
    end

    subgraph STORAGE["Almacenamiento"]
        STATE["(Opcional)\nBase de datos local\nSQLite / Postgres"]:::storage
    end

    SCRIPTS -->|"HTTP POST / API call"| APPRISE
    APPRISE -->|"tgram://BOT_TOKEN/CHAT_ID"| BOT
    APPRISE -->|"HTTP PUT"| NTFY
    BOT -->|"send_message()"| TG
    NTFY -->|"WebSocket / FCM"| MOBILE
    APPRISE -.->|"logs / persistencia"| STATE

    linkStyle 0 stroke:#1565C0,stroke-width:2px
    linkStyle 1 stroke:#6A1B9A,stroke-width:1.5px
    linkStyle 2 stroke:#2E7D32,stroke-width:1.5px
    linkStyle 3 stroke:#E65100,stroke-width:1px
    linkStyle 4 stroke:#2E7D32,stroke-width:1px
    linkStyle 5 stroke:#6A1B9A,stroke-dasharray:4 2
```

### 4.2 Popularidad de proyectos (estrellas GitHub)

```mermaid
%% Distribución de popularidad entre los proyectos analizados
xychart-beta
    title "Estrellas GitHub de proyectos self-hosted"
    x-axis ["code-server", "ntfy", "Eclipse Theia", "Apprise", "Gotify", "OpenVSCode"]
    y-axis "Estrellas (miles)" 0 --> 80
    bar [77.6, 28.5, 21.5, 16.6, 15, 6]
```

### 4.3 Árbol de decisión para selección de proyectos

```mermaid
%% Árbol de decisión para elegir el stack adecuado
flowchart TD
    classDef question fill:#FFF3E0,stroke:#E65100,color:#BF360C,font-weight:bold
    classDef answer fill:#E8F5E9,stroke:#2E7D32,color:#1B5E20
    classDef option fill:#E3F2FD,stroke:#1565C0,color:#0D47A1

    START([¿Qué necesitas?]):::question

    START --> WEB{"Editor web\nself-hosted?"}:::question
    WEB -->|"Uso individual"| CS["code-server\n77.6k ★ · Docker fácil"]:::answer
    WEB -->|"APIs propias / IA"| THEIA["Eclipse Theia\n21.5k ★ · Framework extensible"]:::answer

    START --> PUSH{"Notificaciones\npush?"}:::question
    PUSH -->|"iOS + Android"| N["ntfy\n28.5k ★ · Apps oficiales"]:::answer
    PUSH -->|"Solo Android"| G["Gotify\n15k ★ · WebSocket"]:::answer

    START --> TG{"Mensajes\nTelegram?"}:::question
    TG -->|"Alertas simples"| APR["Apprise\n16.6k ★ · 1 línea de código"]:::answer
    TG -->|"Bot complejo"| PTB["python-telegram-bot\nControl total"]:::answer
```

### 4.4 Datos Relevantes

#### Estadísticas de popularidad (GitHub, julio 2025)

| Proyecto | Estrellas | Forks | Licencia | Lenguaje |
|---|---|---|---|---|
| code-server | 77,600 | 6,700 | MIT | TypeScript/Go |
| Eclipse Theia | 21,500 | 2,800 | EPL 2.0 | TypeScript |
| OpenVSCode Server | 6,000 | 570 | MIT | TypeScript |
| Gotify | 15,000 | 819 | MIT | Go |
| ntfy | ~28,500 | — | Apache 2.0/GPLv2 | Go |
| Apprise | 16,600 | 599 | MIT | Python |

#### Consumo de recursos

- **code-server:** ~256 MB RAM + CPU por sesión activa
- **Gotify:** <50 MB RAM en reposo
- **ntfy:** ~30 MB RAM en reposo
- **Apprise (API):** ~100 MB RAM

---

## 5. Conclusión y Recomendaciones

### Recomendación 1: Editor web self-hosted

**Para uso individual o pocos desarrolladores:** **code-server** es la opción más recomendable por su madurez, documentación, facilidad de instalación (Docker listo) y ecosistema. Es el proyecto más popular con diferencia (77.6k estrellas).

**Si necesitas personalización profunda o integración nativa de APIs propias:** **Eclipse Theia** es superior por ser un framework diseñado para extensibilidad. Su compatibilidad con extensiones VS Code y su naturaleza AI-native lo hacen ideal para integrar herramientas como OpenCode.

**Si priorizas estar lo más cerca posible del VS Code oficial:** **OpenVSCode Server** es una alternativa válida, aunque menos activa que code-server.

### Recomendación 2: Notificaciones push self-hosted

**Opción principal: ntfy.** Es más popular, tiene apps iOS y Android oficiales, soporta adjuntos, y su modelo pub-sub es más flexible. La instalación es igual de simple que Gotify.

**Alternativa sólida: Gotify.** Si prefieres una interfaz web más pulida y priorizas mensajes con WebSocket, Gotify es excelente. Su ecosistema es más pequeño pero estable.

**Capa de abstracción recomendada: Apprise.** Independientemente de si eliges Gotify o ntfy como servidor de notificaciones, Apprise puede actuar como orquestador que unifique las notificaciones hacia múltiples destinos (incluyendo Telegram).

### Recomendación 3: Mensajería Telegram self-hosted

**Para scripts y alertas simples:** Usa **Apprise** con el plugin de Telegram. Es la opción más simple y rápida de implementar.

**Para bots interactivos o lógica compleja:** Usa **python-telegram-bot** en un contenedor Docker. Te da control total y es fácil de mantener.

**Para casos avanzados (archivos grandes, baja latencia):** Considera hostear **telegram-bot-api** localmente, evaluando la complejidad adicional.

### Stack recomendado integrado

```
[Scripts/Apps] → [Apprise API]
    ↓                    ↓
[Gotify/ntfy]      [Telegram Bot]
(notif. push)      (mensajería)
```

Este stack permite que desde cualquier script o aplicación:
1. Se envíe una notificación push al teléfono (vía Gotify/ntfy)
2. Se envíe un mensaje a Telegram (vía Apprise → Telegram Bot)
3. Todo en infraestructura propia, sin servicios externos

---

## 6. Integración con OpenCode

Respecto a la pregunta específica sobre OpenCode, es importante señalar que:

1. **OpenCode** (herramienta de asistencia de código) se integra típicamente como extensión de VS Code.
2. **code-server** y **Eclipse Theia** soportan extensiones VS Code, por lo que OpenCode puede instalarse directamente.
3. Para APIs propias, la ruta recomendada es:
   - En code-server: desarrollar una extensión VS Code personalizada
   - En Eclipse Theia: usar el framework de extensiones o la API compile-time

---

## 7. Fuentes Consultadas

1. Coder. (2025). code-server: VS Code in the browser [Repositorio GitHub]. https://github.com/coder/code-server
2. Gitpod. (2025). OpenVSCode Server [Repositorio GitHub]. https://github.com/gitpod-io/openvscode-server
3. Eclipse Theia. (2025). Theia: Cloud & Desktop IDE framework [Repositorio GitHub]. https://github.com/eclipse-theia/theia
4. Gotify. (2025). Gotify Server: A simple server for sending and receiving messages [Repositorio GitHub]. https://github.com/gotify/server
5. Heckel, P. (2025). ntfy: Push notifications made easy [Sitio web]. https://ntfy.sh/
6. Caron, C. (2025). Apprise: Push Notifications that work with just about every platform [Repositorio GitHub]. https://github.com/caronc/apprise
7. OneUptime. (2026, 8 de febrero). How to Run Gotify in Docker for Push Notifications. https://oneuptime.com/blog/post/2026-02-08-how-to-run-gotify-in-docker-for-push-notifications/view
8. MassiveGRID. (2026, 28 de enero). Self-Host ntfy on Ubuntu VPS: Push Notifications for Your Infrastructure. https://massivegrid.com/blog/self-host-ntfy-ubuntu-vps/
9. Vezpi Lab. (2025, 13 de junio). Testing Gotify and Ntfy, a Self-Hosted Notification System. https://blog.vezpi.com/en/post/notification-system-gotify-vs-ntfy/
10. EclipseSource. (2024, 27 de junio). Introducing the Theia IDE. https://eclipsesource.com/blogs/2024/06/27/introducing-the-theia-ide/
11. Theia IDE. (2025). The AI-Native Open-Source Cloud and Desktop IDE. https://theia-ide.org/
12. Dev.to. (2025, 28 de septiembre). How I Self-Hosted the Telegram Bot API with Docker. https://dev.to/joybtw/how-i-self-hosted-the-telegram-bot-api-with-docker-to-bypass-50mb-upload-limits-483a
13. Medevel. (2024). 11 Open-source Free Self-hosted Web-based Code Editor for Teams and Agencies. https://medevel.com/11-self-hosted-code-editors-os/
14. Akash Rajpurohit. (2025, 2 de enero). Ntfy — Self-hosted push notification server for all your services. https://akashrajpurohit.com/blog/selfhost-ntfy-for-push-notifications/