cambio a 7 horas de intervalo

se agrega los puertos

.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

@@ -0,0 +1,31 @@
+# Microsoft E5 Auto-Renewal Configuration
+# 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
+E5_CLIENT_SECRET=your_client_secret_here
+E5_REFRESH_TOKEN=your_refresh_token_here
+
+# Web application passwords
+WEB_APP_PASSWORD=your_secure_password_here
+E5_WEB_APP_PASSWORD=your_e5_password_here
+
+# === Cron Service (odcron) Configuration ===
+# Engine connection (se genera automáticamente si no se especifica)
+# CRON_IP=odengin:8080
+
+# Authentication
+CRON_PASSWORD=your_cron_password_here
+CRON_REFRESH_TOKEN=your_cron_refresh_token_here

.gitignore

@@ -0,0 +1,53 @@
+# Environment variables
+.env
+.env.local
+.env.*.local
+.env.inst*
+.env.instancia*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Docker
+docker-compose.override.yml
+
+# Multiple instances directories
+instancia*/
+inst*/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Logs
+logs/
+*.log
+
+# Node modules (if applicable)
+node_modules/
+
+# OS
+Thumbs.db

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

@@ -1 +1,272 @@
-Pruebas con docker
+# OneDrive Engine
+
+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:
+
+- **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
+
+### Características
+
+✅ Soporte para múltiples instancias en la misma máquina  
+✅ Compatible con Dokploy para gestión centralizada  
+✅ Configuración con variables de entorno (`.env`)  
+✅ Redes Docker aisladas por instancia  
+✅ Health checks automáticos  
+✅ Reinicio automático de servicios  
+✅ Fácil de escalar y mantener
+
+## 🎯 Métodos de Despliegue
+
+### 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
+
+- Docker
+- Docker Compose
+- Credenciales de Microsoft E5:
+  - Client ID
+  - Client Secret
+  - Refresh Token
+
+### Instalación
+
+1. Clona el repositorio:
+
+```bash
+git clone <tu-repositorio>
+cd onedrive
+```
+
+2. Copia el archivo de configuración de ejemplo:
+
+```bash
+cp .env.example .env
+```
+
+3. Edita el archivo `.env` con tus credenciales:
+
+```bash
+# Linux/Mac
+nano .env
+
+# Windows
+notepad .env
+```
+
+4. Rellena todas las variables requeridas:
+
+```env
+E5_CLIENT_ID=tu_client_id
+E5_CLIENT_SECRET=tu_client_secret
+E5_REFRESH_TOKEN=tu_refresh_token
+WEB_APP_PASSWORD=tu_password_segura
+E5_WEB_APP_PASSWORD=tu_e5_password
+CRON_PASSWORD=tu_cron_password
+CRON_REFRESH_TOKEN=tu_cron_refresh_token
+```
+
+5. Inicia los servicios:
+
+```bash
+docker-compose up -d
+```
+
+6. Verifica el estado:
+
+```bash
+docker-compose ps
+docker-compose logs -f
+```
+
+## ⚙️ Configuración
+
+### Archivo `.env`
+
+El archivo `.env` contiene todas las variables de entorno necesarias. **Nunca** debes:
+
+- ❌ Subir `.env` a Git
+- ❌ Compartir `.env` públicamente
+- ❌ Guardar credenciales en el código
+
+El archivo `.env.example` se incluye como referencia para documentar qué variables se necesitan.
+
+### Variables de Entorno
+
+#### Servicio `odengin`
+
+| Variable              | Descripción                     | Requerida | Variable de Entorno   |
+| --------------------- | ------------------------------- | --------- | --------------------- |
+| `E5_CLIENT_ID`        | Client ID de Microsoft Azure    | ✅        | `E5_CLIENT_ID`        |
+| `E5_CLIENT_SECRET`    | Client Secret de Azure          | ✅        | `E5_CLIENT_SECRET`    |
+| `E5_REFRESH_TOKEN`    | Token de renovación             | ✅        | `E5_REFRESH_TOKEN`    |
+| `WEB_APP_PASSWORD`    | Contraseña de la aplicación web | ✅        | `WEB_APP_PASSWORD`    |
+| `E5_WEB_APP_PASSWORD` | Contraseña adicional E5         | ✅        | `E5_WEB_APP_PASSWORD` |
+
+#### Servicio `odcron`
+
+| Variable            | Descripción                                  | Requerida | Variable de Entorno  |
+| ------------------- | -------------------------------------------- | --------- | -------------------- |
+| IP del motor        | Dirección del motor (formato: `host:puerto`) | ✅        | `CRON_IP`            |
+| Contraseña          | Contraseña de autenticación                  | ✅        | `CRON_PASSWORD`      |
+| Token de renovación | Token de renovación                          | ✅        | `CRON_REFRESH_TOKEN` |
+
+### 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          # Compose para despliegue local/tradicional
+├── docker-compose.dokploy.yml  # Compose optimizado para Dokploy
+├── 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
+│   ├── requirements.txt
+│   ├── script.py
+│   └── README.md
+└── engine/                     # Motor principal
+    ├── Dockerfile
+    └── README.md
+```
+
+## 🔧 Comandos Útiles
+
+### Gestión de Contenedores
+
+```bash
+# Iniciar servicios
+docker-compose up -d
+
+# Detener servicios
+docker-compose down
+
+# Ver logs en tiempo real
+docker-compose logs -f
+
+# Ver logs de un servicio específico
+docker-compose logs -f odengin
+docker-compose logs -f odcron
+
+# Reiniciar servicios
+docker-compose restart
+
+# Reconstruir imágenes
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+### Monitoreo
+
+```bash
+# Estado de los contenedores
+docker-compose ps
+
+# Inspeccionar un contenedor
+docker inspect odengin
+
+# Acceder al shell de un contenedor
+docker exec -it odengin /bin/bash
+docker exec -it odcron /bin/bash
+```
+
+## 🔍 Troubleshooting
+
+### El servicio odengin no inicia
+
+- Verifica que las credenciales de E5 sean correctas
+- Revisa los logs: `docker-compose logs odengin`
+- Asegúrate de que el puerto 8089 no esté en uso
+
+### El servicio odcron no se conecta
+
+- Verifica que odengin esté corriendo: `docker-compose ps`
+- Confirma que la variable `IP` apunte a `odengin:8080`
+- Revisa la configuración de la red: `docker network inspect onedrive_odeng-net`
+
+### Problemas de red entre contenedores
+
+```bash
+# Verificar conectividad
+docker exec -it odcron ping odengin
+```
+
+## 🛡️ Seguridad
+
+### Gestión de Credenciales
+
+✅ **HACER:**
+
+- ✅ Usar archivo `.env` para variables sensibles
+- ✅ Incluir `.env` en `.gitignore`
+- ✅ Compartir solo `.env.example` con placeholders
+- ✅ Cambiar contraseñas por defecto
+- ✅ Restringir permisos del archivo `.env`: `chmod 600 .env`
+- ✅ Usar secretos de Docker/Kubernetes en producción
+
+❌ **NO HACER:**
+
+- ❌ Nunca subir `.env` a Git
+- ❌ No guardar credenciales en el código
+- ❌ No compartir `.env` por mensajes o email
+- ❌ No usar contraseñas débiles
+- ❌ No hacer commit accidental de `.env`
+
+### Verificar antes de subir
+
+```bash
+# Asegurate de que .env NO está en Git
+git status
+
+# Si fue agregado accidentalmente:
+git rm --cached .env
+git commit --amend -m "Remove .env from repository"
+```
+
+## 📝 Notas
+
+- Los contenedores se reinician automáticamente (`restart: unless-stopped`)
+- La comunicación entre servicios usa la red interna `odeng-net`

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

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

cron/README.md

@@ -0,0 +1,3 @@
+## Actualizado, puede contener errores
+
+

cron/docker-compose.yml

@@ -0,0 +1,12 @@
+---
+services:
+  odcron:
+    build: .
+    container_name: odcron
+    environment:
+      - IP=host:8080  # Cambia esto por la IP y puerto deseado
+      - PASSWORD=pass           # Cambia esto por la contraseña deseada
+      - REFRESH_TOKEN=tokenit   # Cambia esto por el token deseado
+    restart: unless-stopped
+    hostname: odcron
+    network_mode: bridge

cron/requirements.txt

@@ -0,0 +1,2 @@
+requests
+schedule

cron/script.py

@@ -0,0 +1,46 @@
+import requests
+import schedule
+import time
+import logging
+import os
+
+# Configuración del logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Leer variables de entorno
+IP = os.getenv("IP", "127.0.0.0:8080")  # IP y puerto por defecto
+PASSWORD = os.getenv("PASSWORD", "pass")  # Password por defecto
+REFRESH_TOKEN = os.getenv("REFRESH_TOKEN", "tokenit")  # Token por defecto
+
+# Construir la URL correctamente
+URL = f"http://{IP}/call"  # Incluye el protocolo y la ruta
+HEADERS = {"Content-Type": "application/json"}
+DATA = {"password": PASSWORD, "refresh_token": REFRESH_TOKEN}
+
+def perform_curl():
+    try:
+        # Realiza la solicitud POST
+        response = requests.post(URL, headers=HEADERS, json=DATA)
+        response.raise_for_status()  # Lanza una excepción si la respuesta no es exitosa
+        logging.info(f"Success: {response.status_code} - {response.text[:100]}...")  # Muestra solo los primeros 100 caracteres
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Error: {e}")
+
+def initial_test():
+    logging.info("Running initial test...")
+    perform_curl()
+
+def main():
+    # Ejecuta la prueba inicial
+    initial_test()
+
+    # Programa la ejecución cada 7 horas
+    schedule.every(7).hours.do(perform_curl)
+
+    # Bucle para mantener el script en ejecución
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,47 @@
+---
+# 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: ${COMPOSE_PROJECT_NAME:-onedrive}-odengin
+    env_file: .env
+    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
+    hostname: ${COMPOSE_PROJECT_NAME:-onedrive}-odengin
+    networks:
+      - ${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: ${COMPOSE_PROJECT_NAME:-onedrive}-odcron
+    env_file: .env
+    environment:
+      - IP=${CRON_IP:-${COMPOSE_PROJECT_NAME:-onedrive}-odengin:8080}
+      - PASSWORD=${CRON_PASSWORD}
+      - REFRESH_TOKEN=${CRON_REFRESH_TOKEN}
+    restart: unless-stopped
+    hostname: ${COMPOSE_PROJECT_NAME:-onedrive}-odcron
+    networks:
+      - ${COMPOSE_PROJECT_NAME:-onedrive}-net
+    depends_on:
+      odengin:
+        condition: service_healthy
+
+networks:
+  ${COMPOSE_PROJECT_NAME:-onedrive}-net:
+    driver: bridge

engine/Dockerfile

@@ -0,0 +1,26 @@
+# Usar una imagen base más ligera y específica
+FROM python:3.9-slim
+
+# Establecer el directorio de trabajo
+WORKDIR /app
+
+# Instalar dependencias del sistema y limpiar caché en un solo RUN
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git wget && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Clonar el repositorio
+RUN git clone https://github.com/TheCaduceus/Microsoft-E5-Auto-Renewal /app
+
+# Instalar dependencias de Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar el resto de los archivos
+COPY . .
+
+# Exponer el puerto
+EXPOSE 8080
+
+# Establecer el comando de entrada con unbuffered output para mejor logging
+CMD ["python", "-u", "main.py"]

engine/README.md

@@ -0,0 +1,2 @@
+## Actualizado, puede contener errores
+

engine/docker-compose.yml

@@ -0,0 +1,16 @@
+---
+services:
+  odengin:
+    build: .
+    container_name: odengin
+    environment:
+      - E5_CLIENT_ID=id
+      - E5_CLIENT_SECRET=secret
+      - E5_REFRESH_TOKEN=tokenit
+      - WEB_APP_PASSWORD=123
+      - E5_WEB_APP_PASSWORD=123
+    ports:
+      - 8089:8080
+    restart: unless-stopped
+    hostname: odengin
+    network_mode: bridge

nosleep-oracle/Dockerfile

@@ -1,13 +0,0 @@
-FROM ubuntu
-
-RUN apt update && apt upgrade -y && apt install wget -y
-
-RUN wget https://github.com/layou233/NeverIdle/releases/download/0.2.3/NeverIdle-linux-arm64 -O NeverIdle
-
-RUN chmod 777 NeverIdle
-
-COPY . .
-
-RUN chmod +x test.sh
-
-ENTRYPOINT ./test.sh

nosleep-oracle/test.sh

@@ -1 +0,0 @@
-./NeverIdle -c 2h1m2s -m 2 -n 4h

onedrive/cron/Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu
-
-WORKDIR /app
-
-RUN apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano wget curl -y
-
-RUN pip install schedule
-
-COPY . .
-
-ENV IP_PING="http://127.0.0.1:8080/call"
-
-ENV TOKEN="token"
-
-ENV PASSWORD_WEB="pass"
-
-ENV SUPERCOMANDO='curl -X POST -H "Content-Type: application/json" -d '{"password": "$PASSWORD_WEB" ,"refresh_token": "$TOKEN"}' "$IP_PING"'
-
-RUN chmod +x run.sh
-
-ENTRYPOINT ./run.sh

onedrive/cron/README.md

@@ -1,6 +0,0 @@
-## actualmente da error
-
-#### manual
-```sh
-apt update && apt install wget -y && bash -c "$(wget -qLO - https://raw.githubusercontent.com/kadma/pruebasdocker/main/onedrive/cron/script.sh)"
-```

onedrive/cron/cron1m.py

@@ -1,21 +0,0 @@
-import os
-import schedule
-import time
-import subprocess
-
-def ejecutar_comando():
-    comando = os.environ.get('SUPERCOMANDO', default=None)
-
-    if comando is not None:
-        subprocess.run(comando, shell=True)
-    else:
-        print("La variable de entorno no tiene un valor definido.")
-
-schedule.every(1).minutes.do(ejecutar_comando)
-
-while True:
-    # Ejecuta las tareas pendientes
-    schedule.run_pending()
-    
-    # Espera 1 segundo antes de volver a verificar
-    time.sleep(1)

onedrive/cron/cron7h.py

@@ -1,21 +0,0 @@
-import os
-import schedule
-import time
-import subprocess
-
-def ejecutar_comando():
-    comando = os.environ.get('SUPERCOMANDO', default=None)
-
-    if comando is not None:
-        subprocess.run(comando, shell=True)
-    else:
-        print("La variable de entorno no tiene un valor definido.")
-
-schedule.every(7).hours.do(ejecutar_comando)
-
-while True:
-    # Ejecuta las tareas pendientes
-    schedule.run_pending()
-    
-    # Espera 1 segundo antes de volver a verificar
-    time.sleep(1)

onedrive/cron/run.sh

@@ -1 +0,0 @@
-python3 cron7h.py

onedrive/cron/script.sh

@@ -1,4 +0,0 @@
-apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano curl -y
-pip3 install schedule
-wget -b -P /app/ https://raw.githubusercontent.com/kadma/pruebasdocker/main/onedrive/cron/cron1m.py
-wget -b -P /app/ https://raw.githubusercontent.com/kadma/pruebasdocker/main/onedrive/cron/cron7h.py

onedrive/engine/Dockerfile

@@ -1,25 +0,0 @@
-FROM ubuntu
-
-WORKDIR /app
-
-RUN apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano wget -y
-
-RUN git clone https://github.com/TheCaduceus/Microsoft-E5-Auto-Renewal /app
-
-RUN pip install -r requirements.txt
-
-COPY . .
-
-ENV E5_CLIENT_ID="id"
-
-ENV E5_CLIENT_SECRET="secret"
-
-ENV E5_REFRESH_TOKEN="token"
-
-ENV WEB_APP_PASSWORD="pass"
-
-EXPOSE 8080
-
-RUN chmod +x run.sh
-
-ENTRYPOINT ./run.sh

onedrive/engine/README.md

@@ -1,6 +0,0 @@
-## sin actualziar
-
-#### manual
-```sh
-apt update && apt install wget -y && bash -c "$(wget -qLO - https://raw.githubusercontent.com/kadma/pruebasdocker/main/onedrive/engine/script.sh)"
-```

onedrive/engine/run.sh

@@ -1 +0,0 @@
-python3 main.py

onedrive/engine/script.sh

@@ -1,4 +0,0 @@
-apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano curl -y
-git clone https://github.com/TheCaduceus/Microsoft-E5-Auto-Renewal /app
-pip3 install -r /app/requirements.txt
-python3 /app/main.py

rclone-gui/Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu
-
-RUN apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano wget -y
-
-ENV URL_DESCARGA_RCLONE="https://downloads.rclone.org/v1.65.0/rclone-v1.65.0-linux-amd64.deb"
-
-EXPOSE 5572
-
-WORKDIR /app
-
-RUN wget $URL_DESCARGA_RCLONE
-
-RUN dpkg -i rclone-v1.65.0-linux-amd64.deb
-
-ENV USER_RCLONE=adm	PASSWORD_RCLONE=pass
-
-RUN wget https://raw.githubusercontent.com/kadma/pruebasdocker/main/rclone-gui/test.sh
-
-RUN chmod +x test.sh
-
-ENTRYPOINT ./test.sh

rclone-gui/test.sh

@@ -1 +0,0 @@
-rclone rcd --rc-web-gui --rc-addr :5572 --rc-serve --rc-user=$USER_RCLONE --rc-pass=$PASSWORD_RCLONE --rc-no-auth --config "/root/.config/rclone/rclone.conf" --user-agent "Mozilla" --transfers 24

rclone-webdav/Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu
-
-RUN apt update && apt upgrade -y && apt autoremove -y && apt install python3 python3-pip -y && apt install git nano wget -y
-
-ENV URL_DESCARGA_RCLONE="https://downloads.rclone.org/v1.66.0/rclone-v1.66.0-linux-amd64.deb"
-
-WORKDIR /app
-
-RUN wget $URL_DESCARGA_RCLONE
-
-RUN dpkg -i rclone-v1.66.0-linux-amd64.deb
-
-RUN rm rclone-v1.66.0-linux-amd64.deb
-
-ENV USER_RCLONE=adm	PASSWORD_RCLONE=pass
-
-RUN wget https://raw.githubusercontent.com/kadma/pruebasdocker/main/rclone-webdav/test.sh
-
-RUN chmod +x test.sh
-
-ENTRYPOINT ./test.sh

rclone-webdav/docker-compose.yaml

@@ -1,11 +0,0 @@
----
-services:
-  rclone-webdav:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: rclone-webdav
-    volumes:
-      - /path/to/config:/root/.config/rclone
-    restart: unless-stopped
-    network_mode: bridge

rclone-webdav/test.sh

@@ -1,4 +0,0 @@
-rclone serve webdav --vfs-cache-mode writes --addr :80 drive: --buffer-size 250M --vfs-read-chunk-size 256M --ignore-size --ignore-checksum --update & 
-rclone serve webdav --vfs-cache-mode writes --addr :81 drive1: --buffer-size 250M --vfs-read-chunk-size 256M --ignore-size --ignore-checksum --update & 
-rclone serve webdav --vfs-cache-mode writes --addr :82 drive2: --buffer-size 250M --vfs-read-chunk-size 256M --ignore-size --ignore-checksum --update & 
-rclone serve webdav --vfs-cache-mode writes --addr :83 drive3: --buffer-size 250M --vfs-read-chunk-size 256M --ignore-size --ignore-checksum --update