cambio a 7 horas de intervalo

.dockerignore

@@ -0,0 +1,55 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# CI/CD
+.github
+.gitlab-ci.yml
+
+# Documentation
+*.md
+docs/
+
+# Environment files
+.env
+.env.*
+!.env.example
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Logs
+*.log
+logs/
+
+# Node
+node_modules/
+npm-debug.log
+
+# Docker
+docker-compose.yml
+docker-compose.*.yml
+Dockerfile
+.dockerignore
+
+# Other instances
+instancia*/

.env.example

@@ -2,6 +2,16 @@
 # Copy this file to .env and fill in your actual values
 # DO NOT commit .env to version control
 
+# === Project Configuration ===
+# Nombre del proyecto (usado para prefijos de contenedores y redes)
+# Para múltiples instancias, usa nombres diferentes: instancia1, instancia2, etc.
+# Por defecto: onedrive
+# COMPOSE_PROJECT_NAME=onedrive
+
+# Puerto expuesto para el motor (por defecto: 8089)
+# Para múltiples instancias, usa puertos diferentes: 8089, 8090, 8091, etc.
+# ENGINE_PORT=8089
+
 # === Engine (odengin) Configuration ===
 # Microsoft Azure credentials
 E5_CLIENT_ID=your_client_id_here
@@ -13,8 +23,8 @@ WEB_APP_PASSWORD=your_secure_password_here
 E5_WEB_APP_PASSWORD=your_e5_password_here
 
 # === Cron Service (odcron) Configuration ===
-# Engine connection
+# Engine connection (se genera automáticamente si no se especifica)
-CRON_IP=odengin:8080
+# CRON_IP=odengin:8080
 
 # Authentication
 CRON_PASSWORD=your_cron_password_here

.gitignore

@@ -2,6 +2,8 @@
 .env
 .env.local
 .env.*.local
+.env.inst*
+.env.instancia*
 
 # IDE
 .vscode/
@@ -14,6 +16,10 @@
 # Docker
 docker-compose.override.yml
 
+# Multiple instances directories
+instancia*/
+inst*/
+
 # Python
 __pycache__/
 *.py[cod]

DOKPLOY.md

@@ -0,0 +1,400 @@
+# 🚀 Despliegue en Dokploy
+
+Esta guía explica cómo desplegar múltiples instancias de OneDrive Engine en Dokploy.
+
+## 📋 ¿Qué es Dokploy?
+
+Dokploy es una plataforma de gestión de aplicaciones que simplifica el despliegue de contenedores Docker. Automáticamente maneja:
+
+- Nombres únicos de contenedores
+- Redes aisladas por proyecto
+- Variables de entorno
+- SSL/TLS con Let's Encrypt
+- Dominios y subdominios
+- Monitoreo y logs
+
+## 🎯 Ventajas de usar Dokploy
+
+✅ **Interfaz Web**: Gestiona todo desde el navegador  
+✅ **Multi-instancia**: Cada proyecto es independiente  
+✅ **Sin conflictos**: Dokploy maneja puertos y nombres automáticamente  
+✅ **Variables de entorno**: Configuración segura desde la UI  
+✅ **Logs centralizados**: Ver logs de todas las instancias en un lugar  
+✅ **Actualizaciones fáciles**: Rebuild y redeploy con un clic
+
+## 🔧 Preparación
+
+### Prerrequisitos
+
+1. Servidor con Dokploy instalado
+2. Acceso a la UI de Dokploy
+3. Repositorio Git (opcional, pero recomendado)
+
+### Estructura del Proyecto
+
+Asegúrate de que tu proyecto tenga esta estructura:
+
+```
+onedrive/
+├── docker-compose.dokploy.yml  # Compose para Dokploy
+├── docker-compose.yml          # Compose local/tradicional
+├── .env.example
+├── engine/
+│   └── Dockerfile
+└── cron/
+    └── Dockerfile
+```
+
+## 📦 Método 1: Deploy desde Git (Recomendado)
+
+### Paso 1: Sube el proyecto a Git
+
+```bash
+# Inicializar repositorio (si no existe)
+git init
+git add .
+git commit -m "Initial commit"
+
+# Subir a GitHub/GitLab/Gitea
+git remote add origin <tu-repositorio-url>
+git push -u origin main
+```
+
+### Paso 2: Crear Proyecto en Dokploy
+
+1. Accede a Dokploy: `https://tu-servidor:3000`
+2. Clic en **"New Project"**
+3. Nombre del proyecto: `onedrive-instancia1` (o el nombre que prefieras)
+4. Clic en **"Create Project"**
+
+### Paso 3: Crear Aplicación (Compose)
+
+1. Dentro del proyecto, clic en **"New Service"**
+2. Selecciona **"Docker Compose"**
+3. Configura:
+   - **Name**: `e5-renewal`
+   - **Repository**: Tu URL de Git
+   - **Branch**: `main`
+   - **Compose File Path**: `docker-compose.dokploy.yml`
+   - **Build Path**: `./` (raíz del repo)
+
+### Paso 4: Configurar Variables de Entorno
+
+En la sección **"Environment Variables"**, agrega:
+
+```env
+# Credenciales E5
+E5_CLIENT_ID=tu_client_id_aqui
+E5_CLIENT_SECRET=tu_client_secret_aqui
+E5_REFRESH_TOKEN=tu_refresh_token_aqui
+
+# Contraseñas
+WEB_APP_PASSWORD=tu_password_segura
+E5_WEB_APP_PASSWORD=tu_e5_password
+
+# Cron
+CRON_PASSWORD=tu_cron_password
+CRON_REFRESH_TOKEN=tu_cron_refresh_token
+
+# Puerto (opcional, Dokploy puede asignar automáticamente)
+ENGINE_PORT=8089
+```
+
+### Paso 5: Deploy
+
+1. Clic en **"Deploy"**
+2. Dokploy automáticamente:
+   - Clona el repositorio
+   - Construye las imágenes
+   - Inicia los contenedores
+   - Configura la red
+
+### Paso 6: Configurar Dominio (Opcional)
+
+1. En la aplicación, ve a **"Domains"**
+2. Agrega un dominio: `onedrive1.tudominio.com`
+3. Dokploy configurará SSL automáticamente
+
+## 📦 Método 2: Deploy Manual (Docker Compose)
+
+### Paso 1: Crear Proyecto en Dokploy
+
+1. Nuevo proyecto: `onedrive-instancia1`
+2. New Service → **"Docker Compose"**
+3. Selecciona **"Custom Compose"**
+
+### Paso 2: Pegar Docker Compose
+
+Copia el contenido de `docker-compose.dokploy.yml` en el editor.
+
+### Paso 3: Configurar Variables de Entorno
+
+Igual que en el Método 1.
+
+### Paso 4: Deploy
+
+Clic en **"Deploy"**.
+
+## 🔄 Múltiples Instancias en Dokploy
+
+Para gestionar múltiples cuentas de E5, crea **proyectos separados**:
+
+### Configuración Recomendada
+
+| Proyecto Dokploy   | Cuenta E5       | Puerto | Dominio (opcional)   |
+| ------------------ | --------------- | ------ | -------------------- |
+| `onedrive-cuenta1` | Cuenta personal | 8089   | `e5-1.tudominio.com` |
+| `onedrive-cuenta2` | Cuenta trabajo  | 8090   | `e5-2.tudominio.com` |
+| `onedrive-cuenta3` | Cuenta familiar | 8091   | `e5-3.tudominio.com` |
+
+### Crear Nueva Instancia
+
+1. **Duplicar Proyecto**:
+
+   - Clic en el menú del proyecto → **"Clone Project"**
+   - Nuevo nombre: `onedrive-cuenta2`
+
+2. **Actualizar Variables**:
+
+   - Ir a Environment Variables
+   - Cambiar todas las credenciales E5
+   - Cambiar `ENGINE_PORT` (ej: 8090)
+
+3. **Deploy**:
+   - Clic en "Deploy"
+
+Repite para cada cuenta adicional.
+
+## 📊 Gestión desde Dokploy UI
+
+### Ver Logs
+
+1. Navega al proyecto
+2. Selecciona el servicio (`odengin` o `odcron`)
+3. Clic en **"Logs"**
+4. Logs en tiempo real con búsqueda y filtros
+
+### Reiniciar Servicios
+
+1. En el servicio, clic en **"Restart"**
+2. O **"Rebuild"** para reconstruir desde cero
+
+### Monitoreo
+
+1. Dashboard del proyecto muestra:
+   - Estado de contenedores
+   - Uso de recursos (CPU, RAM)
+   - Tráfico de red
+
+### Actualizar Código
+
+1. Haz push de cambios a Git
+2. En Dokploy, clic en **"Rebuild & Deploy"**
+3. Dokploy pull, rebuild y redeploy automáticamente
+
+## 🔒 Seguridad en Dokploy
+
+### Mejores Prácticas
+
+✅ **Variables de Entorno**:
+
+- Usa la UI de Dokploy para variables sensibles
+- No las incluyas en el compose file
+
+✅ **Dominios con SSL**:
+
+- Dokploy genera certificados Let's Encrypt automáticamente
+- Fuerza HTTPS para todas las conexiones
+
+✅ **Redes Aisladas**:
+
+- Cada proyecto tiene su propia red Docker
+- Los servicios no pueden comunicarse entre proyectos
+
+✅ **Control de Acceso**:
+
+- Configura usuarios con permisos específicos
+- Usa autenticación de dos factores
+
+## 🛠️ Configuración Avanzada
+
+### Usar Registry Privado
+
+Si construyes imágenes previamente:
+
+```yaml
+services:
+  odengin:
+    image: ghcr.io/tuusuario/onedrive-engine:v1.0
+    # No necesitas 'build' si usas imagen pre-construida
+```
+
+Variables de entorno en Dokploy:
+
+```env
+REGISTRY=ghcr.io
+IMAGE_OWNER=tuusuario
+IMAGE_TAG=v1.0
+```
+
+### Health Checks Personalizados
+
+Dokploy respeta los health checks del compose:
+
+```yaml
+healthcheck:
+  test: ["CMD-SHELL", "wget --spider http://localhost:8080/health"]
+  interval: 30s
+  timeout: 10s
+  retries: 3
+  start_period: 40s
+```
+
+### Límites de Recursos
+
+Agrega en el compose file:
+
+```yaml
+services:
+  odengin:
+    deploy:
+      resources:
+        limits:
+          cpus: "0.5"
+          memory: 512M
+        reservations:
+          cpus: "0.25"
+          memory: 256M
+```
+
+## 🔍 Troubleshooting
+
+### El servicio no inicia
+
+1. **Revisar logs**:
+
+   - Dokploy UI → Service → Logs
+   - Busca errores de inicio
+
+2. **Verificar variables**:
+
+   - Asegúrate de que todas las variables requeridas están configuradas
+   - Revisa por typos en nombres de variables
+
+3. **Rebuild**:
+   - Intenta "Rebuild & Deploy" para forzar reconstrucción
+
+### Puertos en conflicto
+
+Dokploy maneja esto automáticamente, pero si necesitas puertos específicos:
+
+1. Asigna puertos únicos en cada proyecto
+2. O deja que Dokploy asigne puertos aleatorios
+3. Usa dominios en lugar de puertos
+
+### No puedo acceder al servicio
+
+1. **Verifica el estado**:
+
+   - Dashboard → Service Status debe ser "Running"
+
+2. **Revisa el firewall**:
+
+   ```bash
+   # En el servidor
+   sudo ufw allow 8089/tcp
+   ```
+
+3. **Usa dominios**:
+   - Más fácil que gestionar puertos
+   - Dokploy configura proxy reverso automáticamente
+
+### Actualización no se refleja
+
+1. **Force rebuild**:
+   - Clic en "Rebuild & Deploy" (no solo "Deploy")
+2. **Limpia cache**:
+   - En algunas versiones de Dokploy: Settings → "Clear Build Cache"
+
+## 📋 Checklist de Deploy
+
+Antes de crear una nueva instancia:
+
+- [ ] Nombre único de proyecto
+- [ ] Repositorio Git configurado (o compose manual)
+- [ ] Todas las variables de entorno configuradas
+- [ ] Puerto único asignado (o dominio configurado)
+- [ ] Credenciales E5 correctas y válidas
+- [ ] Build context correcto (`./`)
+- [ ] Compose file path correcto
+
+Después del deploy:
+
+- [ ] Estado del servicio es "Running"
+- [ ] Logs no muestran errores críticos
+- [ ] Health check pasa (si está configurado)
+- [ ] Puedes acceder al servicio (puerto o dominio)
+
+## 💡 Tips Pro
+
+### 1. Usa Git Tags para Versiones
+
+```bash
+git tag -a v1.0 -m "Version 1.0"
+git push origin v1.0
+```
+
+En Dokploy, configura el branch a `v1.0` para deploys estables.
+
+### 2. Organiza con Etiquetas
+
+En el compose, agrega labels:
+
+```yaml
+labels:
+  - "com.dokploy.project=onedrive"
+  - "com.dokploy.environment=production"
+  - "com.dokploy.owner=admin"
+```
+
+### 3. Automatiza con Webhooks
+
+1. Dokploy UI → Service → Webhooks
+2. Copia la URL del webhook
+3. En GitHub: Settings → Webhooks → Add webhook
+4. Paste URL, selecciona eventos (push, release)
+5. Ahora cada push redeploya automáticamente
+
+### 4. Backup de Variables
+
+Exporta variables de entorno periódicamente:
+
+1. Settings → Export Configuration
+2. Guarda el JSON de forma segura
+3. Úsalo para restaurar o clonar proyectos
+
+### 5. Monitoreo Externo
+
+Integra con herramientas como:
+
+- **Uptime Kuma**: Para monitoreo de uptime
+- **Grafana**: Para métricas avanzadas
+- **Prometheus**: Para alertas
+
+## 🔗 Recursos
+
+- [Dokploy Docs](https://docs.dokploy.com)
+- [Docker Compose Reference](https://docs.docker.com/compose/compose-file/)
+- [Microsoft E5 Auto-Renewal](https://github.com/TheCaduceus/Microsoft-E5-Auto-Renewal)
+
+## 📝 Resumen
+
+Con Dokploy puedes:
+
+1. **Crear proyecto** → Asignar nombre único
+2. **Configurar compose** → Desde Git o manual
+3. **Agregar variables** → Desde la UI segura
+4. **Deploy** → Con un clic
+5. **Repetir** → Para múltiples instancias
+
+Cada instancia es completamente independiente y se gestiona desde una interfaz centralizada. 🎉

DOKPLOY_QUICK.md

@@ -0,0 +1,109 @@
+# Guía Rápida de Dokploy
+
+## 🚀 Deploy en 5 Minutos
+
+### 1. Preparar el Repositorio
+
+```bash
+# Asegúrate de que todo esté commiteado
+git add .
+git commit -m "Preparar para Dokploy"
+git push
+```
+
+### 2. Crear Proyecto en Dokploy
+
+1. Accede a Dokploy: `https://tu-servidor:3000`
+2. **New Project** → Nombre: `onedrive-cuenta1`
+3. **New Service** → **Docker Compose**
+
+### 3. Configurar el Servicio
+
+**Repository Settings:**
+
+- Git URL: `https://github.com/tuusuario/onedrive-engine.git`
+- Branch: `main`
+- Compose File: `docker-compose.dokploy.yml`
+- Build Path: `./`
+
+**Environment Variables:**
+
+```env
+E5_CLIENT_ID=tu_client_id
+E5_CLIENT_SECRET=tu_client_secret
+E5_REFRESH_TOKEN=tu_refresh_token
+WEB_APP_PASSWORD=password123
+E5_WEB_APP_PASSWORD=e5password123
+CRON_PASSWORD=cronpass123
+CRON_REFRESH_TOKEN=cron_refresh_token
+ENGINE_PORT=8089
+```
+
+### 4. Deploy
+
+Clic en **"Deploy"** → Espera ~2-3 minutos → ✅ Listo!
+
+---
+
+## 📋 Checklist Pre-Deploy
+
+- [ ] Repositorio Git actualizado
+- [ ] `docker-compose.dokploy.yml` en la raíz
+- [ ] Dockerfiles en `engine/` y `cron/`
+- [ ] Credenciales E5 válidas preparadas
+- [ ] Puerto único decidido (8089, 8090, etc.)
+
+---
+
+## 🔄 Para Múltiples Instancias
+
+**Opción A: Clonar Proyecto en Dokploy**
+
+1. Proyecto existente → Menu → **Clone Project**
+2. Nuevo nombre: `onedrive-cuenta2`
+3. Cambiar variables de entorno (especialmente credenciales y puerto)
+4. Deploy
+
+**Opción B: Crear Nuevo Proyecto**
+
+Repite los pasos 1-4 con:
+
+- Diferente nombre de proyecto
+- Diferentes credenciales E5
+- Diferente `ENGINE_PORT`
+
+---
+
+## 🌐 Configurar Dominio (Opcional)
+
+1. En el servicio → **Domains**
+2. Add Domain: `e5-cuenta1.tudominio.com`
+3. Dokploy configura SSL automáticamente
+4. Accede via HTTPS: `https://e5-cuenta1.tudominio.com`
+
+---
+
+## 📊 Tabla de Instancias Recomendada
+
+| Proyecto Dokploy | Puerto | Dominio          | Cuenta E5 |
+| ---------------- | ------ | ---------------- | --------- |
+| onedrive-cuenta1 | 8089   | e5-1.example.com | Personal  |
+| onedrive-cuenta2 | 8090   | e5-2.example.com | Trabajo   |
+| onedrive-cuenta3 | 8091   | e5-3.example.com | Familiar  |
+
+---
+
+## 🛠️ Comandos Útiles en Dokploy
+
+- **Ver Logs**: Service → Logs
+- **Reiniciar**: Service → Restart
+- **Rebuild**: Service → Rebuild & Deploy
+- **SSH al Contenedor**: Service → Terminal
+
+---
+
+## 🔗 Enlaces
+
+- Documentación completa: [DOKPLOY.md](DOKPLOY.md)
+- Múltiples instancias local: [MULTI_INSTANCIAS.md](MULTI_INSTANCIAS.md)
+- README principal: [README.md](README.md)

MULTI_INSTANCIAS.md

@@ -0,0 +1,306 @@
+# 🚀 Ejecutar Múltiples Instancias
+
+Este proyecto está configurado para ejecutar múltiples instancias en la misma máquina sin conflictos de puertos o nombres.
+
+## 📋 Estructura de Directorios
+
+Para ejecutar múltiples instancias, organiza el proyecto así:
+
+```
+OneDrive/
+├── instancia1/          # Primera instancia
+│   ├── .env
+│   └── docker-compose.yml (enlace simbólico o copia)
+├── instancia2/          # Segunda instancia
+│   ├── .env
+│   └── docker-compose.yml (enlace simbólico o copia)
+└── instancia3/          # Tercera instancia
+    ├── .env
+    └── docker-compose.yml (enlace simbólico o copia)
+```
+
+## 🔧 Configuración para Múltiples Instancias
+
+### Opción 1: Directorios Separados (Recomendado)
+
+**Paso 1: Crea directorios para cada instancia**
+
+```powershell
+# Windows
+mkdir instancia1, instancia2, instancia3
+
+# o crear estructura completa
+mkdir instancia1\engine, instancia1\cron
+mkdir instancia2\engine, instancia2\cron
+mkdir instancia3\engine, instancia3\cron
+```
+
+**Paso 2: Copia el proyecto a cada directorio**
+
+```powershell
+# Copiar archivos base
+Copy-Item -Path "docker-compose.yml", ".env.example", ".gitignore" -Destination "instancia1"
+Copy-Item -Path "docker-compose.yml", ".env.example", ".gitignore" -Destination "instancia2"
+Copy-Item -Path "docker-compose.yml", ".env.example", ".gitignore" -Destination "instancia3"
+
+# Copiar carpetas engine y cron
+Copy-Item -Path "engine\*" -Destination "instancia1\engine" -Recurse
+Copy-Item -Path "cron\*" -Destination "instancia1\cron" -Recurse
+
+# Repetir para instancia2 y instancia3
+```
+
+**Paso 3: Crea archivos `.env` para cada instancia**
+
+```powershell
+# Instancia 1
+cd instancia1
+cp .env.example .env
+# Editar .env con credenciales de cuenta 1
+
+# Instancia 2
+cd ..\instancia2
+cp .env.example .env
+# Editar .env con credenciales de cuenta 2
+
+# Instancia 3
+cd ..\instancia3
+cp .env.example .env
+# Editar .env con credenciales de cuenta 3
+```
+
+**Contenido del `.env` para cada instancia:**
+
+```env
+# instancia1/.env
+COMPOSE_PROJECT_NAME=instancia1
+ENGINE_PORT=8089
+E5_CLIENT_ID=cuenta1_client_id
+E5_CLIENT_SECRET=cuenta1_secret
+E5_REFRESH_TOKEN=cuenta1_refresh_token
+WEB_APP_PASSWORD=password1
+E5_WEB_APP_PASSWORD=e5_password1
+CRON_PASSWORD=cron_password1
+CRON_REFRESH_TOKEN=cron_refresh_token1
+```
+
+```env
+# instancia2/.env
+COMPOSE_PROJECT_NAME=instancia2
+ENGINE_PORT=8090
+E5_CLIENT_ID=cuenta2_client_id
+E5_CLIENT_SECRET=cuenta2_secret
+E5_REFRESH_TOKEN=cuenta2_refresh_token
+WEB_APP_PASSWORD=password2
+E5_WEB_APP_PASSWORD=e5_password2
+CRON_PASSWORD=cron_password2
+CRON_REFRESH_TOKEN=cron_refresh_token2
+```
+
+```env
+# instancia3/.env
+COMPOSE_PROJECT_NAME=instancia3
+ENGINE_PORT=8091
+E5_CLIENT_ID=cuenta3_client_id
+E5_CLIENT_SECRET=cuenta3_secret
+E5_REFRESH_TOKEN=cuenta3_refresh_token
+WEB_APP_PASSWORD=password3
+E5_WEB_APP_PASSWORD=e5_password3
+CRON_PASSWORD=cron_password3
+CRON_REFRESH_TOKEN=cron_refresh_token3
+```
+
+### Opción 2: Una Sola Carpeta con Múltiples `.env`
+
+Si prefieres mantener un solo directorio, usa `.env` personalizados:
+
+```powershell
+# Crear archivos .env específicos
+cp .env.example .env.instancia1
+cp .env.example .env.instancia2
+cp .env.example .env.instancia3
+```
+
+**Comando para lanzar:**
+
+```powershell
+# Instancia 1
+docker-compose -p instancia1 --env-file .env.instancia1 up -d
+
+# Instancia 2
+docker-compose -p instancia2 --env-file .env.instancia2 up -d
+
+# Instancia 3
+docker-compose -p instancia3 --env-file .env.instancia3 up -d
+```
+
+## 🎯 Gestión de Múltiples Instancias
+
+### Iniciar todas las instancias
+
+```powershell
+# Opción 1: Directorios separados
+cd instancia1; docker-compose up -d; cd ..
+cd instancia2; docker-compose up -d; cd ..
+cd instancia3; docker-compose up -d; cd ..
+
+# Opción 2: Script PowerShell
+@("instancia1", "instancia2", "instancia3") | ForEach-Object {
+    Write-Host "Iniciando $_..."
+    Push-Location $_
+    docker-compose up -d
+    Pop-Location
+}
+```
+
+### Ver estado de todas las instancias
+
+```powershell
+# Opción 1: Por instancia
+cd instancia1; docker-compose ps; cd ..
+cd instancia2; docker-compose ps; cd ..
+cd instancia3; docker-compose ps; cd ..
+
+# Opción 2: Comando único
+docker ps --filter "label=com.docker.compose.project" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+```
+
+### Ver logs de una instancia
+
+```powershell
+cd instancia1
+docker-compose logs -f odengin
+docker-compose logs -f odcron
+```
+
+### Detener todas las instancias
+
+```powershell
+@("instancia1", "instancia2", "instancia3") | ForEach-Object {
+    Write-Host "Deteniendo $_..."
+    Push-Location $_
+    docker-compose down
+    Pop-Location
+}
+```
+
+### Reiniciar una instancia
+
+```powershell
+cd instancia2
+docker-compose restart
+```
+
+## 📊 Tabla de Puertos Recomendados
+
+| Instancia  | Puerto Motor | Contenedor Engine  | Contenedor Cron   |
+| ---------- | ------------ | ------------------ | ----------------- |
+| instancia1 | 8089         | instancia1-odengin | instancia1-odcron |
+| instancia2 | 8090         | instancia2-odengin | instancia2-odcron |
+| instancia3 | 8091         | instancia3-odengin | instancia3-odcron |
+| instancia4 | 8092         | instancia4-odengin | instancia4-odcron |
+
+## 🔗 Cómo Funcionan las Variables de Entorno
+
+El `docker-compose.yml` usa variables para ser flexible:
+
+| Variable               | Uso                           | Valor Por Defecto                     |
+| ---------------------- | ----------------------------- | ------------------------------------- |
+| `COMPOSE_PROJECT_NAME` | Prefijo de nombres y redes    | `onedrive`                            |
+| `ENGINE_PORT`          | Puerto expuesto del motor     | `8089`                                |
+| `CRON_IP`              | Dirección del motor para cron | `{COMPOSE_PROJECT_NAME}-odengin:8080` |
+
+### Ejemplo de Expansión
+
+Con `COMPOSE_PROJECT_NAME=instancia1` y `ENGINE_PORT=8089`:
+
+```yaml
+container_name: instancia1-odengin
+ports: ["8089:8080"]
+hostname: instancia1-odengin
+networks:
+  - instancia1-net
+```
+
+## 🚨 Solución de Problemas
+
+### Error: "Port is already in use"
+
+**Causa:** Dos instancias intentan usar el mismo puerto.
+
+**Solución:** Verifica que cada instancia tenga un `ENGINE_PORT` único en su `.env`:
+
+```powershell
+# Ver qué puertos están en uso
+docker ps --format "table {{.Names}}\t{{.Ports}}"
+
+# Ver un puerto específico
+netstat -ano | findstr :8089
+```
+
+### Error: "Container name is already in use"
+
+**Causa:** Docker intenta crear un contenedor con nombre duplicado.
+
+**Solución:** Verifica que cada instancia tenga un `COMPOSE_PROJECT_NAME` único.
+
+### Los contenedores se detienen solos
+
+**Causa:** Probablemente hay un error en el script Python.
+
+**Solución:** Revisa los logs:
+
+```powershell
+docker-compose logs -f odengin
+docker-compose logs -f odcron
+```
+
+## 💡 Tips
+
+1. **Usa nombres descriptivos:** `cuenta-juan`, `cuenta-maria`, `cuenta-externa`
+2. **Documenta la configuración:** Crea un archivo `INSTANCIAS.txt` con la asignación
+3. **Automatiza con scripts:** Crea scripts para iniciar/detener todo de una vez
+4. **Monitorea recursos:** Con varias instancias, monitorea CPU y memoria
+
+## 📝 Script de Inicialización (Opcional)
+
+Crea un archivo `init-multi-instances.ps1`:
+
+```powershell
+param(
+    [int]$NumInstances = 3
+)
+
+for ($i = 1; $i -le $NumInstances; $i++) {
+    $instanceName = "instancia$i"
+    $port = 8088 + $i
+
+    Write-Host "Creando $instanceName en puerto $port..." -ForegroundColor Green
+
+    mkdir -Force "$instanceName/engine", "$instanceName/cron"
+    Copy-Item -Path "docker-compose.yml", ".env.example" -Destination "$instanceName"
+    Copy-Item -Path "engine\*" -Destination "$instanceName\engine" -Recurse -Force
+    Copy-Item -Path "cron\*" -Destination "$instanceName\cron" -Recurse -Force
+
+    # Crear .env
+    @"
+COMPOSE_PROJECT_NAME=$instanceName
+ENGINE_PORT=$port
+E5_CLIENT_ID=cambiar_aqui
+E5_CLIENT_SECRET=cambiar_aqui
+E5_REFRESH_TOKEN=cambiar_aqui
+WEB_APP_PASSWORD=cambiar_aqui
+E5_WEB_APP_PASSWORD=cambiar_aqui
+CRON_PASSWORD=cambiar_aqui
+CRON_REFRESH_TOKEN=cambiar_aqui
+"@ | Set-Content "$instanceName\.env"
+
+    Write-Host "$instanceName creada. Edita $instanceName\.env con tus credenciales" -ForegroundColor Yellow
+}
+```
+
+Uso:
+
+```powershell
+.\init-multi-instances.ps1 -NumInstances 3
+```

README.md

@@ -2,6 +2,12 @@
 
 Sistema automatizado para la renovación de Microsoft E5 usando Docker, compuesto por dos servicios principales que trabajan en conjunto.
 
+> **✨ Características Destacadas:**
+>
+> - 🚀 **Múltiples instancias** en la misma máquina sin conflictos → [Documentación](MULTI_INSTANCIAS.md)
+> - 🎯 **Despliegue en Dokploy** con gestión centralizada → [Guía Dokploy](DOKPLOY.md)
+> - 🔒 **Variables de entorno** seguras con archivos `.env`
+
 ## 📋 Descripción
 
 Este proyecto implementa un sistema de dos contenedores Docker:
@@ -9,19 +15,29 @@ Este proyecto implementa un sistema de dos contenedores Docker:
 - **odengin**: Motor principal que gestiona la renovación automática de Microsoft E5
 - **odcron**: Servicio de tareas programadas que se comunica con el motor principal
 
-## 🏗️ Arquitectura
+### Características
 
-```
+✅ Soporte para múltiples instancias en la misma máquina  
-┌─────────────────┐         ┌─────────────────┐
+✅ Compatible con Dokploy para gestión centralizada  
-│    odcron       │────────>│    odengin      │
+✅ Configuración con variables de entorno (`.env`)  
-│  (Scheduler)    │  HTTP   │    (Engine)     │
+✅ Redes Docker aisladas por instancia  
-│   Port: N/A     │         │   Port: 8080    │
+✅ Health checks automáticos  
-└─────────────────┘         └─────────────────┘
+✅ Reinicio automático de servicios  
-```
+✅ Fácil de escalar y mantener
 
-Los servicios se comunican a través de una red Docker privada (`odeng-net`).
+## 🎯 Métodos de Despliegue
 
-## 🚀 Inicio Rápido
+### Opción 1: Dokploy (Recomendado para múltiples instancias)
+
+Gestiona múltiples instancias desde una interfaz web con SSL, dominios y monitoreo.
+
+📖 **[Ver guía completa de Dokploy →](DOKPLOY.md)**
+
+### Opción 2: Docker Compose Local
+
+Despliegue tradicional en tu máquina local o servidor.
+
+👇 Continúa leyendo esta guía para instalación local.
 
 ### Prerrequisitos
 
@@ -117,22 +133,43 @@ El archivo `.env.example` se incluye como referencia para documentar qué variab
 ### Puertos
 
 - **8089**: Puerto expuesto del servicio odengin (mapea al 8080 interno)
+- Para múltiples instancias, usa puertos diferentes: 8089, 8090, 8091, etc.
+
+## 🚀 Múltiples Instancias
+
+Este proyecto está diseñado para ejecutar múltiples instancias en la misma máquina:
+
+```bash
+# Instancia 1 - Puerto 8089
+COMPOSE_PROJECT_NAME=instancia1 ENGINE_PORT=8089 docker-compose up -d
+
+# Instancia 2 - Puerto 8090
+COMPOSE_PROJECT_NAME=instancia2 ENGINE_PORT=8090 docker-compose up -d
+
+# Instancia 3 - Puerto 8091
+COMPOSE_PROJECT_NAME=instancia3 ENGINE_PORT=8091 docker-compose up -d
+```
+
+**Ver documentación completa de múltiples instancias:** [MULTI_INSTANCIAS.md](MULTI_INSTANCIAS.md)
 
 ## 📁 Estructura del Proyecto
 
 ```
 onedrive/
-├── docker-compose.yml      # Orquestación de servicios
+├── docker-compose.yml          # Compose para despliegue local/tradicional
-├── README.md              # Este archivo
+├── docker-compose.dokploy.yml  # Compose optimizado para Dokploy
-├── cron/                  # Servicio de tareas programadas
+├── README.md                   # Este archivo
+├── DOKPLOY.md                  # Guía completa para Dokploy
+├── MULTI_INSTANCIAS.md         # Guía para múltiples instancias locales
+├── .env.example                # Plantilla de configuración
+├── .gitignore                  # Archivos a ignorar
+├── cron/                       # Servicio de tareas programadas
 │   ├── Dockerfile
-│   ├── docker-compose.yml
 │   ├── requirements.txt
 │   ├── script.py
 │   └── README.md
-└── engine/                # Motor principal
+└── engine/                     # Motor principal
     ├── Dockerfile
-    ├── docker-compose.yml
     └── README.md
 ```
 

TROUBLESHOOTING.md

@@ -0,0 +1,229 @@
+# 🔧 Solución de Problemas - Dokploy
+
+## ❌ Error: `[Errno 2] No such file or directory`
+
+### Causa
+
+El Dockerfile intentaba copiar `script.py` pero el archivo no existía en el directorio `cron/`.
+
+### ✅ Solución Aplicada
+
+1. **Creado `script.py`** en el directorio `cron/`
+2. **Actualizado Dockerfiles** para mejor logging con flag `-u` (unbuffered output)
+3. **Mejorado healthcheck** para no depender de wget/curl
+
+### 📝 Archivos Corregidos
+
+- ✅ `cron/script.py` - Creado
+- ✅ `cron/Dockerfile` - Actualizado con `-u` flag
+- ✅ `engine/Dockerfile` - Actualizado con `-u` flag
+- ✅ `docker-compose.dokploy.yml` - Healthcheck mejorado
+
+### 🚀 Cómo Proceder en Dokploy
+
+1. **Commitea los cambios**:
+
+   ```bash
+   git add .
+   git commit -m "Fix: Add missing script.py and improve Dockerfiles"
+   git push
+   ```
+
+2. **En Dokploy UI**:
+
+   - Ve a tu proyecto
+   - Clic en **"Rebuild & Deploy"** (no solo "Deploy")
+   - Esto forzará rebuild de las imágenes con los nuevos archivos
+
+3. **Verifica los logs**:
+   - Service → Logs
+   - Deberías ver: `"Running initial test..."`
+
+---
+
+## 🔍 Otros Problemas Comunes
+
+### 1. Build Context Incorrecto
+
+**Síntoma**: `Cannot find Dockerfile` o `No such file or directory` durante build
+
+**Solución**:
+
+- En Dokploy: Build Path debe ser `./` (raíz del repo)
+- Compose File Path: `docker-compose.dokploy.yml`
+
+### 2. Variables de Entorno No Cargadas
+
+**Síntoma**: Servicios inician pero fallan al conectarse
+
+**Solución**:
+
+- Verifica que TODAS estas variables estén configuradas:
+  ```
+  E5_CLIENT_ID
+  E5_CLIENT_SECRET
+  E5_REFRESH_TOKEN
+  WEB_APP_PASSWORD
+  E5_WEB_APP_PASSWORD
+  CRON_PASSWORD
+  CRON_REFRESH_TOKEN
+  ```
+
+### 3. Healthcheck Falla
+
+**Síntoma**: El servicio se reinicia constantemente
+
+**Solución**:
+
+- Aumenta `start_period` a 60s o más
+- Verifica que el puerto 8080 esté correcto
+- Revisa logs para errores de inicio
+
+### 4. odcron No Puede Conectarse a odengin
+
+**Síntoma**: Logs de cron muestran "Connection refused"
+
+**Solución**:
+
+- Verifica que ambos servicios estén en la misma red
+- IP debe ser `odengin:8080` (nombre del servicio, no localhost)
+- Espera a que el healthcheck de odengin pase
+
+### 5. Puerto Ya en Uso
+
+**Síntoma**: `Address already in use` o `port is already allocated`
+
+**Solución**:
+
+- Cambia `ENGINE_PORT` en variables de entorno
+- O elimina el puerto y usa dominios de Dokploy
+
+---
+
+## 📊 Checklist de Deploy Exitoso
+
+Antes de hacer deploy:
+
+- [ ] Todos los archivos están en Git y pusheados
+- [ ] `script.py` existe en `cron/`
+- [ ] Dockerfiles tienen `CMD ["python", "-u", ...]`
+- [ ] Variables de entorno configuradas en Dokploy UI
+- [ ] Build Path: `./`
+- [ ] Compose File: `docker-compose.dokploy.yml`
+
+Después del deploy:
+
+- [ ] Ambos servicios muestran estado "Running"
+- [ ] Healthcheck pasa (ícono verde)
+- [ ] Logs de odengin muestran inicio exitoso
+- [ ] Logs de odcron muestran "Running initial test..."
+- [ ] No hay errores de conexión en logs
+
+---
+
+## 🔬 Debug Avanzado
+
+### Ver Logs en Tiempo Real
+
+En Dokploy UI:
+
+1. Service → Logs
+2. Activa "Follow" (auto-scroll)
+3. Busca por "error", "exception", "failed"
+
+### SSH al Contenedor
+
+```bash
+# Desde Dokploy UI: Service → Terminal
+# O desde SSH del servidor:
+docker exec -it <container-name> /bin/bash
+
+# Verificar archivos
+ls -la /app
+
+# Verificar proceso Python
+ps aux | grep python
+
+# Test manual del script
+cd /app
+python -u script.py
+```
+
+### Verificar Red Docker
+
+```bash
+# Listar redes
+docker network ls | grep onedrive
+
+# Inspeccionar red
+docker network inspect <network-name>
+
+# Verificar que ambos contenedores estén en la red
+```
+
+### Test de Conectividad
+
+```bash
+# Desde el contenedor odcron
+docker exec -it <odcron-container> /bin/bash
+ping odengin
+wget -O- http://odengin:8080
+```
+
+---
+
+## 💡 Tips Pro
+
+### 1. Unbuffered Output
+
+La flag `-u` en Python es crucial para Dokploy:
+
+```dockerfile
+CMD ["python", "-u", "script.py"]
+```
+
+Sin ella, los logs pueden no aparecer en tiempo real.
+
+### 2. Healthcheck Realista
+
+El healthcheck actual usa Python nativo (siempre disponible):
+
+```yaml
+test:
+  [
+    "CMD-SHELL",
+    'python -c ''import urllib.request; urllib.request.urlopen("http://localhost:8080")'' || exit 1',
+  ]
+```
+
+### 3. Start Period Generoso
+
+Dale tiempo al servicio de iniciar:
+
+```yaml
+start_period: 60s # 60 segundos antes de empezar healthchecks
+```
+
+### 4. Logs Estructurados
+
+El script usa `logging` de Python:
+
+```python
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+```
+
+Esto hace los logs más legibles en Dokploy.
+
+---
+
+## 📞 Necesitas Más Ayuda?
+
+1. **Revisa logs completos**: Service → Logs → Download
+2. **Verifica configuración**: Service → Settings
+3. **Rebuild limpio**: Service → "Clear Build Cache" → Rebuild
+
+Si el problema persiste, comparte:
+
+- Logs completos (últimas 50 líneas)
+- Variables de entorno configuradas (sin valores sensibles)
+- Output del build

cron/Dockerfile

@@ -2,9 +2,10 @@ FROM python:3.9-slim
 
 WORKDIR /app
 
-COPY requirements.txt .
+COPY . .
+
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY script.py .
 
-CMD ["python", "script.py"]
+CMD ["python", "-u", "script.py"]

cron/script.py

@@ -34,8 +34,8 @@ def main():
     # Ejecuta la prueba inicial
     initial_test()
 
-    # Programa la ejecución cada minuto
+    # Programa la ejecución cada 7 horas
-    schedule.every(1).minutes.do(perform_curl)
+    schedule.every(7).hours.do(perform_curl)
 
     # Bucle para mantener el script en ejecución
     while True:

docker-compose.dokploy.yml

@@ -0,0 +1,62 @@
+---
+# Docker Compose for Dokploy
+# Dokploy automáticamente maneja:
+# - Nombres únicos de contenedores por proyecto
+# - Redes aisladas
+# - Variables de entorno desde la UI
+
+services:
+  odengin:
+    build:
+      context: ./engine
+      dockerfile: Dockerfile
+    image: ${REGISTRY:-ghcr.io}/${IMAGE_OWNER:-user}/onedrive-engine:${IMAGE_TAG:-latest}
+    environment:
+      - E5_CLIENT_ID=${E5_CLIENT_ID}
+      - E5_CLIENT_SECRET=${E5_CLIENT_SECRET}
+      - E5_REFRESH_TOKEN=${E5_REFRESH_TOKEN}
+      - WEB_APP_PASSWORD=${WEB_APP_PASSWORD}
+      - E5_WEB_APP_PASSWORD=${E5_WEB_APP_PASSWORD}
+    ports:
+      - "${ENGINE_PORT:-8089}:8080"
+    restart: unless-stopped
+    networks:
+      - onedrive-net
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          'python -c ''import urllib.request; urllib.request.urlopen("http://localhost:8080")'' || exit 1',
+        ]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 60s
+    labels:
+      - "com.dokploy.project=onedrive"
+      - "com.dokploy.service=engine"
+
+  odcron:
+    build:
+      context: ./cron
+      dockerfile: Dockerfile
+    image: ${REGISTRY:-ghcr.io}/${IMAGE_OWNER:-user}/onedrive-cron:${IMAGE_TAG:-latest}
+    environment:
+      - IP=odengin:8080
+      - PASSWORD=${CRON_PASSWORD}
+      - REFRESH_TOKEN=${CRON_REFRESH_TOKEN}
+    restart: unless-stopped
+    networks:
+      - onedrive-net
+    depends_on:
+      odengin:
+        condition: service_healthy
+    labels:
+      - "com.dokploy.project=onedrive"
+      - "com.dokploy.service=cron"
+
+networks:
+  onedrive-net:
+    driver: bridge
+    labels:
+      - "com.dokploy.project=onedrive"

docker-compose.yml

@@ -1,8 +1,11 @@
 ---
+# Multi-instance compatible Docker Compose configuration
+# Para ejecutar múltiples instancias: docker-compose -f docker-compose.yml -p instancia1 up -d
+
 services:
   odengin:
     build: ./engine
-    container_name: odengin
+    container_name: ${COMPOSE_PROJECT_NAME:-onedrive}-odengin
     env_file: .env
     environment:
       - E5_CLIENT_ID=${E5_CLIENT_ID}
@@ -11,27 +14,34 @@ services:
       - WEB_APP_PASSWORD=${WEB_APP_PASSWORD}
       - E5_WEB_APP_PASSWORD=${E5_WEB_APP_PASSWORD}
     ports:
-      - "8089:8080"
+      - "${ENGINE_PORT:-8089}:8080"
     restart: unless-stopped
-    hostname: odengin
+    hostname: ${COMPOSE_PROJECT_NAME:-onedrive}-odengin
     networks:
-      - odeng-net
+      - ${COMPOSE_PROJECT_NAME:-onedrive}-net
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
 
   odcron:
     build: ./cron
-    container_name: odcron
+    container_name: ${COMPOSE_PROJECT_NAME:-onedrive}-odcron
     env_file: .env
     environment:
-      - IP=${CRON_IP:-odengin:8080}
+      - IP=${CRON_IP:-${COMPOSE_PROJECT_NAME:-onedrive}-odengin:8080}
       - PASSWORD=${CRON_PASSWORD}
       - REFRESH_TOKEN=${CRON_REFRESH_TOKEN}
     restart: unless-stopped
-    hostname: odcron
+    hostname: ${COMPOSE_PROJECT_NAME:-onedrive}-odcron
     networks:
-      - odeng-net
+      - ${COMPOSE_PROJECT_NAME:-onedrive}-net
     depends_on:
-      - odengin
+      odengin:
+        condition: service_healthy
 
 networks:
-  odeng-net:
+  ${COMPOSE_PROJECT_NAME:-onedrive}-net:
     driver: bridge

engine/Dockerfile

@@ -22,5 +22,5 @@ COPY . .
 # Exponer el puerto
 EXPOSE 8080
 
-# Establecer el comando de entrada
+# Establecer el comando de entrada con unbuffered output para mejor logging
-CMD ["python", "main.py"]
+CMD ["python", "-u", "main.py"]