initial commit - vibe coded with claude

Dockerfile

@@ -0,0 +1,44 @@
+FROM python:3.11-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    wget \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install whisper.cpp
+WORKDIR /tmp
+RUN git clone https://github.com/ggerganov/whisper.cpp.git && \
+    cd whisper.cpp && \
+    make && \
+    cp main /usr/local/bin/whisper.cpp && \
+    chmod +x /usr/local/bin/whisper.cpp
+
+# Download whisper model
+RUN mkdir -p /models && \
+    cd /models && \
+    wget -q https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin && \
+    mv ggml-base.en.bin ggml-base.bin
+
+# Set up application directory
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY agent.py .
+
+# Create directories for videos
+RUN mkdir -p /raw_movies /final_movies
+
+# Set environment variables with defaults
+ENV RAW_DIR=/raw_movies \
+    FINAL_DIR=/final_movies \
+    WHISPER_MODEL=/models/ggml-base.bin \
+    VAAPI_DEVICE=/dev/dri/renderD128
+
+CMD ["python", "-u", "agent.py"]

Dockerfile.init

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+# Install curl, wget and other utilities
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    jq \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python requests library
+RUN pip install --no-cache-dir requests
+
+WORKDIR /app
+
+# The init script will be mounted
+CMD ["/bin/bash"]

PRODUCTION.md

@@ -0,0 +1,875 @@
+# Production Deployment Guide
+
+Complete guide for running the Movie Scheduler in production environments.
+
+## Table of Contents
+1. [Prerequisites](#prerequisites)
+2. [Deployment Options](#deployment-options)
+3. [Installation Methods](#installation-methods)
+4. [Configuration](#configuration)
+5. [Security](#security)
+6. [Monitoring](#monitoring)
+7. [Backup & Recovery](#backup--recovery)
+8. [Maintenance](#maintenance)
+9. [Troubleshooting](#troubleshooting)
+
+---
+
+## Prerequisites
+
+### Hardware Requirements
+
+**Minimum:**
+- CPU: 4 cores (for whisper.cpp and encoding)
+- RAM: 4GB
+- Storage: 100GB+ (depends on video library size)
+- GPU: Intel/AMD with VAAPI support (optional but recommended)
+
+**Recommended:**
+- CPU: 8+ cores
+- RAM: 8GB+
+- Storage: 500GB+ SSD
+- GPU: Modern Intel/AMD GPU with VAAPI
+
+### Software Requirements
+
+- **OS**: Linux (Ubuntu 20.04+, Debian 11+, RHEL 8+, or compatible)
+- **Python**: 3.7+
+- **FFmpeg**: With VAAPI support
+- **whisper.cpp**: Compiled and in PATH
+- **Network**: Stable connection to NocoDB and RTMP server
+
+---
+
+## Deployment Options
+
+### Option 1: Systemd Service (Recommended for bare metal)
+✅ Direct hardware access (best VAAPI performance)
+✅ Low overhead
+✅ System integration
+❌ Manual dependency management
+
+### Option 2: Docker Container (Recommended for most users)
+✅ Isolated environment
+✅ Easy updates
+✅ Portable configuration
+⚠️ Slight performance overhead
+⚠️ Requires GPU passthrough for VAAPI
+
+### Option 3: Kubernetes/Orchestration
+✅ High availability
+✅ Auto-scaling
+✅ Cloud-native
+❌ Complex setup
+❌ Overkill for single-instance deployment
+
+---
+
+## Installation Methods
+
+### Method 1: Systemd Service Installation
+
+#### 1. Create Scheduler User
+
+```bash
+# Create dedicated user for security
+sudo useradd -r -s /bin/bash -d /opt/scheduler -m scheduler
+
+# Add to video group for GPU access
+sudo usermod -aG video,render scheduler
+```
+
+#### 2. Install Dependencies
+
+```bash
+# Install system packages
+sudo apt-get update
+sudo apt-get install -y python3 python3-pip python3-venv ffmpeg git build-essential
+
+# Install whisper.cpp
+sudo -u scheduler git clone https://github.com/ggerganov/whisper.cpp.git /tmp/whisper.cpp
+cd /tmp/whisper.cpp
+make
+sudo cp main /usr/local/bin/whisper.cpp
+sudo chmod +x /usr/local/bin/whisper.cpp
+
+# Download whisper model
+sudo mkdir -p /opt/models
+cd /opt/models
+sudo wget https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin
+sudo mv ggml-base.en.bin ggml-base.bin
+sudo chown -R scheduler:scheduler /opt/models
+```
+
+#### 3. Deploy Application
+
+```bash
+# Create application directory
+sudo mkdir -p /opt/scheduler
+sudo chown scheduler:scheduler /opt/scheduler
+
+# Copy application files
+sudo -u scheduler cp agent.py /opt/scheduler/
+sudo -u scheduler cp requirements.txt /opt/scheduler/
+
+# Create Python virtual environment
+sudo -u scheduler python3 -m venv /opt/scheduler/venv
+sudo -u scheduler /opt/scheduler/venv/bin/pip install -r /opt/scheduler/requirements.txt
+```
+
+#### 4. Configure Storage
+
+```bash
+# Create storage directories (adjust paths as needed)
+sudo mkdir -p /mnt/storage/raw_movies
+sudo mkdir -p /mnt/storage/final_movies
+sudo chown -R scheduler:scheduler /mnt/storage
+```
+
+#### 5. Configure Service
+
+```bash
+# Copy service file
+sudo cp scheduler.service /etc/systemd/system/
+
+# Create environment file with secrets
+sudo mkdir -p /etc/scheduler
+sudo nano /etc/scheduler/scheduler.env
+```
+
+Edit `/etc/scheduler/scheduler.env`:
+```bash
+NOCODB_URL=https://your-nocodb.com/api/v2/tables/YOUR_TABLE_ID/records
+NOCODB_TOKEN=your_production_token
+RTMP_SERVER=rtmp://your-rtmp-server.com/live/stream
+RAW_DIR=/mnt/storage/raw_movies
+FINAL_DIR=/mnt/storage/final_movies
+WHISPER_MODEL=/opt/models/ggml-base.bin
+```
+
+Update `scheduler.service` to use the environment file:
+```ini
+# Replace Environment= lines with:
+EnvironmentFile=/etc/scheduler/scheduler.env
+```
+
+#### 6. Enable and Start Service
+
+```bash
+# Reload systemd
+sudo systemctl daemon-reload
+
+# Enable service (start on boot)
+sudo systemctl enable scheduler
+
+# Start service
+sudo systemctl start scheduler
+
+# Check status
+sudo systemctl status scheduler
+
+# View logs
+sudo journalctl -u scheduler -f
+```
+
+---
+
+### Method 2: Docker Deployment
+
+#### 1. Prepare Environment
+
+```bash
+# Create project directory
+mkdir -p /opt/scheduler
+cd /opt/scheduler
+
+# Copy application files
+cp agent.py requirements.txt Dockerfile docker-compose.prod.yml ./
+
+# Create production environment file
+cp .env.production.example .env.production
+nano .env.production  # Fill in your values
+```
+
+#### 2. Configure Storage
+
+```bash
+# Ensure storage directories exist
+mkdir -p /mnt/storage/raw_movies
+mkdir -p /mnt/storage/final_movies
+
+# Download whisper model
+mkdir -p /opt/models
+cd /opt/models
+wget https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin
+mv ggml-base.en.bin ggml-base.bin
+```
+
+#### 3. Deploy Container
+
+```bash
+cd /opt/scheduler
+
+# Build image
+docker compose -f docker-compose.prod.yml build
+
+# Start service
+docker compose -f docker-compose.prod.yml up -d
+
+# Check logs
+docker compose -f docker-compose.prod.yml logs -f
+
+# Check status
+docker compose -f docker-compose.prod.yml ps
+```
+
+#### 4. Enable Auto-Start
+
+```bash
+# Create systemd service for docker compose
+sudo nano /etc/systemd/system/scheduler-docker.service
+```
+
+```ini
+[Unit]
+Description=Movie Scheduler (Docker)
+Requires=docker.service
+After=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=/opt/scheduler
+ExecStart=/usr/bin/docker compose -f docker-compose.prod.yml up -d
+ExecStop=/usr/bin/docker compose -f docker-compose.prod.yml down
+TimeoutStartSec=0
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable scheduler-docker
+```
+
+---
+
+## Configuration
+
+### Essential Configuration
+
+#### NocoDB Connection
+
+```bash
+# Get your table ID from NocoDB URL
+# https://nocodb.com/nc/YOUR_BASE_ID/table_NAME
+# API endpoint: https://nocodb.com/api/v2/tables/TABLE_ID/records
+
+# Generate API token in NocoDB:
+# Account Settings → Tokens → Create Token
+```
+
+#### RTMP Server
+
+```bash
+# For nginx-rtmp:
+RTMP_SERVER=rtmp://your-server.com:1935/live/stream
+
+# For other RTMP servers, use their endpoint format
+```
+
+#### Storage Paths
+
+```bash
+# Use separate fast storage for final videos (streaming)
+RAW_DIR=/mnt/storage/raw_movies      # Can be slower storage
+FINAL_DIR=/mnt/fast-storage/final    # Should be fast SSD
+
+# Ensure proper permissions
+chown -R scheduler:scheduler /mnt/storage
+chmod 755 /mnt/storage/raw_movies
+chmod 755 /mnt/fast-storage/final
+```
+
+### Performance Tuning
+
+#### Sync Intervals
+
+```bash
+# High-load scenario (many jobs, frequent updates)
+NOCODB_SYNC_INTERVAL_SECONDS=120  # Check less often
+WATCHDOG_CHECK_INTERVAL_SECONDS=15  # Check streams less often
+
+# Low-latency scenario (need fast response)
+NOCODB_SYNC_INTERVAL_SECONDS=30
+WATCHDOG_CHECK_INTERVAL_SECONDS=5
+
+# Default (balanced)
+NOCODB_SYNC_INTERVAL_SECONDS=60
+WATCHDOG_CHECK_INTERVAL_SECONDS=10
+```
+
+#### FFmpeg VAAPI
+
+```bash
+# Find your VAAPI device
+ls -la /dev/dri/
+
+# Common devices:
+# renderD128 - Primary GPU
+# renderD129 - Secondary GPU
+
+# Test VAAPI
+ffmpeg -hwaccel vaapi -vaapi_device /dev/dri/renderD128 -i test.mp4 -f null -
+
+# Set in config
+VAAPI_DEVICE=/dev/dri/renderD128
+```
+
+---
+
+## Security
+
+### Secrets Management
+
+**DO NOT hardcode secrets in files tracked by git!**
+
+#### Option 1: Environment Files (Simple)
+
+```bash
+# Store secrets in protected file
+sudo nano /etc/scheduler/scheduler.env
+sudo chmod 600 /etc/scheduler/scheduler.env
+sudo chown scheduler:scheduler /etc/scheduler/scheduler.env
+```
+
+#### Option 2: Secrets Management Tools
+
+```bash
+# Using Vault
+export NOCODB_TOKEN=$(vault kv get -field=token secret/scheduler/nocodb)
+
+# Using AWS Secrets Manager
+export NOCODB_TOKEN=$(aws secretsmanager get-secret-value --secret-id scheduler/nocodb --query SecretString --output text)
+
+# Using Docker Secrets (Swarm/Kubernetes)
+# Mount secrets as files and read in application
+```
+
+### Filesystem Permissions
+
+```bash
+# Application directory
+chown -R scheduler:scheduler /opt/scheduler
+chmod 750 /opt/scheduler
+
+# Storage directories
+chown -R scheduler:scheduler /mnt/storage
+chmod 755 /mnt/storage/raw_movies      # Read-only for scheduler
+chmod 755 /mnt/storage/final_movies    # Read-write for scheduler
+
+# Database file
+chmod 600 /opt/scheduler/scheduler.db
+chown scheduler:scheduler /opt/scheduler/scheduler.db
+```
+
+### Network Security
+
+```bash
+# Firewall rules (if scheduler runs on separate server)
+# Only allow outbound connections to NocoDB and RTMP
+
+sudo ufw allow out to YOUR_NOCODB_IP port 443  # HTTPS
+sudo ufw allow out to YOUR_RTMP_IP port 1935   # RTMP
+sudo ufw default deny outgoing  # Deny all other outbound (optional)
+```
+
+### Regular Updates
+
+```bash
+# Update system packages weekly
+sudo apt-get update && sudo apt-get upgrade
+
+# Update Python dependencies
+sudo -u scheduler /opt/scheduler/venv/bin/pip install --upgrade requests
+
+# Rebuild whisper.cpp quarterly (for performance improvements)
+```
+
+---
+
+## Monitoring
+
+### Service Health
+
+#### Systemd Monitoring
+
+```bash
+# Check service status
+systemctl status scheduler
+
+# View recent logs
+journalctl -u scheduler -n 100
+
+# Follow logs in real-time
+journalctl -u scheduler -f
+
+# Check for errors in last hour
+journalctl -u scheduler --since "1 hour ago" | grep ERROR
+
+# Service restart count
+systemctl show scheduler | grep NRestarts
+```
+
+#### Docker Monitoring
+
+```bash
+# Container status
+docker compose -f docker-compose.prod.yml ps
+
+# Resource usage
+docker stats movie_scheduler
+
+# Logs
+docker compose -f docker-compose.prod.yml logs --tail=100 -f
+
+# Health check status
+docker inspect movie_scheduler | jq '.[0].State.Health'
+```
+
+### Database Monitoring
+
+```bash
+# Check job status
+sqlite3 /opt/scheduler/scheduler.db "SELECT prep_status, play_status, COUNT(*) FROM jobs GROUP BY prep_status, play_status;"
+
+# Active streams
+sqlite3 /opt/scheduler/scheduler.db "SELECT nocodb_id, title, play_status, stream_retry_count FROM jobs WHERE play_status='streaming';"
+
+# Failed jobs
+sqlite3 /opt/scheduler/scheduler.db "SELECT nocodb_id, title, prep_status, play_status, log FROM jobs WHERE prep_status='failed' OR play_status='failed';"
+
+# Database size
+ls -lh /opt/scheduler/scheduler.db
+```
+
+### Automated Monitoring Script
+
+Create `/opt/scheduler/monitor.sh`:
+
+```bash
+#!/bin/bash
+
+LOG_FILE="/var/log/scheduler-monitor.log"
+DB_PATH="/opt/scheduler/scheduler.db"
+
+echo "=== Scheduler Monitor - $(date) ===" >> "$LOG_FILE"
+
+# Check if service is running
+if systemctl is-active --quiet scheduler; then
+    echo "✓ Service is running" >> "$LOG_FILE"
+else
+    echo "✗ Service is DOWN" >> "$LOG_FILE"
+    # Send alert (email, Slack, etc.)
+    systemctl start scheduler
+fi
+
+# Check for failed jobs
+FAILED=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE prep_status='failed' OR play_status='failed';")
+if [ "$FAILED" -gt 0 ]; then
+    echo "⚠ Found $FAILED failed jobs" >> "$LOG_FILE"
+    # Send alert
+fi
+
+# Check active streams
+STREAMING=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE play_status='streaming';")
+echo "Active streams: $STREAMING" >> "$LOG_FILE"
+
+# Check disk space
+DISK_USAGE=$(df -h /mnt/storage | tail -1 | awk '{print $5}' | sed 's/%//')
+if [ "$DISK_USAGE" -gt 90 ]; then
+    echo "⚠ Disk usage is ${DISK_USAGE}%" >> "$LOG_FILE"
+    # Send alert
+fi
+
+echo "" >> "$LOG_FILE"
+```
+
+```bash
+# Make executable
+chmod +x /opt/scheduler/monitor.sh
+
+# Add to crontab (check every 5 minutes)
+(crontab -l 2>/dev/null; echo "*/5 * * * * /opt/scheduler/monitor.sh") | crontab -
+```
+
+### External Monitoring
+
+#### Prometheus + Grafana
+
+Export metrics using node_exporter or custom exporter:
+
+```bash
+# Install node_exporter for system metrics
+# Create custom exporter for job metrics from database
+# Set up Grafana dashboard
+```
+
+#### Uptime Monitoring
+
+Use services like:
+- UptimeRobot
+- Pingdom
+- Datadog
+
+Monitor:
+- Service availability
+- RTMP server connectivity
+- NocoDB API accessibility
+
+---
+
+## Backup & Recovery
+
+### What to Backup
+
+1. **Database** (scheduler.db) - Critical
+2. **Configuration** (.env.production or /etc/scheduler/scheduler.env) - Critical
+3. **Final videos** (if you want to keep processed videos)
+4. **Logs** (optional, for forensics)
+
+### Backup Script
+
+Create `/opt/scheduler/backup.sh`:
+
+```bash
+#!/bin/bash
+
+BACKUP_DIR="/backup/scheduler"
+DATE=$(date +%Y%m%d_%H%M%S)
+DB_PATH="/opt/scheduler/scheduler.db"
+CONFIG_PATH="/etc/scheduler/scheduler.env"
+
+# Create backup directory
+mkdir -p "$BACKUP_DIR"
+
+# Backup database
+cp "$DB_PATH" "$BACKUP_DIR/scheduler_${DATE}.db"
+
+# Backup config (careful with secrets!)
+cp "$CONFIG_PATH" "$BACKUP_DIR/config_${DATE}.env"
+
+# Compress old backups
+find "$BACKUP_DIR" -name "*.db" -mtime +7 -exec gzip {} \;
+
+# Delete backups older than 30 days
+find "$BACKUP_DIR" -name "*.db.gz" -mtime +30 -delete
+find "$BACKUP_DIR" -name "*.env" -mtime +30 -delete
+
+# Optional: Upload to S3/cloud storage
+# aws s3 sync "$BACKUP_DIR" s3://your-bucket/scheduler-backups/
+
+echo "Backup completed: $BACKUP_DIR/scheduler_${DATE}.db"
+```
+
+```bash
+# Make executable
+chmod +x /opt/scheduler/backup.sh
+
+# Run daily at 2 AM
+(crontab -l 2>/dev/null; echo "0 2 * * * /opt/scheduler/backup.sh") | crontab -
+```
+
+### Recovery Procedure
+
+#### 1. Restore from Backup
+
+```bash
+# Stop service
+sudo systemctl stop scheduler
+
+# Restore database
+cp /backup/scheduler/scheduler_YYYYMMDD_HHMMSS.db /opt/scheduler/scheduler.db
+chown scheduler:scheduler /opt/scheduler/scheduler.db
+
+# Restore config if needed
+cp /backup/scheduler/config_YYYYMMDD_HHMMSS.env /etc/scheduler/scheduler.env
+
+# Start service
+sudo systemctl start scheduler
+```
+
+#### 2. Disaster Recovery (Full Rebuild)
+
+If server is completely lost:
+
+1. Provision new server
+2. Follow installation steps above
+3. Restore database and config from backup
+4. Restart service
+5. Verify jobs are picked up
+
+**Recovery Time Objective (RTO):** 30-60 minutes
+**Recovery Point Objective (RPO):** Up to 24 hours (with daily backups)
+
+---
+
+## Maintenance
+
+### Routine Tasks
+
+#### Daily
+- ✓ Check service status
+- ✓ Review error logs
+- ✓ Check failed jobs
+
+#### Weekly
+- ✓ Review disk space
+- ✓ Check database size
+- ✓ Clean up old processed videos (if not needed)
+
+#### Monthly
+- ✓ Update system packages
+- ✓ Review and optimize database
+- ✓ Test backup restoration
+- ✓ Review and rotate logs
+
+### Database Maintenance
+
+```bash
+# Vacuum database (reclaim space, optimize)
+sqlite3 /opt/scheduler/scheduler.db "VACUUM;"
+
+# Analyze database (update statistics)
+sqlite3 /opt/scheduler/scheduler.db "ANALYZE;"
+
+# Clean up old completed jobs (optional)
+sqlite3 /opt/scheduler/scheduler.db "DELETE FROM jobs WHERE play_status='done' AND datetime(run_at) < datetime('now', '-30 days');"
+```
+
+### Log Rotation
+
+For systemd (automatic via journald):
+```bash
+# Configure in /etc/systemd/journald.conf
+SystemMaxUse=1G
+RuntimeMaxUse=100M
+```
+
+For Docker:
+```yaml
+# Already configured in docker-compose.prod.yml
+logging:
+  driver: "json-file"
+  options:
+    max-size: "10m"
+    max-file: "5"
+```
+
+### Video Cleanup
+
+```bash
+# Clean up old final videos (adjust retention as needed)
+find /mnt/storage/final_movies -name "*.mp4" -mtime +7 -delete
+
+# Or move to archive
+find /mnt/storage/final_movies -name "*.mp4" -mtime +7 -exec mv {} /mnt/archive/ \;
+```
+
+---
+
+## Troubleshooting
+
+### Service Won't Start
+
+```bash
+# Check service status
+systemctl status scheduler
+
+# Check logs for errors
+journalctl -u scheduler -n 50
+
+# Common issues:
+# 1. Missing environment variables
+grep -i "error" /var/log/syslog | grep scheduler
+
+# 2. Permission issues
+ls -la /opt/scheduler
+ls -la /mnt/storage
+
+# 3. GPU access issues
+ls -la /dev/dri/
+groups scheduler  # Should include 'video' and 'render'
+```
+
+### Streams Keep Failing
+
+```bash
+# Test RTMP server manually
+ffmpeg -re -i test.mp4 -c copy -f flv rtmp://your-server/live/stream
+
+# Check network connectivity
+ping your-rtmp-server.com
+telnet your-rtmp-server.com 1935
+
+# Review stream logs
+journalctl -u scheduler | grep -A 10 "Stream crashed"
+
+# Check retry count
+sqlite3 /opt/scheduler/scheduler.db "SELECT nocodb_id, title, stream_retry_count FROM jobs WHERE play_status='streaming';"
+```
+
+### High CPU/Memory Usage
+
+```bash
+# Check resource usage
+top -u scheduler
+
+# Or for Docker
+docker stats movie_scheduler
+
+# Common causes:
+# 1. Large video file encoding - normal, wait for completion
+# 2. whisper.cpp using all cores - normal
+# 3. Multiple prep jobs running - adjust or wait
+
+# Limit resources if needed (systemd)
+systemctl edit scheduler
+# Add:
+[Service]
+CPUQuota=200%
+MemoryMax=4G
+```
+
+### Database Locked Errors
+
+```bash
+# Check for stale locks
+lsof /opt/scheduler/scheduler.db
+
+# Kill stale processes if needed
+# Restart service
+systemctl restart scheduler
+```
+
+### VAAPI Not Working
+
+```bash
+# Verify VAAPI support
+vainfo
+
+# Test FFmpeg VAAPI
+ffmpeg -hwaccels
+
+# Check permissions
+ls -la /dev/dri/renderD128
+groups scheduler  # Should include 'video' or 'render'
+
+# Fallback to software encoding
+# Comment out VAAPI_DEVICE in config
+# Encoding will use CPU (slower but works)
+```
+
+---
+
+## Performance Optimization
+
+### Hardware Acceleration
+
+```bash
+# Verify GPU usage during encoding
+intel_gpu_top  # For Intel GPUs
+radeontop      # For AMD GPUs
+
+# If GPU not being used, check:
+# 1. VAAPI device path correct
+# 2. User has GPU permissions
+# 3. FFmpeg compiled with VAAPI support
+```
+
+### Storage Performance
+
+```bash
+# Use SSD for final videos (they're streamed frequently)
+# Use HDD for raw videos (accessed once for processing)
+
+# Test disk performance
+dd if=/dev/zero of=/mnt/storage/test bs=1M count=1024 oflag=direct
+rm /mnt/storage/test
+```
+
+### Network Optimization
+
+```bash
+# For better streaming reliability
+# 1. Use dedicated network for RTMP
+# 2. Enable QoS for streaming traffic
+# 3. Consider local RTMP relay
+
+# Test network throughput
+iperf3 -c your-rtmp-server.com
+```
+
+---
+
+## Production Checklist
+
+Before going live:
+
+- [ ] Secrets stored securely (not in git)
+- [ ] Service auto-starts on boot
+- [ ] Backups configured and tested
+- [ ] Monitoring configured
+- [ ] Logs being rotated
+- [ ] Disk space alerts configured
+- [ ] Test recovery procedure
+- [ ] Document runbook for on-call
+- [ ] GPU permissions verified
+- [ ] RTMP connectivity tested
+- [ ] NocoDB API tested
+- [ ] Process one test video end-to-end
+- [ ] Verify streaming watchdog works
+- [ ] Test service restart during streaming
+- [ ] Configure alerting for failures
+
+---
+
+## Support & Updates
+
+### Getting Updates
+
+```bash
+# Git-based deployment
+cd /opt/scheduler
+git pull origin main
+systemctl restart scheduler
+
+# Docker-based deployment
+cd /opt/scheduler
+docker compose -f docker-compose.prod.yml pull
+docker compose -f docker-compose.prod.yml up -d
+```
+
+### Reporting Issues
+
+Include in bug reports:
+- Service logs: `journalctl -u scheduler -n 100`
+- Database state: `sqlite3 scheduler.db ".dump jobs"`
+- System info: `uname -a`, `python3 --version`, `ffmpeg -version`
+- Configuration (redact secrets!)
+
+---
+
+## Additional Resources
+
+- FFmpeg VAAPI Guide: https://trac.ffmpeg.org/wiki/Hardware/VAAPI
+- whisper.cpp: https://github.com/ggerganov/whisper.cpp
+- NocoDB API: https://docs.nocodb.com
+- Systemd Documentation: https://www.freedesktop.org/software/systemd/man/
+
+---
+
+## License
+
+This production guide is provided as-is. Test thoroughly in staging before production deployment.

README.md

@@ -0,0 +1,314 @@
+# Movie Scheduler
+
+Automated movie scheduler that reads from NocoDB, generates subtitles with whisper.cpp, burns them into videos with VAAPI encoding, and streams at scheduled times.
+
+## Quick Links
+
+- **[Production Deployment Guide](PRODUCTION.md)** - Complete guide for production setup
+- **[Testing Guide](TESTING.md)** - Docker-based test environment
+- **[Development Setup](#installation)** - Local development setup
+
+## Features
+
+- **NocoDB Integration**: Syncs job schedules from NocoDB database
+- **Automatic Subtitle Generation**: Uses whisper.cpp to generate SRT subtitles
+- **Hardware-Accelerated Encoding**: Burns subtitles into videos using VAAPI (h264_vaapi)
+- **Scheduled Streaming**: Streams videos to RTMP server at scheduled times
+- **Robust Error Handling**: Automatic retries with exponential backoff
+- **Comprehensive Logging**: Tracks all operations in database log column
+- **Process Management**: Properly tracks and manages streaming processes
+
+## Requirements
+
+- Python 3.7+
+- `requests` library
+- `whisper.cpp` installed and available in PATH
+- `ffmpeg` with VAAPI support
+- VAAPI-capable hardware (AMD/Intel GPU)
+- NocoDB instance with scheduled jobs table
+
+## Installation
+
+1. Clone or download this repository
+
+2. Install Python dependencies:
+   ```bash
+   pip install requests
+   ```
+
+3. Ensure whisper.cpp is installed:
+   ```bash
+   # Follow whisper.cpp installation instructions
+   # Make sure the binary is in your PATH
+   which whisper.cpp
+   ```
+
+4. Verify FFmpeg has VAAPI support:
+   ```bash
+   ffmpeg -hwaccels | grep vaapi
+   ```
+
+## Configuration
+
+1. Copy the example environment file:
+   ```bash
+   cp .env.example .env
+   ```
+
+2. Edit `.env` and set the required variables:
+   ```bash
+   # Required
+   export NOCODB_URL="https://nocodb/api/v2/tables/XXXX/records"
+   export NOCODB_TOKEN="your_token_here"
+   export RTMP_SERVER="rtmp://your_server/live"
+
+   # Optional (defaults provided)
+   export RAW_DIR="/root/surowe_filmy"
+   export FINAL_DIR="/root/przygotowane_filmy"
+   export WHISPER_MODEL="/root/models/ggml-base.bin"
+   export VAAPI_DEVICE="/dev/dri/renderD128"
+   export STREAM_GRACE_PERIOD_MINUTES="15"
+   export NOCODB_SYNC_INTERVAL_SECONDS="60"
+   export WATCHDOG_CHECK_INTERVAL_SECONDS="10"
+   ```
+
+3. Load the environment variables:
+   ```bash
+   source .env
+   ```
+
+## NocoDB Table Structure
+
+Your NocoDB table should have the following fields:
+
+- `Id` - Unique identifier (Text/Primary Key)
+- `Title` - Movie title matching filename (Text)
+- `Date` - Scheduled run time (DateTime in ISO format)
+
+The scheduler will automatically create additional columns in the local SQLite database:
+- `prep_at` - Preparation time (6 hours before run_at)
+- `prep_status` - Preparation status (pending/done/failed)
+- `play_status` - Streaming status (pending/done/failed)
+- `raw_path` - Path to source video file
+- `final_path` - Path to converted video with subtitles
+- `log` - Detailed operation log
+
+## Usage
+
+### Running the Scheduler
+
+```bash
+# Ensure environment variables are set
+source .env
+
+# Run the scheduler
+python agent.py
+```
+
+The scheduler will:
+1. Sync jobs from NocoDB every 60 seconds (configurable)
+2. Check stream health every 10 seconds (configurable)
+3. Prepare videos 6 hours before their scheduled time:
+   - Find matching video file in RAW_DIR
+   - Generate subtitles with whisper.cpp
+   - Encode video with burned subtitles using VAAPI
+4. Stream videos at their scheduled time to RTMP server
+
+### Stopping the Scheduler
+
+Press `Ctrl+C` to gracefully stop the scheduler. It will:
+- Stop any active streaming process
+- Close the database connection
+- Exit cleanly
+
+### Restart & Recovery Behavior
+
+The scheduler handles restarts, power outages, and downtime gracefully:
+
+**On Startup:**
+- ✅ Checks for overdue prep jobs and processes them immediately
+- ⚠️ Skips jobs where the streaming time has already passed
+- 📊 Logs recovery status (overdue/skipped jobs found)
+
+**Grace Period for Late Streaming:**
+- ⏰ If prep is done and streaming time is overdue by **up to 15 minutes**, will still start streaming
+- ⚠️ Jobs more than 15 minutes late are marked as 'skipped'
+- 📝 Late starts are logged with exact delay time
+
+**Recovery Scenarios:**
+
+1. **Short Outage (prep time missed, but streaming time not reached)**
+   - Movie scheduled for 21:00 (prep at 15:00)
+   - System down from 14:00-16:00
+   - ✅ Restarts at 16:00: immediately preps the movie
+   - ✅ Streams normally at 21:00
+
+2. **Late Start Within Grace Period (< 15 minutes)**
+   - Movie scheduled for 21:00 (prep completed at 15:00)
+   - System down from 20:00-21:10
+   - ✅ Restarts at 21:10: starts streaming immediately (10 minutes late)
+   - 📝 Logged: "Starting stream 10.0 minutes late"
+
+3. **Too Late to Stream (> 15 minutes)**
+   - Movie scheduled for 21:00 (prep completed)
+   - System down from 20:00-21:20
+   - ⚠️ Restarts at 21:20: marks streaming as 'skipped' (>15 min late)
+   - 📝 Logged: "Streaming skipped - more than 15 minutes late"
+
+4. **Long Outage (both prep and streaming times passed, >15 min)**
+   - Movie scheduled for 21:00 (prep at 15:00)
+   - System down from 14:00-22:00
+   - ⚠️ Restarts at 22:00: marks entire job as 'skipped'
+   - 📝 Logged: "Job skipped - streaming time already passed"
+
+5. **Crash During Processing**
+   - System crashes during subtitle generation or encoding
+   - ✅ On restart: retries from the beginning with full retry logic
+   - All operations are idempotent (safe to re-run)
+
+**Database Persistence:**
+- Job status stored in `scheduler.db` survives restarts
+- Completed preps are never re-done
+- Failed jobs stay marked as 'failed' (can be reset manually to 'pending' if needed)
+
+## File Naming
+
+Place your raw video files in `RAW_DIR` with names that contain the title from NocoDB.
+
+Example:
+- NocoDB Title: `"The Matrix"`
+- Valid filenames: `The Matrix.mkv`, `the-matrix-1999.mp4`, `[1080p] The Matrix.avi`
+
+The scheduler uses glob matching to find files containing the title.
+
+## Streaming Watchdog
+
+The scheduler includes an active watchdog that monitors streaming:
+
+**Stream Monitoring (checked every 10 seconds):**
+- ✅ Detects if ffmpeg stream crashes or exits unexpectedly
+- ✅ Automatically restarts stream at the correct playback position
+- ✅ Calculates elapsed time since stream start
+- ✅ Seeks to correct position using `ffmpeg -ss` flag
+- ✅ Limits restarts to 10 attempts to prevent infinite loops
+- ✅ Marks stream as 'done' when video completes normally
+- ✅ Marks stream as 'failed' after 10 failed restart attempts
+
+**How It Works:**
+1. Stream starts and status set to 'streaming' (not 'done')
+2. Watchdog checks every 10 seconds if stream process is running
+3. If crashed: calculates elapsed time and restarts with seek
+4. If completed normally (exit code 0): marks as 'done'
+5. If video duration exceeded: marks as 'done'
+
+**Example:**
+```
+Stream starts at 21:00:00
+Stream crashes at 21:05:30 (5.5 minutes in)
+Watchdog detects crash within 10 seconds
+Restarts stream with: ffmpeg -ss 330 -i video.mp4
+Stream resumes from 5:30 mark
+```
+
+## Error Handling
+
+The scheduler includes robust error handling:
+
+- **Automatic Retries**: Failed operations are retried up to 3 times with exponential backoff
+- **Database Logging**: All operations and errors are logged to the `log` column
+- **Status Tracking**: Jobs are marked as 'failed' if all retries are exhausted
+- **File Verification**: Checks that subtitle files and encoded videos were created successfully
+
+## Monitoring
+
+### Check Job Status
+
+Query the SQLite database:
+```bash
+sqlite3 scheduler.db "SELECT nocodb_id, title, prep_status, play_status FROM jobs;"
+```
+
+### View Job Logs
+
+```bash
+sqlite3 scheduler.db "SELECT nocodb_id, title, log FROM jobs WHERE nocodb_id='YOUR_JOB_ID';"
+```
+
+### Console Output
+
+The scheduler logs to stdout with timestamps:
+- INFO: Normal operations
+- WARNING: Retry attempts
+- ERROR: Failures
+
+## Troubleshooting
+
+### Configuration Validation Failed
+- Ensure all required environment variables are set
+- Check that NOCODB_URL is accessible
+- Verify NOCODB_TOKEN has proper permissions
+
+### No Files Found Matching Title
+- Check that video files exist in RAW_DIR
+- Ensure filenames contain the NocoDB title (case-insensitive glob matching)
+- Review the log column in the database for exact error messages
+
+### Subtitle Generation Failed
+- Verify whisper.cpp is installed: `which whisper.cpp`
+- Check WHISPER_MODEL path is correct
+- Ensure the model file exists and is readable
+
+### Video Encoding Failed
+- Confirm VAAPI is available: `ffmpeg -hwaccels | grep vaapi`
+- Check VAAPI device exists: `ls -l /dev/dri/renderD128`
+- Verify subtitle file was created successfully
+- Review FFmpeg error output in the log column
+
+### Streaming Failed
+- Test RTMP server connectivity: `ffmpeg -re -i test.mp4 -c copy -f flv rtmp://your_server/live`
+- Ensure final video file exists
+- Check network connectivity to RTMP server
+
+## Development
+
+### Database Schema
+
+```sql
+CREATE TABLE jobs (
+    nocodb_id TEXT PRIMARY KEY,
+    title TEXT,
+    run_at TIMESTAMP,
+    prep_at TIMESTAMP,
+    raw_path TEXT,
+    final_path TEXT,
+    prep_status TEXT,  -- pending/done/failed/skipped
+    play_status TEXT,  -- pending/streaming/done/failed/skipped
+    log TEXT,
+    stream_start_time TIMESTAMP,  -- When streaming started (for restart seek)
+    stream_retry_count INTEGER    -- Number of stream restart attempts
+);
+```
+
+**Status Values:**
+- `play_status='streaming'`: Stream is actively running
+- `play_status='done'`: Stream completed successfully
+- `play_status='failed'`: Stream failed after 10 restart attempts
+- `play_status='skipped'`: Too late to stream (>15 min past scheduled time)
+
+### Customization
+
+Use environment variables to customize:
+- `NOCODB_SYNC_INTERVAL_SECONDS` - How often to check NocoDB for new jobs (default: 60)
+- `WATCHDOG_CHECK_INTERVAL_SECONDS` - How often to monitor streams (default: 10)
+- `STREAM_GRACE_PERIOD_MINUTES` - Late start tolerance (default: 15)
+
+Edit `agent.py` to customize:
+- Retry attempts and delay (agent.py:99, 203, 232)
+- Preparation time offset (currently 6 hours, see sync function)
+- Stream restart limit (agent.py:572)
+- Subtitle styling (agent.py:246)
+- Video encoding parameters (agent.py:248-250)
+
+## License
+
+This project is provided as-is without warranty.

TESTING.md

@@ -0,0 +1,486 @@
+# Movie Scheduler - Testing Environment
+
+Complete Docker-based testing environment for the movie scheduler. Fire and forget - just run one command and everything is set up automatically!
+
+## Quick Start
+
+```bash
+./start-test-environment.sh
+```
+
+That's it! The script will:
+1. Build all Docker containers
+2. Start PostgreSQL, NocoDB, and RTMP server
+3. Initialize NocoDB with test data
+4. Download a test video (Big Buck Bunny)
+5. Start the scheduler
+
+## Services
+
+After running the startup script, you'll have:
+
+### NocoDB Dashboard
+- **URL**: http://localhost:8080
+- **Email**: admin@test.com
+- **Password**: admin123
+
+Login and view the "Movies" table to see scheduled movies and their status.
+
+### RTMP Streaming Server
+- **Stream URL**: rtmp://localhost:1935/live/stream
+- **Statistics**: http://localhost:8081/stat
+
+This is where processed movies will be streamed.
+
+### Movie Scheduler
+Runs in the background, automatically:
+- Syncs movies from NocoDB every 60 seconds (configurable)
+- Monitors stream health every 10 seconds (configurable)
+- Prepares videos 6 hours before scheduled time
+- Streams at the scheduled time
+
+## Testing the Workflow
+
+### 1. View Initial Data
+
+The test environment comes with a pre-loaded movie:
+- **Title**: BigBuckBunny
+- **Scheduled**: 5 minutes from startup
+
+Open NocoDB to see this entry.
+
+### 2. Monitor the Scheduler
+
+Watch the scheduler logs:
+```bash
+docker compose logs -f scheduler
+```
+
+You'll see:
+- Syncing from NocoDB
+- Preparation jobs (if within 6 hours of scheduled time)
+- Subtitle generation
+- Video encoding
+- Streaming start
+
+### 3. Check the Database
+
+Query the local SQLite database:
+```bash
+sqlite3 scheduler.db "SELECT nocodb_id, title, prep_status, play_status FROM jobs;"
+```
+
+View detailed logs:
+```bash
+sqlite3 scheduler.db "SELECT title, log FROM jobs WHERE title='BigBuckBunny';"
+```
+
+### 4. Watch the Stream
+
+When a movie starts streaming, watch it with VLC:
+```bash
+vlc rtmp://localhost:1935/live/stream
+```
+
+Or use ffplay:
+```bash
+ffplay rtmp://localhost:1935/live/stream
+```
+
+### 5. Add Your Own Movies
+
+#### Option A: Through NocoDB UI
+
+1. Open http://localhost:8080
+2. Navigate to the Movies table
+3. Click "+ Add New Row"
+4. Fill in:
+   - **Title**: Name matching your video file
+   - **Date**: Schedule time (ISO format: 2024-01-21T20:00:00)
+   - Other fields are optional
+5. Place video file in `raw_movies` volume
+
+#### Option B: Add Video File Manually
+
+Copy a video to the raw movies volume:
+```bash
+# Find the volume name
+docker volume ls | grep raw_movies
+
+# Copy your video
+docker run --rm -v scheduler_raw_movies:/data -v $(pwd):/host alpine \
+  cp /host/your-movie.mp4 /data/
+```
+
+Then add the entry in NocoDB with matching Title.
+
+## Testing Restart & Recovery
+
+### Test Overdue Job Processing
+
+1. Add a movie scheduled for 15 minutes from now
+2. Stop the scheduler:
+   ```bash
+   docker compose stop scheduler
+   ```
+3. Wait 20 minutes (past the prep time)
+4. Restart the scheduler:
+   ```bash
+   docker compose start scheduler
+   docker compose logs -f scheduler
+   ```
+5. Watch it immediately process the overdue prep job
+
+### Test 15-Minute Grace Period for Streaming
+
+1. Add a movie scheduled for 5 minutes from now (with prep already done)
+2. Stop the scheduler after prep completes:
+   ```bash
+   docker compose stop scheduler
+   ```
+3. Wait 10 minutes (past streaming time but within 15-min grace period)
+4. Restart and watch logs:
+   ```bash
+   docker compose start scheduler
+   docker compose logs -f scheduler
+   ```
+5. Stream should start immediately with "Starting stream X.X minutes late" message
+
+### Test Skipping Late Streams (>15 minutes)
+
+1. Add a movie scheduled for 5 minutes from now
+2. Let prep complete, then stop the scheduler:
+   ```bash
+   docker compose stop scheduler
+   ```
+3. Wait 20 minutes (past the 15-minute grace period)
+4. Restart and watch logs:
+   ```bash
+   docker compose start scheduler
+   docker compose logs -f scheduler
+   ```
+5. Job should be marked as 'skipped' with "more than 15 minutes late"
+
+### Test Skipping Unprepared Expired Jobs
+
+1. Add a movie scheduled for 5 minutes from now
+2. Stop the scheduler before prep starts:
+   ```bash
+   docker compose stop scheduler
+   ```
+3. Wait 10 minutes (past both prep and streaming time)
+4. Restart and watch logs:
+   ```bash
+   docker compose start scheduler
+   docker compose logs -f scheduler
+   ```
+5. Job should be marked as 'skipped' (too late to prep)
+
+### Test Recovery from Crash During Processing
+
+1. Start processing a large video file
+2. Kill the scheduler during encoding:
+   ```bash
+   docker compose kill scheduler
+   ```
+3. Restart:
+   ```bash
+   docker compose start scheduler
+   ```
+4. Watch it retry the entire operation from the beginning
+
+## Testing Stream Watchdog
+
+### Test Stream Crash and Auto-Restart
+
+1. Start a stream:
+   ```bash
+   docker compose logs -f scheduler
+   ```
+
+2. Find the streaming ffmpeg process and kill it:
+   ```bash
+   # In another terminal
+   docker compose exec scheduler ps aux | grep ffmpeg
+   docker compose exec scheduler kill -9 <PID>
+   ```
+
+3. Watch the scheduler logs - within 10 seconds it should:
+   - Detect the crash
+   - Calculate elapsed playback time
+   - Restart with seek to correct position
+   - Log: "Restarting stream at position X.Xs"
+
+### Test Stream Restart with Correct Position
+
+1. Start a test stream with a longer video
+2. Let it run for 2-3 minutes
+3. Kill the ffmpeg process
+4. Watch logs confirm restart with seek:
+   ```
+   Restarting stream for job XXX at position 180.0s (attempt 2)
+   ```
+5. Use VLC to confirm playback resumed at correct position
+
+### Test Stream Completion Detection
+
+1. Use a short test video (1-2 minutes)
+2. Watch stream until completion
+3. Check logs - should show:
+   ```
+   Stream completed successfully for job XXX
+   ```
+4. Check database - play_status should be 'done'
+
+### Test Retry Limit
+
+1. Break the RTMP server or use invalid RTMP URL
+2. Start a stream - it will crash immediately
+3. Watch the scheduler attempt 10 restarts
+4. After 10 attempts, should mark as 'failed':
+   ```
+   Stream retry limit exceeded for job XXX
+   ERROR: Stream failed after 10 restart attempts
+   ```
+
+### Test Network Interruption Recovery
+
+1. Start a stream
+2. Stop the RTMP server:
+   ```bash
+   docker compose stop rtmp
+   ```
+3. Watch stream fail and retry
+4. Restart RTMP:
+   ```bash
+   docker compose start rtmp
+   ```
+5. Stream should resume at correct position
+
+## Testing Error Handling
+
+### Test Retry Logic
+
+1. Stop the RTMP server:
+   ```bash
+   docker compose stop rtmp
+   ```
+
+2. Watch the scheduler handle the failure and retry:
+   ```bash
+   docker compose logs -f scheduler
+   ```
+
+3. Restart RTMP:
+   ```bash
+   docker compose start rtmp
+   ```
+
+### Test Missing File
+
+1. Add a movie entry in NocoDB with a title that doesn't match any file
+2. Set the Date to trigger immediately
+3. Watch the scheduler log the error and mark it as failed
+
+### Test Subtitle Generation Failure
+
+1. Add an invalid video file (corrupted or wrong format)
+2. Watch the scheduler attempt retries with exponential backoff
+
+## Viewing Results
+
+### Processed Videos
+
+List final videos with burned-in subtitles:
+```bash
+docker run --rm -v scheduler_final_movies:/data alpine ls -lh /data
+```
+
+### Raw Videos
+
+List source videos:
+```bash
+docker run --rm -v scheduler_raw_movies:/data alpine ls -lh /data
+```
+
+### RTMP Recordings (if enabled)
+
+Recordings are saved to the rtmp_recordings volume:
+```bash
+docker run --rm -v scheduler_rtmp_recordings:/data alpine ls -lh /data/recordings
+```
+
+## Customization
+
+### Change Test Video Scheduling
+
+Edit `init-data.sh` before starting, around line 130:
+```python
+"Date": (datetime.now() + timedelta(minutes=5)).isoformat(),
+```
+
+Change `minutes=5` to adjust when the test movie is scheduled.
+
+### Use Different NocoDB Credentials
+
+Edit `docker-compose.yml`:
+```yaml
+environment:
+  NOCODB_EMAIL: "your@email.com"
+  NOCODB_PASSWORD: "yourpassword"
+```
+
+### Test with Real NocoDB Instance
+
+Comment out the `nocodb` and `postgres` services in `docker-compose.yml` and update the `init` service environment:
+```yaml
+environment:
+  NOCODB_URL: "https://your-nocodb-instance.com"
+  NOCODB_EMAIL: "your@email.com"
+  NOCODB_PASSWORD: "yourpassword"
+```
+
+## Troubleshooting
+
+### Services Won't Start
+
+Check if ports are already in use:
+```bash
+lsof -i :8080  # NocoDB
+lsof -i :1935  # RTMP
+lsof -i :8081  # RTMP stats
+```
+
+### Initialization Fails
+
+View init logs:
+```bash
+docker compose logs init
+```
+
+Common issues:
+- NocoDB not ready yet (increase wait time in init-data.sh)
+- Network connectivity issues
+- Insufficient disk space
+
+### Scheduler Not Processing
+
+Check if it's running:
+```bash
+docker compose ps scheduler
+```
+
+View logs for errors:
+```bash
+docker compose logs scheduler
+```
+
+Restart if needed:
+```bash
+docker compose restart scheduler
+```
+
+### Video Download Fails
+
+The init script downloads Big Buck Bunny from Google's test video bucket. If this fails:
+1. Check internet connectivity
+2. Manually download and copy to raw_movies volume
+3. Or use your own test video
+
+### VAAPI Not Available
+
+The Docker container runs without GPU access by default (CPU encoding fallback). To enable VAAPI:
+
+Edit `docker-compose.yml` scheduler service:
+```yaml
+scheduler:
+  devices:
+    - /dev/dri:/dev/dri
+  group_add:
+    - video
+```
+
+## Cleanup
+
+### Stop Everything
+```bash
+docker compose down
+```
+
+### Remove All Data (including volumes)
+```bash
+docker compose down -v
+```
+
+This removes:
+- All containers
+- All volumes (database, videos, recordings)
+- Network
+
+### Keep Database, Remove Containers
+```bash
+docker compose down
+# Volumes persist - next startup will reuse existing data
+```
+
+## Architecture
+
+```
+┌─────────────┐
+│  PostgreSQL │
+└──────┬──────┘
+       │
+┌──────▼──────┐      ┌─────────────┐
+│   NocoDB    │◄─────┤    Init     │  Downloads test video
+└──────┬──────┘      │  Container  │  Creates test data
+       │             └─────────────┘
+       │
+┌──────▼──────┐
+│  Scheduler  │  Reads from NocoDB
+└──────┬──────┘  Generates subtitles
+       │         Encodes videos
+       │         Manages streaming
+       │
+┌──────▼──────┐
+│ RTMP Server │  Streams processed videos
+└─────────────┘
+```
+
+## Production Considerations
+
+This test environment uses:
+- Embedded PostgreSQL (fine for testing)
+- Local volumes (fine for testing)
+- Simple authentication (change for production)
+- No SSL/TLS (add for production)
+- CPU-only encoding (enable VAAPI for production)
+
+For production deployment:
+1. Use external PostgreSQL database
+2. Configure proper authentication and secrets
+3. Enable SSL/TLS for NocoDB
+4. Mount persistent storage for videos
+5. Enable GPU acceleration (VAAPI)
+6. Set up proper monitoring and logging
+7. Configure backup for NocoDB database
+
+## Next Steps
+
+Once you've tested the environment:
+1. Review the logs to understand the workflow
+2. Try adding your own movies
+3. Test error scenarios
+4. Adjust timing and configuration
+5. Deploy to production with proper setup
+
+## Support
+
+For issues with:
+- **Scheduler code**: Check `agent.py` and logs
+- **Docker setup**: Check `docker-compose.yml` and service logs
+- **NocoDB**: Visit https://docs.nocodb.com
+- **RTMP streaming**: Check nginx-rtmp documentation
+
+## License
+
+This test environment is provided as-is for development and testing purposes.

agent.py

@@ -0,0 +1,684 @@
+import requests
+import sqlite3
+import time
+import subprocess
+import hashlib
+import os
+import sys
+import logging
+from datetime import datetime, timedelta
+from pathlib import Path
+from functools import wraps
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Load configuration from environment variables
+NOCODB_URL = os.getenv("NOCODB_URL")
+NOCODB_TOKEN = os.getenv("NOCODB_TOKEN")
+RTMP_SERVER = os.getenv("RTMP_SERVER")
+RAW_DIR = Path(os.getenv("RAW_DIR", "/root/surowe_filmy"))
+FINAL_DIR = Path(os.getenv("FINAL_DIR", "/root/przygotowane_filmy"))
+WHISPER_MODEL = os.getenv("WHISPER_MODEL", "/root/models/ggml-base.bin")
+VAAPI_DEVICE = os.getenv("VAAPI_DEVICE", "/dev/dri/renderD128")
+STREAM_GRACE_PERIOD_MINUTES = int(os.getenv("STREAM_GRACE_PERIOD_MINUTES", "15"))
+
+# Timing configuration
+NOCODB_SYNC_INTERVAL_SECONDS = int(os.getenv("NOCODB_SYNC_INTERVAL_SECONDS", "60"))
+WATCHDOG_CHECK_INTERVAL_SECONDS = int(os.getenv("WATCHDOG_CHECK_INTERVAL_SECONDS", "10"))
+
+# Configuration validation
+def validate_config():
+    """Validate required environment variables on startup."""
+    required_vars = {
+        "NOCODB_URL": NOCODB_URL,
+        "NOCODB_TOKEN": NOCODB_TOKEN,
+        "RTMP_SERVER": RTMP_SERVER
+    }
+
+    missing = [name for name, value in required_vars.items() if not value]
+
+    if missing:
+        logger.error(f"Missing required environment variables: {', '.join(missing)}")
+        logger.error("Please set the following environment variables:")
+        logger.error("  NOCODB_URL - NocoDB API endpoint")
+        logger.error("  NOCODB_TOKEN - Authentication token")
+        logger.error("  RTMP_SERVER - Streaming destination")
+        sys.exit(1)
+
+    # Validate directories exist or can be created
+    for dir_path in [RAW_DIR, FINAL_DIR]:
+        try:
+            dir_path.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            logger.error(f"Cannot create directory {dir_path}: {e}")
+            sys.exit(1)
+
+    logger.info("Configuration validated successfully")
+    logger.info(f"RAW_DIR: {RAW_DIR}")
+    logger.info(f"FINAL_DIR: {FINAL_DIR}")
+    logger.info(f"WHISPER_MODEL: {WHISPER_MODEL}")
+    logger.info(f"VAAPI_DEVICE: {VAAPI_DEVICE}")
+    logger.info(f"STREAM_GRACE_PERIOD: {STREAM_GRACE_PERIOD_MINUTES} minutes")
+    logger.info(f"NOCODB_SYNC_INTERVAL: {NOCODB_SYNC_INTERVAL_SECONDS} seconds")
+    logger.info(f"WATCHDOG_CHECK_INTERVAL: {WATCHDOG_CHECK_INTERVAL_SECONDS} seconds")
+
+# Database setup
+db = sqlite3.connect("scheduler.db", check_same_thread=False)
+db.row_factory = sqlite3.Row
+
+# Ensure table exists with log column and streaming metadata
+db.execute("""
+CREATE TABLE IF NOT EXISTS jobs (
+    nocodb_id TEXT PRIMARY KEY,
+    title TEXT,
+    run_at TIMESTAMP,
+    prep_at TIMESTAMP,
+    raw_path TEXT,
+    final_path TEXT,
+    prep_status TEXT,
+    play_status TEXT,
+    log TEXT,
+    stream_start_time TIMESTAMP,
+    stream_retry_count INTEGER DEFAULT 0
+)
+""")
+db.commit()
+
+# Add new columns if they don't exist (for existing databases)
+try:
+    db.execute("ALTER TABLE jobs ADD COLUMN stream_start_time TIMESTAMP")
+    db.commit()
+except:
+    pass
+
+try:
+    db.execute("ALTER TABLE jobs ADD COLUMN stream_retry_count INTEGER DEFAULT 0")
+    db.commit()
+except:
+    pass
+
+# Track streaming process
+streaming_process = None
+current_streaming_job = None
+
+def log_to_db(nocodb_id, message):
+    """Append a timestamped log message to the database log column."""
+    timestamp = datetime.now().isoformat()
+    log_entry = f"[{timestamp}] {message}\n"
+
+    try:
+        db.execute("""
+        UPDATE jobs SET log = log || ? WHERE nocodb_id = ?
+        """, (log_entry, nocodb_id))
+        db.commit()
+        logger.info(f"Job {nocodb_id}: {message}")
+    except Exception as e:
+        logger.error(f"Failed to log to database: {e}")
+
+def retry_with_backoff(max_attempts=3, base_delay=1):
+    """Decorator to retry a function with exponential backoff."""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if attempt == max_attempts:
+                        logger.error(f"{func.__name__} failed after {max_attempts} attempts: {e}")
+                        raise
+
+                    delay = base_delay * (2 ** (attempt - 1))
+                    logger.warning(f"{func.__name__} attempt {attempt} failed: {e}. Retrying in {delay}s...")
+                    time.sleep(delay)
+
+        return wrapper
+    return decorator
+
+@retry_with_backoff(max_attempts=3)
+def sync():
+    """Sync jobs from NocoDB."""
+    try:
+        response = requests.get(
+            NOCODB_URL,
+            headers={"xc-token": NOCODB_TOKEN},
+            timeout=30
+        )
+        response.raise_for_status()
+
+        rows = response.json().get("list", [])
+        logger.info(f"Fetched {len(rows)} jobs from NocoDB")
+
+        for r in rows:
+            try:
+                run_at = datetime.fromisoformat(r["Date"])
+                prep_at = run_at - timedelta(hours=6)
+
+                # Preserve existing status and streaming data on sync
+                existing = db.execute("SELECT * FROM jobs WHERE nocodb_id=?", (r["Id"],)).fetchone()
+                if existing:
+                    db.execute("""
+                    UPDATE jobs SET title=?, run_at=?, prep_at=?
+                    WHERE nocodb_id=?
+                    """, (r["Title"], run_at, prep_at, r["Id"]))
+                else:
+                    db.execute("""
+                    INSERT INTO jobs (nocodb_id, title, run_at, prep_at, raw_path, final_path,
+                                     prep_status, play_status, log, stream_start_time, stream_retry_count)
+                    VALUES (?,?,?,?,?,?,?,?,?,?,?)
+                    """, (r["Id"], r["Title"], run_at, prep_at, None, None, 'pending', 'pending', '', None, 0))
+
+            except Exception as e:
+                logger.error(f"Failed to process row {r.get('Id', 'unknown')}: {e}")
+
+        db.commit()
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to sync from NocoDB: {e}")
+        raise
+
+def take_prep():
+    """Get the next job ready for preparation."""
+    try:
+        # First, mark jobs as skipped if both prep and run times have passed
+        db.execute("""
+        UPDATE jobs
+        SET prep_status='skipped', play_status='skipped',
+            log = log || ?
+        WHERE prep_status='pending'
+        AND run_at <= CURRENT_TIMESTAMP
+        """, (f"[{datetime.now().isoformat()}] Job skipped - streaming time already passed\n",))
+        db.commit()
+
+        # Get next overdue or upcoming prep job
+        c = db.execute("""
+        SELECT * FROM jobs WHERE prep_status='pending' AND prep_at <= CURRENT_TIMESTAMP LIMIT 1
+        """)
+        job = c.fetchone()
+
+        if job:
+            # Check if this is an overdue job
+            prep_at = datetime.fromisoformat(job["prep_at"])
+            if prep_at < datetime.now() - timedelta(minutes=5):
+                logger.warning(f"Processing overdue prep job: {job['nocodb_id']} - {job['title']} (was due {prep_at})")
+
+        return job
+    except Exception as e:
+        logger.error(f"Failed to query prep jobs: {e}")
+        return None
+
+def take_play():
+    """Get the next job ready for streaming with configurable grace period."""
+    try:
+        # Calculate grace period cutoff (default 15 minutes ago)
+        grace_period_cutoff = datetime.now() - timedelta(minutes=STREAM_GRACE_PERIOD_MINUTES)
+
+        # Mark jobs more than STREAM_GRACE_PERIOD_MINUTES overdue as skipped
+        db.execute("""
+        UPDATE jobs
+        SET play_status='skipped',
+            log = log || ?
+        WHERE prep_status='done'
+        AND play_status='pending'
+        AND run_at < ?
+        """, (
+            f"[{datetime.now().isoformat()}] Streaming skipped - more than {STREAM_GRACE_PERIOD_MINUTES} minutes late\n",
+            grace_period_cutoff.isoformat()
+        ))
+        db.commit()
+
+        # Get jobs ready to stream (on time or within 15-minute grace period)
+        c = db.execute("""
+        SELECT * FROM jobs
+        WHERE prep_status='done'
+        AND play_status='pending'
+        AND run_at <= CURRENT_TIMESTAMP
+        LIMIT 1
+        """)
+        job = c.fetchone()
+
+        if job:
+            # Check if this is a late start
+            run_at = datetime.fromisoformat(job["run_at"])
+            delay = datetime.now() - run_at
+            if delay > timedelta(seconds=30):
+                minutes_late = delay.total_seconds() / 60
+                logger.warning(f"Starting stream late: {job['nocodb_id']} - {job['title']} ({minutes_late:.1f} minutes after scheduled time)")
+
+        return job
+    except Exception as e:
+        logger.error(f"Failed to query play jobs: {e}")
+        return None
+
+def run_subprocess(cmd, job_id, description, timeout=None):
+    """Run a subprocess with error handling and logging."""
+    log_to_db(job_id, f"Starting: {description}")
+    logger.info(f"Running command: {' '.join(str(c) for c in cmd)}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=True
+        )
+
+        if result.stdout:
+            logger.debug(f"stdout: {result.stdout[:500]}")
+
+        log_to_db(job_id, f"Completed: {description}")
+        return result
+
+    except subprocess.TimeoutExpired:
+        error_msg = f"Timeout: {description} exceeded {timeout}s"
+        log_to_db(job_id, f"ERROR: {error_msg}")
+        raise Exception(error_msg)
+
+    except subprocess.CalledProcessError as e:
+        error_msg = f"Command failed with code {e.returncode}: {e.stderr[:500] if e.stderr else 'no error output'}"
+        log_to_db(job_id, f"ERROR: {description} - {error_msg}")
+        raise Exception(error_msg)
+
+@retry_with_backoff(max_attempts=3, base_delay=2)
+def generate_subtitles(raw_file, job_id):
+    """Generate subtitles using whisper.cpp."""
+    srt_file = raw_file.with_suffix(".srt")
+
+    # Remove existing subtitle file if present
+    if srt_file.exists():
+        srt_file.unlink()
+        log_to_db(job_id, f"Removed existing subtitle file: {srt_file}")
+
+    # Run whisper.cpp with correct format: whisper.cpp -m <model> -f <file> -osrt
+    cmd = [
+        "whisper.cpp",
+        "-m", str(WHISPER_MODEL),
+        "-f", str(raw_file),
+        "-osrt"
+    ]
+
+    run_subprocess(cmd, job_id, "Subtitle generation with whisper.cpp", timeout=3600)
+
+    # Verify subtitle file was created
+    if not srt_file.exists():
+        error_msg = f"Subtitle file not created: {srt_file}"
+        log_to_db(job_id, f"ERROR: {error_msg}")
+        raise Exception(error_msg)
+
+    log_to_db(job_id, f"Subtitle file created successfully: {srt_file}")
+    return srt_file
+
+@retry_with_backoff(max_attempts=3, base_delay=2)
+def encode_video_with_subtitles(raw_file, srt_file, final_file, job_id):
+    """Encode video with burned-in subtitles using VAAPI."""
+    # Remove existing output file if present
+    if final_file.exists():
+        final_file.unlink()
+        log_to_db(job_id, f"Removed existing output file: {final_file}")
+
+    # FFmpeg command with VAAPI encoding (h264_vaapi instead of h264_qsv)
+    cmd = [
+        "ffmpeg",
+        "-hwaccel", "vaapi",
+        "-vaapi_device", VAAPI_DEVICE,
+        "-i", str(raw_file),
+        "-vf", f"subtitles={srt_file}:force_style=Fontname=Consolas,BackColour=&H80000000,Spacing=0.2,Outline=0,Shadow=0.75,format=yuv420p",
+        "-c:v", "h264_vaapi",  # Changed from h264_qsv to h264_vaapi
+        "-qp", "23",  # Quality parameter for VAAPI (similar to CRF)
+        "-c:a", "aac",
+        "-b:a", "192k",
+        "-movflags", "faststart",
+        "-y",  # Overwrite output file
+        str(final_file)
+    ]
+
+    run_subprocess(cmd, job_id, "Video encoding with VAAPI", timeout=7200)
+
+    # Verify output file was created
+    if not final_file.exists():
+        error_msg = f"Output video file not created: {final_file}"
+        log_to_db(job_id, f"ERROR: {error_msg}")
+        raise Exception(error_msg)
+
+    file_size = final_file.stat().st_size / (1024 * 1024)  # Size in MB
+    log_to_db(job_id, f"Video encoded successfully: {final_file} ({file_size:.2f} MB)")
+    return final_file
+
+def prepare_job(job):
+    """Prepare a job: generate subtitles and encode video."""
+    job_id = job["nocodb_id"]
+    title = job["title"]
+
+    try:
+        log_to_db(job_id, f"Starting preparation for: {title}")
+
+        # Find raw video file
+        matching_files = list(RAW_DIR.glob(f"*{title}*"))
+
+        if not matching_files:
+            error_msg = f"No files found matching title: {title}"
+            log_to_db(job_id, f"ERROR: {error_msg}")
+            db.execute("UPDATE jobs SET prep_status='failed' WHERE nocodb_id=?", (job_id,))
+            db.commit()
+            return
+
+        raw_file = max(matching_files, key=lambda x: x.stat().st_mtime)
+        log_to_db(job_id, f"Found raw file: {raw_file}")
+
+        # Generate subtitles
+        srt_file = generate_subtitles(raw_file, job_id)
+
+        # Prepare output filename
+        final_file = FINAL_DIR / (raw_file.stem + ".converted.mp4")
+
+        # Encode video with subtitles
+        encode_video_with_subtitles(raw_file, srt_file, final_file, job_id)
+
+        # Update database
+        db.execute("""
+        UPDATE jobs SET prep_status='done', raw_path=?, final_path=? WHERE nocodb_id=?
+        """, (str(raw_file), str(final_file), job_id))
+        db.commit()
+
+        log_to_db(job_id, "Preparation completed successfully")
+
+    except Exception as e:
+        error_msg = f"Preparation failed: {e}"
+        log_to_db(job_id, f"ERROR: {error_msg}")
+        logger.error(f"Job {job_id} preparation failed: {e}")
+
+        db.execute("UPDATE jobs SET prep_status='failed' WHERE nocodb_id=?", (job_id,))
+        db.commit()
+
+def get_video_duration(video_path):
+    """Get video duration in seconds using ffprobe."""
+    try:
+        result = subprocess.run(
+            [
+                "ffprobe",
+                "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "default=noprint_wrappers=1:nokey=1",
+                str(video_path)
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return float(result.stdout.strip())
+    except Exception as e:
+        logger.error(f"Failed to get video duration: {e}")
+    return None
+
+def stream_job(job, seek_seconds=0):
+    """Start streaming a prepared job with optional seek position."""
+    global streaming_process, current_streaming_job
+
+    job_id = job["nocodb_id"]
+    final_path = job["final_path"]
+
+    try:
+        # Check if starting late or restarting
+        run_at = datetime.fromisoformat(job["run_at"])
+        delay = datetime.now() - run_at
+        if seek_seconds > 0:
+            log_to_db(job_id, f"Restarting stream at position {seek_seconds:.1f}s")
+        elif delay > timedelta(seconds=30):
+            minutes_late = delay.total_seconds() / 60
+            log_to_db(job_id, f"Starting stream {minutes_late:.1f} minutes late")
+
+        log_to_db(job_id, f"Starting stream to: {RTMP_SERVER}")
+
+        # Verify file exists
+        if not Path(final_path).exists():
+            error_msg = f"Final video file not found: {final_path}"
+            log_to_db(job_id, f"ERROR: {error_msg}")
+            db.execute("UPDATE jobs SET play_status='failed' WHERE nocodb_id=?", (job_id,))
+            db.commit()
+            return False
+
+        # Get video duration to know when it should finish
+        video_duration = get_video_duration(final_path)
+        if not video_duration:
+            logger.warning(f"Could not determine video duration for {final_path}")
+
+        # Stop previous stream if running
+        if streaming_process and streaming_process.poll() is None:
+            logger.info(f"Stopping previous stream (PID: {streaming_process.pid})")
+            streaming_process.terminate()
+            try:
+                streaming_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                streaming_process.kill()
+            log_to_db(job_id, "Stopped previous stream")
+
+        # Build ffmpeg command with optional seek
+        cmd = ["ffmpeg"]
+
+        if seek_seconds > 0:
+            # Seek to position (input seeking is faster)
+            cmd.extend(["-ss", str(seek_seconds)])
+
+        cmd.extend([
+            "-re",  # Read input at native frame rate
+            "-i", final_path,
+            "-c", "copy",  # Copy streams without re-encoding
+            "-f", "flv",
+            RTMP_SERVER
+        ])
+
+        logger.info(f"Starting stream: {' '.join(cmd)}")
+        streaming_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+
+        # Record when this stream started (for calculating seek position on restart)
+        stream_start_time = datetime.now()
+        current_streaming_job = job_id
+
+        log_to_db(job_id, f"Stream started (PID: {streaming_process.pid})")
+
+        # Update database - set status to 'streaming', not 'done'
+        db.execute("""
+        UPDATE jobs
+        SET play_status='streaming',
+            stream_start_time=?,
+            stream_retry_count=stream_retry_count+1
+        WHERE nocodb_id=?
+        """, (stream_start_time.isoformat(), job_id))
+        db.commit()
+
+        return True
+
+    except Exception as e:
+        error_msg = f"Streaming failed: {e}"
+        log_to_db(job_id, f"ERROR: {error_msg}")
+        logger.error(f"Job {job_id} streaming failed: {e}")
+
+        db.execute("UPDATE jobs SET play_status='failed' WHERE nocodb_id=?", (job_id,))
+        db.commit()
+        return False
+
+def monitor_and_restart_stream():
+    """Monitor active stream and restart if it fails."""
+    global streaming_process, current_streaming_job
+
+    # Check if there's supposed to be an active stream
+    try:
+        active_stream = db.execute("""
+        SELECT * FROM jobs WHERE play_status='streaming' LIMIT 1
+        """).fetchone()
+
+        if not active_stream:
+            # No active stream expected
+            streaming_process = None
+            current_streaming_job = None
+            return
+
+        job_id = active_stream["nocodb_id"]
+        final_path = active_stream["final_path"]
+        stream_start_time = active_stream["stream_start_time"]
+        retry_count = active_stream["stream_retry_count"] or 0
+
+        # Check if process is still running
+        if streaming_process and streaming_process.poll() is None:
+            # Stream is running fine
+            return
+
+        # Stream is not running but should be
+        if streaming_process:
+            # Process exited - check if it was normal completion or error
+            return_code = streaming_process.returncode
+            if return_code == 0:
+                # Normal completion - video finished
+                logger.info(f"Stream completed successfully for job {job_id}")
+                log_to_db(job_id, "Stream completed successfully")
+                db.execute("UPDATE jobs SET play_status='done' WHERE nocodb_id=?", (job_id,))
+                db.commit()
+                streaming_process = None
+                current_streaming_job = None
+                return
+            else:
+                # Error exit
+                stderr = streaming_process.stderr.read().decode('utf-8')[-500:] if streaming_process.stderr else ""
+                logger.error(f"Stream crashed for job {job_id} with code {return_code}: {stderr}")
+                log_to_db(job_id, f"Stream crashed (exit code {return_code})")
+
+        # Calculate how much time has elapsed since stream started
+        if not stream_start_time:
+            logger.error(f"No stream start time recorded for job {job_id}")
+            db.execute("UPDATE jobs SET play_status='failed' WHERE nocodb_id=?", (job_id,))
+            db.commit()
+            return
+
+        start_time = datetime.fromisoformat(stream_start_time)
+        elapsed_seconds = (datetime.now() - start_time).total_seconds()
+
+        # Get video duration to check if we should still be streaming
+        video_duration = get_video_duration(final_path)
+        if video_duration and elapsed_seconds >= video_duration:
+            # Video should have finished by now
+            logger.info(f"Stream duration exceeded for job {job_id} - marking as done")
+            log_to_db(job_id, "Stream duration completed")
+            db.execute("UPDATE jobs SET play_status='done' WHERE nocodb_id=?", (job_id,))
+            db.commit()
+            streaming_process = None
+            current_streaming_job = None
+            return
+
+        # Check retry limit (max 10 restarts)
+        if retry_count >= 10:
+            logger.error(f"Stream retry limit exceeded for job {job_id}")
+            log_to_db(job_id, "ERROR: Stream failed after 10 restart attempts")
+            db.execute("UPDATE jobs SET play_status='failed' WHERE nocodb_id=?", (job_id,))
+            db.commit()
+            streaming_process = None
+            current_streaming_job = None
+            return
+
+        # Restart stream at correct position
+        logger.warning(f"Restarting stream for job {job_id} at position {elapsed_seconds:.1f}s (attempt {retry_count + 1})")
+        stream_job(active_stream, seek_seconds=elapsed_seconds)
+
+    except Exception as e:
+        logger.error(f"Error in stream monitor: {e}")
+
+def main():
+    """Main scheduler loop."""
+    logger.info("Starting scheduler...")
+    validate_config()
+
+    # Check for overdue jobs on startup
+    try:
+        grace_period_cutoff = datetime.now() - timedelta(minutes=STREAM_GRACE_PERIOD_MINUTES)
+
+        overdue_prep = db.execute("""
+        SELECT COUNT(*) as count FROM jobs
+        WHERE prep_status='pending' AND prep_at <= CURRENT_TIMESTAMP AND run_at > CURRENT_TIMESTAMP
+        """).fetchone()
+
+        skipped_prep = db.execute("""
+        SELECT COUNT(*) as count FROM jobs
+        WHERE prep_status='pending' AND run_at <= CURRENT_TIMESTAMP
+        """).fetchone()
+
+        overdue_stream = db.execute("""
+        SELECT COUNT(*) as count FROM jobs
+        WHERE prep_status='done' AND play_status='pending' AND run_at <= CURRENT_TIMESTAMP AND run_at >= ?
+        """, (grace_period_cutoff.isoformat(),)).fetchone()
+
+        skipped_stream = db.execute("""
+        SELECT COUNT(*) as count FROM jobs
+        WHERE prep_status='done' AND play_status='pending' AND run_at < ?
+        """, (grace_period_cutoff.isoformat(),)).fetchone()
+
+        if overdue_prep and overdue_prep["count"] > 0:
+            logger.warning(f"Found {overdue_prep['count']} overdue prep job(s) - will process immediately")
+
+        if skipped_prep and skipped_prep["count"] > 0:
+            logger.warning(f"Found {skipped_prep['count']} unprepared job(s) past streaming time - will be marked as skipped")
+
+        if overdue_stream and overdue_stream["count"] > 0:
+            logger.warning(f"Found {overdue_stream['count']} overdue streaming job(s) - will start within grace period ({STREAM_GRACE_PERIOD_MINUTES}min)")
+
+        if skipped_stream and skipped_stream["count"] > 0:
+            logger.warning(f"Found {skipped_stream['count']} streaming job(s) more than {STREAM_GRACE_PERIOD_MINUTES}min late - will be marked as skipped")
+
+    except Exception as e:
+        logger.error(f"Failed to check for overdue jobs: {e}")
+
+    logger.info("Scheduler is running. Press Ctrl+C to stop.")
+
+    try:
+        # Calculate how many iterations between syncs
+        sync_iterations = max(1, NOCODB_SYNC_INTERVAL_SECONDS // WATCHDOG_CHECK_INTERVAL_SECONDS)
+        logger.info(f"Main loop: checking every {WATCHDOG_CHECK_INTERVAL_SECONDS}s, syncing every {sync_iterations} iterations ({NOCODB_SYNC_INTERVAL_SECONDS}s)")
+
+        iteration = 0
+        while True:
+            try:
+                # Monitor and restart stream if needed (check every iteration)
+                monitor_and_restart_stream()
+
+                # Sync jobs from NocoDB at configured interval
+                if iteration % sync_iterations == 0:
+                    sync()
+
+                # Process preparation jobs
+                job = take_prep()
+                if job:
+                    logger.info(f"Processing prep job: {job['nocodb_id']} - {job['title']}")
+                    prepare_job(job)
+
+                # Process streaming jobs
+                job = take_play()
+                if job:
+                    logger.info(f"Processing play job: {job['nocodb_id']} - {job['title']}")
+                    stream_job(job)
+
+            except Exception as e:
+                logger.error(f"Error in main loop: {e}")
+
+            # Sleep between iterations
+            time.sleep(WATCHDOG_CHECK_INTERVAL_SECONDS)
+            iteration += 1
+
+    except KeyboardInterrupt:
+        logger.info("Scheduler stopped by user")
+        if streaming_process and streaming_process.poll() is None:
+            logger.info("Stopping active stream...")
+            streaming_process.terminate()
+    finally:
+        db.close()
+
+if __name__ == "__main__":
+    main()

docker-compose.prod.yml

@@ -0,0 +1,74 @@
+version: '3.8'
+
+services:
+  scheduler:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: movie_scheduler
+    restart: unless-stopped
+
+    # Environment variables - USE SECRETS IN PRODUCTION
+    env_file:
+      - .env.production
+
+    # GPU access for VAAPI encoding
+    devices:
+      - /dev/dri:/dev/dri
+    group_add:
+      - video
+      - render
+
+    volumes:
+      # Persistent database
+      - ./scheduler.db:/app/scheduler.db
+
+      # Video storage - mount your actual storage paths
+      - /mnt/storage/raw_movies:/raw_movies:ro
+      - /mnt/storage/final_movies:/final_movies
+
+      # Whisper model (download once, reuse)
+      - /opt/models:/models:ro
+
+      # Logs (optional - use if not using external logging)
+      - ./logs:/app/logs
+
+    # Logging configuration
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "5"
+
+    # Resource limits
+    deploy:
+      resources:
+        limits:
+          cpus: '4.0'
+          memory: 4G
+        reservations:
+          cpus: '1.0'
+          memory: 1G
+
+    # Health check
+    healthcheck:
+      test: ["CMD-SHELL", "pgrep -f agent.py || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+    # Network
+    networks:
+      - scheduler_network
+
+    # Security
+    security_opt:
+      - no-new-privileges:true
+    read_only: false
+    tmpfs:
+      - /tmp
+
+networks:
+  scheduler_network:
+    driver: bridge

docker-compose.yml

@@ -0,0 +1,112 @@
+version: '3.8'
+
+services:
+  # PostgreSQL database for NocoDB
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_DB: nocodb
+      POSTGRES_USER: nocodb
+      POSTGRES_PASSWORD: nocodb_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U nocodb"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - scheduler_network
+
+  # NocoDB service
+  nocodb:
+    image: nocodb/nocodb:latest
+    ports:
+      - "8080:8080"
+    environment:
+      NC_DB: "pg://postgres:5432?u=nocodb&p=nocodb_password&d=nocodb"
+      NC_AUTH_JWT_SECRET: "test_jwt_secret_key_12345"
+      NC_PUBLIC_URL: "http://localhost:8080"
+    depends_on:
+      postgres:
+        condition: service_healthy
+    volumes:
+      - nocodb_data:/usr/app/data
+    healthcheck:
+      test: ["CMD-SHELL", "curl -f http://localhost:8080/api/v1/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+    networks:
+      - scheduler_network
+
+  # RTMP Server for streaming
+  rtmp:
+    image: tiangolo/nginx-rtmp
+    ports:
+      - "1935:1935"
+      - "8081:80"
+    volumes:
+      - ./nginx-rtmp.conf:/etc/nginx/nginx.conf:ro
+      - rtmp_recordings:/tmp/recordings
+    networks:
+      - scheduler_network
+
+  # Initialization service - sets up test data
+  init:
+    build:
+      context: .
+      dockerfile: Dockerfile.init
+    depends_on:
+      nocodb:
+        condition: service_healthy
+    environment:
+      NOCODB_URL: "http://nocodb:8080"
+      NOCODB_EMAIL: "admin@test.com"
+      NOCODB_PASSWORD: "admin123"
+    volumes:
+      - raw_movies:/raw_movies
+      - config_data:/tmp
+      - ./init-data.sh:/init-data.sh:ro
+    networks:
+      - scheduler_network
+    command: ["/bin/bash", "/init-data.sh"]
+
+  # Movie scheduler service
+  scheduler:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    depends_on:
+      nocodb:
+        condition: service_healthy
+      rtmp:
+        condition: service_started
+      init:
+        condition: service_completed_successfully
+    environment:
+      RAW_DIR: "/raw_movies"
+      FINAL_DIR: "/final_movies"
+      WHISPER_MODEL: "/models/ggml-base.bin"
+    volumes:
+      - raw_movies:/raw_movies
+      - final_movies:/final_movies
+      - config_data:/config:ro
+      - ./scheduler.db:/app/scheduler.db
+      - ./start-scheduler.sh:/start-scheduler.sh:ro
+    networks:
+      - scheduler_network
+    restart: unless-stopped
+    command: ["/bin/bash", "/start-scheduler.sh"]
+
+volumes:
+  postgres_data:
+  nocodb_data:
+  raw_movies:
+  final_movies:
+  rtmp_recordings:
+  config_data:
+
+networks:
+  scheduler_network:
+    driver: bridge

docker-helper.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+# Docker Compose command detection
+if docker compose version &> /dev/null; then
+    COMPOSE="docker compose"
+elif docker-compose --version &> /dev/null; then
+    COMPOSE="docker-compose"
+else
+    echo "Error: Docker Compose not found!"
+    exit 1
+fi
+
+case "$1" in
+    start)
+        echo "Starting all services..."
+        $COMPOSE up -d
+        ;;
+    stop)
+        echo "Stopping all services..."
+        $COMPOSE down
+        ;;
+    restart)
+        echo "Restarting all services..."
+        $COMPOSE restart
+        ;;
+    logs)
+        if [ -z "$2" ]; then
+            $COMPOSE logs -f
+        else
+            $COMPOSE logs -f "$2"
+        fi
+        ;;
+    status)
+        $COMPOSE ps
+        ;;
+    clean)
+        echo "Stopping and removing all containers and volumes..."
+        read -p "This will delete all data. Continue? (y/N) " -n 1 -r
+        echo
+        if [[ $REPLY =~ ^[Yy]$ ]]; then
+            $COMPOSE down -v
+            echo "Cleanup complete!"
+        else
+            echo "Cancelled."
+        fi
+        ;;
+    db)
+        echo "Opening scheduler database..."
+        if [ -f "scheduler.db" ]; then
+            sqlite3 scheduler.db
+        else
+            echo "Database file not found. Is the scheduler running?"
+        fi
+        ;;
+    jobs)
+        echo "Current jobs:"
+        if [ -f "scheduler.db" ]; then
+            sqlite3 scheduler.db "SELECT nocodb_id, title, prep_status, play_status, datetime(run_at) as scheduled FROM jobs ORDER BY run_at;"
+        else
+            echo "Database file not found."
+        fi
+        ;;
+    add-video)
+        if [ -z "$2" ]; then
+            echo "Usage: $0 add-video <path-to-video-file>"
+            exit 1
+        fi
+        if [ ! -f "$2" ]; then
+            echo "File not found: $2"
+            exit 1
+        fi
+        echo "Adding video to raw_movies volume..."
+        docker run --rm -v scheduler_raw_movies:/data -v "$(pwd):/host" alpine \
+            cp "/host/$2" /data/
+        echo "✓ Video added: $(basename "$2")"
+        echo "Now add an entry in NocoDB with Title matching: $(basename "$2" | cut -d. -f1)"
+        ;;
+    stream)
+        echo "To watch the stream, use one of these commands:"
+        echo ""
+        echo "VLC:"
+        echo "  vlc rtmp://localhost:1935/live/stream"
+        echo ""
+        echo "ffplay:"
+        echo "  ffplay rtmp://localhost:1935/live/stream"
+        echo ""
+        echo "MPV:"
+        echo "  mpv rtmp://localhost:1935/live/stream"
+        ;;
+    *)
+        echo "Movie Scheduler - Docker Helper"
+        echo ""
+        echo "Usage: $0 <command> [arguments]"
+        echo ""
+        echo "Commands:"
+        echo "  start              Start all services"
+        echo "  stop               Stop all services"
+        echo "  restart            Restart all services"
+        echo "  logs [service]     View logs (all or specific service)"
+        echo "  status             Show service status"
+        echo "  clean              Stop and remove all data"
+        echo "  db                 Open scheduler database (SQLite)"
+        echo "  jobs               List all jobs and their status"
+        echo "  add-video <file>   Add video to raw_movies volume"
+        echo "  stream             Show commands to watch the stream"
+        echo ""
+        echo "Examples:"
+        echo "  $0 start"
+        echo "  $0 logs scheduler"
+        echo "  $0 add-video my-movie.mp4"
+        echo "  $0 jobs"
+        ;;
+esac

init-data.sh

@@ -0,0 +1,261 @@
+#!/bin/bash
+set -e
+
+echo "========================================"
+echo "NocoDB & Test Data Initialization"
+echo "========================================"
+
+NOCODB_URL=${NOCODB_URL:-"http://nocodb:8080"}
+NOCODB_EMAIL=${NOCODB_EMAIL:-"admin@test.com"}
+NOCODB_PASSWORD=${NOCODB_PASSWORD:-"admin123"}
+
+# Wait for NocoDB to be fully ready
+echo "Waiting for NocoDB to be ready..."
+for i in {1..30}; do
+    if curl -sf "${NOCODB_URL}/api/v1/health" > /dev/null 2>&1; then
+        echo "NocoDB is ready!"
+        break
+    fi
+    echo "Attempt $i/30: NocoDB not ready yet, waiting..."
+    sleep 2
+done
+
+# Download test video (Big Buck Bunny - open source test video)
+echo ""
+echo "Downloading test video..."
+if [ ! -f "/raw_movies/BigBuckBunny.mp4" ]; then
+    wget -q -O /raw_movies/BigBuckBunny.mp4 \
+        "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4" \
+        || echo "Failed to download test video, but continuing..."
+
+    if [ -f "/raw_movies/BigBuckBunny.mp4" ]; then
+        echo "✓ Test video downloaded: BigBuckBunny.mp4"
+    else
+        echo "⚠ Could not download test video - you'll need to provide one manually"
+    fi
+else
+    echo "✓ Test video already exists"
+fi
+
+# Run Python script to setup NocoDB
+echo ""
+echo "Setting up NocoDB database and table..."
+python3 << 'PYTHON_SCRIPT'
+import requests
+import json
+import sys
+import os
+from datetime import datetime, timedelta
+
+NOCODB_URL = os.getenv("NOCODB_URL", "http://nocodb:8080")
+EMAIL = os.getenv("NOCODB_EMAIL", "admin@test.com")
+PASSWORD = os.getenv("NOCODB_PASSWORD", "admin123")
+
+print(f"Connecting to NocoDB at {NOCODB_URL}")
+
+# Step 1: Sign up (first time) or sign in
+try:
+    # Try to sign up first
+    response = requests.post(
+        f"{NOCODB_URL}/api/v1/auth/user/signup",
+        json={
+            "email": EMAIL,
+            "password": PASSWORD
+        },
+        timeout=10
+    )
+
+    if response.status_code == 200:
+        print("✓ New user created successfully")
+        auth_data = response.json()
+    else:
+        # If signup fails, try signin
+        response = requests.post(
+            f"{NOCODB_URL}/api/v1/auth/user/signin",
+            json={
+                "email": EMAIL,
+                "password": PASSWORD
+            },
+            timeout=10
+        )
+        response.raise_for_status()
+        print("✓ Signed in successfully")
+        auth_data = response.json()
+
+except Exception as e:
+    print(f"✗ Authentication failed: {e}")
+    sys.exit(1)
+
+token = auth_data.get("token")
+if not token:
+    print("✗ No token received from NocoDB")
+    sys.exit(1)
+
+print(f"✓ Got authentication token")
+
+headers = {
+    "xc-auth": token,
+    "Content-Type": "application/json"
+}
+
+# Step 2: Create a new base (project)
+try:
+    response = requests.post(
+        f"{NOCODB_URL}/api/v1/db/meta/projects/",
+        headers=headers,
+        json={
+            "title": "MovieScheduler",
+            "type": "database"
+        },
+        timeout=10
+    )
+
+    if response.status_code in [200, 201]:
+        base = response.json()
+        print(f"✓ Created base: {base.get('title')}")
+    else:
+        # Base might already exist, try to get it
+        response = requests.get(
+            f"{NOCODB_URL}/api/v1/db/meta/projects/",
+            headers=headers,
+            timeout=10
+        )
+        bases = response.json().get("list", [])
+        base = next((b for b in bases if b.get("title") == "MovieScheduler"), bases[0] if bases else None)
+
+        if not base:
+            print("✗ Could not create or find base")
+            sys.exit(1)
+        print(f"✓ Using existing base: {base.get('title')}")
+
+except Exception as e:
+    print(f"✗ Base creation failed: {e}")
+    sys.exit(1)
+
+base_id = base.get("id")
+print(f"Base ID: {base_id}")
+
+# Step 3: Get or create table
+try:
+    # List existing tables
+    response = requests.get(
+        f"{NOCODB_URL}/api/v1/db/meta/projects/{base_id}/tables",
+        headers=headers,
+        timeout=10
+    )
+    tables = response.json().get("list", [])
+
+    # Check if Movies table exists
+    movies_table = next((t for t in tables if t.get("title") == "Movies"), None)
+
+    if not movies_table:
+        # Create Movies table
+        response = requests.post(
+            f"{NOCODB_URL}/api/v1/db/meta/projects/{base_id}/tables",
+            headers=headers,
+            json={
+                "table_name": "Movies",
+                "title": "Movies",
+                "columns": [
+                    {"column_name": "Id", "title": "Id", "uidt": "ID"},
+                    {"column_name": "Title", "title": "Title", "uidt": "SingleLineText"},
+                    {"column_name": "Language", "title": "Language", "uidt": "SingleLineText"},
+                    {"column_name": "Year", "title": "Year", "uidt": "Year"},
+                    {"column_name": "Date", "title": "Date", "uidt": "DateTime"},
+                    {"column_name": "Image", "title": "Image", "uidt": "URL"},
+                    {"column_name": "IMDB", "title": "IMDB", "uidt": "URL"},
+                    {"column_name": "Time", "title": "Time", "uidt": "Duration"},
+                    {"column_name": "Kanal", "title": "Kanal", "uidt": "SingleLineText"},
+                    {"column_name": "Obejrzane", "title": "Obejrzane", "uidt": "Checkbox"}
+                ]
+            },
+            timeout=10
+        )
+        response.raise_for_status()
+        movies_table = response.json()
+        print(f"✓ Created table: Movies")
+    else:
+        print(f"✓ Using existing table: Movies")
+
+except Exception as e:
+    print(f"✗ Table creation failed: {e}")
+    sys.exit(1)
+
+table_id = movies_table.get("id")
+print(f"Table ID: {table_id}")
+
+# Step 4: Add test movie entries
+test_movies = [
+    {
+        "Title": "BigBuckBunny",
+        "Language": "po angielsku; z napisami",
+        "Year": 2008,
+        "Date": (datetime.now() + timedelta(minutes=5)).isoformat(),
+        "Image": "https://peach.blender.org/wp-content/uploads/title_anouncement.jpg",
+        "IMDB": "https://www.imdb.com/title/tt1254207/",
+        "Time": "9:56",
+        "Kanal": "TestTV",
+        "Obejrzane": False
+    },
+    {
+        "Title": "TestMovie",
+        "Language": "po angielsku; z napisami",
+        "Year": 2024,
+        "Date": (datetime.now() + timedelta(hours=1)).isoformat(),
+        "Image": "https://example.com/test.jpg",
+        "IMDB": "https://www.imdb.com/",
+        "Time": "1:30:00",
+        "Kanal": "TestTV",
+        "Obejrzane": False
+    }
+]
+
+try:
+    for movie in test_movies:
+        response = requests.post(
+            f"{NOCODB_URL}/api/v2/tables/{table_id}/records",
+            headers={"xc-token": token, "Content-Type": "application/json"},
+            json=movie,
+            timeout=10
+        )
+        if response.status_code in [200, 201]:
+            print(f"✓ Added movie: {movie['Title']}")
+        else:
+            print(f"⚠ Could not add movie {movie['Title']}: {response.text}")
+
+except Exception as e:
+    print(f"⚠ Some movies could not be added: {e}")
+
+# Step 5: Save configuration for scheduler
+print("\n" + "="*50)
+print("CONFIGURATION FOR SCHEDULER")
+print("="*50)
+print(f"NOCODB_URL: http://nocodb:8080/api/v2/tables/{table_id}/records")
+print(f"NOCODB_TOKEN: {token}")
+print(f"RTMP_SERVER: rtmp://rtmp:1935/live/stream")
+print("="*50)
+
+# Save to file that docker-compose can read
+with open("/tmp/nocodb_config.env", "w") as f:
+    f.write(f"NOCODB_TABLE_ID={table_id}\n")
+    f.write(f"NOCODB_TOKEN={token}\n")
+
+print("\n✓ Configuration saved to /tmp/nocodb_config.env")
+print("\n✓ Initialization complete!")
+
+PYTHON_SCRIPT
+
+echo ""
+echo "========================================"
+echo "✓ All initialization steps completed!"
+echo "========================================"
+echo ""
+echo "NocoDB Dashboard: http://localhost:8080"
+echo "  Email: ${NOCODB_EMAIL}"
+echo "  Password: ${NOCODB_PASSWORD}"
+echo ""
+echo "RTMP Server: rtmp://localhost:1935/live/stream"
+echo "RTMP Stats: http://localhost:8081/stat"
+echo ""
+echo "The scheduler will start automatically."
+echo "========================================"

nginx-rtmp.conf

@@ -0,0 +1,66 @@
+worker_processes auto;
+events {
+    worker_connections 1024;
+}
+
+# RTMP configuration
+rtmp {
+    server {
+        listen 1935;
+        chunk_size 4096;
+        allow publish all;
+
+        application live {
+            live on;
+            record off;
+
+            # Allow playback from anywhere
+            allow play all;
+
+            # HLS settings (optional, for web playback)
+            hls on;
+            hls_path /tmp/hls;
+            hls_fragment 3;
+            hls_playlist_length 60;
+
+            # Record streams (optional)
+            record all;
+            record_path /tmp/recordings;
+            record_suffix -%Y%m%d-%H%M%S.flv;
+        }
+    }
+}
+
+# HTTP server for HLS playback
+http {
+    server {
+        listen 80;
+
+        # HLS streaming endpoint
+        location /hls {
+            types {
+                application/vnd.apple.mpegurl m3u8;
+                video/mp2t ts;
+            }
+            root /tmp;
+            add_header Cache-Control no-cache;
+            add_header Access-Control-Allow-Origin *;
+        }
+
+        # RTMP statistics
+        location /stat {
+            rtmp_stat all;
+            rtmp_stat_stylesheet stat.xsl;
+        }
+
+        location /stat.xsl {
+            root /usr/local/nginx/html;
+        }
+
+        # Status page
+        location / {
+            root /usr/local/nginx/html;
+            index index.html;
+        }
+    }
+}

requirements.txt

@@ -0,0 +1 @@
+requests>=2.25.0

scheduler.service

@@ -0,0 +1,56 @@
+[Unit]
+Description=Movie Scheduler - Automated video processing and streaming
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=scheduler
+Group=scheduler
+WorkingDirectory=/opt/scheduler
+
+# Environment variables (or use EnvironmentFile)
+Environment="NOCODB_URL=https://your-nocodb.com/api/v2/tables/YOUR_TABLE_ID/records"
+Environment="NOCODB_TOKEN=YOUR_TOKEN_HERE"
+Environment="RTMP_SERVER=rtmp://your-rtmp-server.com/live/stream"
+Environment="RAW_DIR=/mnt/storage/raw_movies"
+Environment="FINAL_DIR=/mnt/storage/final_movies"
+Environment="WHISPER_MODEL=/opt/models/ggml-base.bin"
+Environment="VAAPI_DEVICE=/dev/dri/renderD128"
+Environment="STREAM_GRACE_PERIOD_MINUTES=15"
+Environment="NOCODB_SYNC_INTERVAL_SECONDS=60"
+Environment="WATCHDOG_CHECK_INTERVAL_SECONDS=10"
+
+# Or use external environment file (recommended for secrets)
+# EnvironmentFile=/etc/scheduler/scheduler.env
+
+# Python virtual environment
+ExecStart=/opt/scheduler/venv/bin/python /opt/scheduler/agent.py
+
+# Restart policy
+Restart=always
+RestartSec=10
+
+# Security hardening
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/mnt/storage /opt/scheduler
+
+# Allow access to GPU for VAAPI
+DeviceAllow=/dev/dri/renderD128 rw
+SupplementaryGroups=video render
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=scheduler
+
+# Resource limits (adjust based on your needs)
+LimitNOFILE=65536
+MemoryMax=4G
+CPUQuota=200%
+
+[Install]
+WantedBy=multi-user.target

scripts/backup.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+#
+# Scheduler Backup Script
+# Backs up database and configuration with rotation
+#
+
+set -e
+
+# Configuration
+BACKUP_DIR="${BACKUP_DIR:-/backup/scheduler}"
+DB_PATH="${DB_PATH:-/opt/scheduler/scheduler.db}"
+CONFIG_PATH="${CONFIG_PATH:-/etc/scheduler/scheduler.env}"
+RETENTION_DAYS=30
+COMPRESS_AFTER_DAYS=7
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+DATE=$(date +%Y%m%d_%H%M%S)
+
+echo -e "${GREEN}=== Scheduler Backup - $(date) ===${NC}"
+
+# Create backup directory
+mkdir -p "$BACKUP_DIR"
+
+# Check if database exists
+if [ ! -f "$DB_PATH" ]; then
+    echo -e "${RED}✗ Database not found: $DB_PATH${NC}"
+    exit 1
+fi
+
+# Backup database
+echo "Backing up database..."
+cp "$DB_PATH" "$BACKUP_DIR/scheduler_${DATE}.db"
+if [ $? -eq 0 ]; then
+    echo -e "${GREEN}✓ Database backed up: scheduler_${DATE}.db${NC}"
+else
+    echo -e "${RED}✗ Database backup failed${NC}"
+    exit 1
+fi
+
+# Backup config if exists
+if [ -f "$CONFIG_PATH" ]; then
+    echo "Backing up configuration..."
+    cp "$CONFIG_PATH" "$BACKUP_DIR/config_${DATE}.env"
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✓ Config backed up: config_${DATE}.env${NC}"
+    else
+        echo -e "${YELLOW}⚠ Config backup failed${NC}"
+    fi
+fi
+
+# Get database stats
+DB_SIZE=$(du -h "$BACKUP_DIR/scheduler_${DATE}.db" | cut -f1)
+JOB_COUNT=$(sqlite3 "$BACKUP_DIR/scheduler_${DATE}.db" "SELECT COUNT(*) FROM jobs;" 2>/dev/null || echo "N/A")
+echo -e "Database size: ${DB_SIZE}, Jobs: ${JOB_COUNT}"
+
+# Compress old backups (older than COMPRESS_AFTER_DAYS)
+echo "Compressing old backups..."
+COMPRESSED=$(find "$BACKUP_DIR" -name "*.db" -mtime +${COMPRESS_AFTER_DAYS} -exec gzip {} \; -print | wc -l)
+if [ $COMPRESSED -gt 0 ]; then
+    echo -e "${GREEN}✓ Compressed $COMPRESSED old backup(s)${NC}"
+fi
+
+# Delete backups older than RETENTION_DAYS
+echo "Cleaning up old backups..."
+DELETED_DB=$(find "$BACKUP_DIR" -name "*.db.gz" -mtime +${RETENTION_DAYS} -delete -print | wc -l)
+DELETED_CFG=$(find "$BACKUP_DIR" -name "*.env" -mtime +${RETENTION_DAYS} -delete -print | wc -l)
+if [ $DELETED_DB -gt 0 ] || [ $DELETED_CFG -gt 0 ]; then
+    echo -e "${GREEN}✓ Deleted $DELETED_DB database(s) and $DELETED_CFG config(s)${NC}"
+fi
+
+# List recent backups
+echo ""
+echo "Recent backups:"
+ls -lh "$BACKUP_DIR" | tail -5
+
+# Optional: Upload to S3 or remote storage
+# Uncomment and configure if needed
+#
+# if command -v aws &> /dev/null; then
+#     echo "Uploading to S3..."
+#     aws s3 cp "$BACKUP_DIR/scheduler_${DATE}.db" "s3://your-bucket/scheduler-backups/"
+#     echo -e "${GREEN}✓ Uploaded to S3${NC}"
+# fi
+
+echo ""
+echo -e "${GREEN}=== Backup completed ===${NC}"
+echo "Backup location: $BACKUP_DIR/scheduler_${DATE}.db"

scripts/monitor.sh

@@ -0,0 +1,173 @@
+#!/bin/bash
+#
+# Scheduler Monitoring Script
+# Checks service health, job status, and system resources
+#
+
+set -e
+
+# Configuration
+LOG_FILE="${LOG_FILE:-/var/log/scheduler-monitor.log}"
+DB_PATH="${DB_PATH:-/opt/scheduler/scheduler.db}"
+SERVICE_NAME="${SERVICE_NAME:-scheduler}"
+ALERT_EMAIL="${ALERT_EMAIL:-}"
+DISK_THRESHOLD=90
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+ALERTS=()
+
+echo "=== Scheduler Monitor - $TIMESTAMP ===" | tee -a "$LOG_FILE"
+
+# Check if service is running
+check_service() {
+    if systemctl is-active --quiet "$SERVICE_NAME" 2>/dev/null; then
+        echo -e "${GREEN}✓ Service is running${NC}" | tee -a "$LOG_FILE"
+        return 0
+    elif docker ps --filter "name=movie_scheduler" --format "{{.Status}}" | grep -q "Up"; then
+        echo -e "${GREEN}✓ Docker container is running${NC}" | tee -a "$LOG_FILE"
+        return 0
+    else
+        echo -e "${RED}✗ Service is DOWN${NC}" | tee -a "$LOG_FILE"
+        ALERTS+=("Service is DOWN")
+
+        # Try to restart
+        echo "Attempting to restart service..." | tee -a "$LOG_FILE"
+        systemctl start "$SERVICE_NAME" 2>/dev/null || \
+        docker compose -f /opt/scheduler/docker-compose.prod.yml restart 2>/dev/null || true
+
+        return 1
+    fi
+}
+
+# Check database
+check_database() {
+    if [ ! -f "$DB_PATH" ]; then
+        echo -e "${RED}✗ Database not found${NC}" | tee -a "$LOG_FILE"
+        ALERTS+=("Database file not found")
+        return 1
+    fi
+
+    # Database size
+    DB_SIZE=$(du -h "$DB_PATH" | cut -f1)
+    echo "Database size: $DB_SIZE" | tee -a "$LOG_FILE"
+
+    # Job counts
+    TOTAL=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs;" 2>/dev/null)
+    PENDING_PREP=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE prep_status='pending';" 2>/dev/null)
+    PENDING_PLAY=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE play_status='pending';" 2>/dev/null)
+    STREAMING=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE play_status='streaming';" 2>/dev/null)
+    FAILED=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM jobs WHERE prep_status='failed' OR play_status='failed';" 2>/dev/null)
+
+    echo "Jobs - Total: $TOTAL, Pending prep: $PENDING_PREP, Pending play: $PENDING_PLAY, Streaming: $STREAMING, Failed: $FAILED" | tee -a "$LOG_FILE"
+
+    if [ "$FAILED" -gt 0 ]; then
+        echo -e "${YELLOW}⚠ Found $FAILED failed job(s)${NC}" | tee -a "$LOG_FILE"
+        ALERTS+=("$FAILED failed jobs")
+    fi
+
+    if [ "$STREAMING" -gt 0 ]; then
+        echo -e "${GREEN}✓ $STREAMING active stream(s)${NC}" | tee -a "$LOG_FILE"
+    fi
+}
+
+# Check disk space
+check_disk() {
+    for PATH in "/mnt/storage" "/opt/scheduler" "/"; do
+        if [ -d "$PATH" ]; then
+            USAGE=$(df "$PATH" 2>/dev/null | tail -1 | awk '{print $5}' | sed 's/%//')
+            if [ -n "$USAGE" ]; then
+                if [ "$USAGE" -gt "$DISK_THRESHOLD" ]; then
+                    echo -e "${RED}✗ Disk usage for $PATH: ${USAGE}%${NC}" | tee -a "$LOG_FILE"
+                    ALERTS+=("Disk usage ${USAGE}% on $PATH")
+                else
+                    echo -e "Disk usage for $PATH: ${USAGE}%" | tee -a "$LOG_FILE"
+                fi
+            fi
+        fi
+    done
+}
+
+# Check for stuck streams
+check_stuck_streams() {
+    # Find streams that have been active for more than 4 hours
+    STUCK=$(sqlite3 "$DB_PATH" "
+        SELECT COUNT(*) FROM jobs
+        WHERE play_status='streaming'
+        AND datetime(stream_start_time) < datetime('now', '-4 hours')
+    " 2>/dev/null)
+
+    if [ "$STUCK" -gt 0 ]; then
+        echo -e "${YELLOW}⚠ Found $STUCK stream(s) active for >4 hours${NC}" | tee -a "$LOG_FILE"
+        ALERTS+=("$STUCK potentially stuck streams")
+    fi
+}
+
+# Check recent errors in logs
+check_logs() {
+    if systemctl is-active --quiet "$SERVICE_NAME" 2>/dev/null; then
+        ERROR_COUNT=$(journalctl -u "$SERVICE_NAME" --since "5 minutes ago" 2>/dev/null | grep -i "ERROR" | wc -l)
+    else
+        ERROR_COUNT=$(docker compose -f /opt/scheduler/docker-compose.prod.yml logs --since 5m 2>/dev/null | grep -i "ERROR" | wc -l || echo "0")
+    fi
+
+    if [ "$ERROR_COUNT" -gt 10 ]; then
+        echo -e "${YELLOW}⚠ Found $ERROR_COUNT errors in last 5 minutes${NC}" | tee -a "$LOG_FILE"
+        ALERTS+=("$ERROR_COUNT recent errors")
+    fi
+}
+
+# Send alerts
+send_alerts() {
+    if [ ${#ALERTS[@]} -gt 0 ]; then
+        echo "" | tee -a "$LOG_FILE"
+        echo -e "${RED}=== ALERTS ===${NC}" | tee -a "$LOG_FILE"
+        for alert in "${ALERTS[@]}"; do
+            echo "- $alert" | tee -a "$LOG_FILE"
+        done
+
+        # Send email if configured
+        if [ -n "$ALERT_EMAIL" ] && command -v mail &> /dev/null; then
+            {
+                echo "Scheduler Monitoring Alert - $TIMESTAMP"
+                echo ""
+                echo "The following issues were detected:"
+                for alert in "${ALERTS[@]}"; do
+                    echo "- $alert"
+                done
+                echo ""
+                echo "Check $LOG_FILE for details"
+            } | mail -s "Scheduler Alert" "$ALERT_EMAIL"
+        fi
+
+        # Could also send to Slack, PagerDuty, etc.
+        # Example Slack webhook:
+        # if [ -n "$SLACK_WEBHOOK" ]; then
+        #     curl -X POST -H 'Content-type: application/json' \
+        #     --data "{\"text\":\"Scheduler Alert: ${ALERTS[*]}\"}" \
+        #     "$SLACK_WEBHOOK"
+        # fi
+    fi
+}
+
+# Run checks
+check_service
+check_database
+check_disk
+check_stuck_streams
+check_logs
+send_alerts
+
+echo "" | tee -a "$LOG_FILE"
+
+# Exit with error if there are alerts
+if [ ${#ALERTS[@]} -gt 0 ]; then
+    exit 1
+fi
+
+exit 0

scripts/setup-production.sh

@@ -0,0 +1,238 @@
+#!/bin/bash
+#
+# Production Setup Script
+# Quick setup for production deployment
+#
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${BLUE}"
+echo "=========================================="
+echo "  Movie Scheduler - Production Setup"
+echo "=========================================="
+echo -e "${NC}"
+
+# Check if running as root
+if [ "$EUID" -eq 0 ]; then
+    echo -e "${RED}Please don't run as root. Run as your regular user.${NC}"
+    echo "The script will use sudo when needed."
+    exit 1
+fi
+
+# Detect deployment method
+echo "Choose deployment method:"
+echo "1) Systemd service (bare metal)"
+echo "2) Docker container"
+read -p "Enter choice [1-2]: " DEPLOY_METHOD
+
+if [ "$DEPLOY_METHOD" == "1" ]; then
+    echo -e "${GREEN}Setting up systemd service...${NC}"
+
+    # Check dependencies
+    echo "Checking dependencies..."
+    for cmd in python3 ffmpeg git sqlite3 systemctl; do
+        if ! command -v $cmd &> /dev/null; then
+            echo -e "${RED}✗ Missing: $cmd${NC}"
+            echo "Install it with: sudo apt-get install $cmd"
+            exit 1
+        else
+            echo -e "${GREEN}✓ Found: $cmd${NC}"
+        fi
+    done
+
+    # Check whisper.cpp
+    if ! command -v whisper.cpp &> /dev/null; then
+        echo -e "${YELLOW}⚠ whisper.cpp not found${NC}"
+        read -p "Install whisper.cpp now? [y/N]: " INSTALL_WHISPER
+        if [[ $INSTALL_WHISPER =~ ^[Yy]$ ]]; then
+            echo "Installing whisper.cpp..."
+            git clone https://github.com/ggerganov/whisper.cpp.git /tmp/whisper.cpp
+            cd /tmp/whisper.cpp
+            make
+            sudo cp main /usr/local/bin/whisper.cpp
+            sudo chmod +x /usr/local/bin/whisper.cpp
+            rm -rf /tmp/whisper.cpp
+            echo -e "${GREEN}✓ whisper.cpp installed${NC}"
+        fi
+    fi
+
+    # Create scheduler user
+    if ! id -u scheduler &> /dev/null; then
+        echo "Creating scheduler user..."
+        sudo useradd -r -s /bin/bash -d /opt/scheduler -m scheduler
+        sudo usermod -aG video,render scheduler
+        echo -e "${GREEN}✓ User created${NC}"
+    else
+        echo -e "${GREEN}✓ User already exists${NC}"
+    fi
+
+    # Create directories
+    echo "Creating directories..."
+    sudo mkdir -p /opt/scheduler /opt/models
+    sudo mkdir -p /mnt/storage/raw_movies /mnt/storage/final_movies
+    sudo chown scheduler:scheduler /opt/scheduler
+    sudo chown scheduler:scheduler /mnt/storage/raw_movies /mnt/storage/final_movies
+
+    # Copy application files
+    echo "Copying application files..."
+    SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+    PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+    sudo -u scheduler cp "$PROJECT_DIR/agent.py" /opt/scheduler/
+    sudo -u scheduler cp "$PROJECT_DIR/requirements.txt" /opt/scheduler/
+
+    # Create virtual environment
+    echo "Setting up Python virtual environment..."
+    sudo -u scheduler python3 -m venv /opt/scheduler/venv
+    sudo -u scheduler /opt/scheduler/venv/bin/pip install --upgrade pip
+    sudo -u scheduler /opt/scheduler/venv/bin/pip install -r /opt/scheduler/requirements.txt
+
+    # Download whisper model if needed
+    if [ ! -f "/opt/models/ggml-base.bin" ]; then
+        echo "Downloading whisper model..."
+        sudo wget -q -O /opt/models/ggml-base.bin \
+            https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin
+        echo -e "${GREEN}✓ Model downloaded${NC}"
+    fi
+
+    # Create config directory
+    echo "Setting up configuration..."
+    sudo mkdir -p /etc/scheduler
+
+    # Create environment file
+    if [ ! -f "/etc/scheduler/scheduler.env" ]; then
+        cat << 'EOF' | sudo tee /etc/scheduler/scheduler.env > /dev/null
+# NocoDB Configuration
+NOCODB_URL=https://your-nocodb.com/api/v2/tables/YOUR_TABLE_ID/records
+NOCODB_TOKEN=YOUR_TOKEN_HERE
+
+# RTMP Server
+RTMP_SERVER=rtmp://your-rtmp-server.com/live/stream
+
+# Storage Paths
+RAW_DIR=/mnt/storage/raw_movies
+FINAL_DIR=/mnt/storage/final_movies
+
+# Whisper Model
+WHISPER_MODEL=/opt/models/ggml-base.bin
+
+# VAAPI Device
+VAAPI_DEVICE=/dev/dri/renderD128
+
+# Timing
+NOCODB_SYNC_INTERVAL_SECONDS=60
+WATCHDOG_CHECK_INTERVAL_SECONDS=10
+STREAM_GRACE_PERIOD_MINUTES=15
+EOF
+        sudo chmod 600 /etc/scheduler/scheduler.env
+        sudo chown scheduler:scheduler /etc/scheduler/scheduler.env
+
+        echo -e "${YELLOW}⚠ IMPORTANT: Edit /etc/scheduler/scheduler.env with your actual values${NC}"
+        echo "  sudo nano /etc/scheduler/scheduler.env"
+    fi
+
+    # Install systemd service
+    echo "Installing systemd service..."
+    sudo cp "$PROJECT_DIR/scheduler.service" /etc/systemd/system/
+    sudo sed -i 's|^Environment=|# Environment=|g' /etc/systemd/system/scheduler.service
+    sudo sed -i 's|^# EnvironmentFile=|EnvironmentFile=|g' /etc/systemd/system/scheduler.service
+    sudo systemctl daemon-reload
+
+    echo ""
+    echo -e "${GREEN}=== Installation Complete ===${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "1. Edit configuration:"
+    echo "   sudo nano /etc/scheduler/scheduler.env"
+    echo ""
+    echo "2. Enable and start service:"
+    echo "   sudo systemctl enable scheduler"
+    echo "   sudo systemctl start scheduler"
+    echo ""
+    echo "3. Check status:"
+    echo "   sudo systemctl status scheduler"
+    echo ""
+    echo "4. View logs:"
+    echo "   sudo journalctl -u scheduler -f"
+
+elif [ "$DEPLOY_METHOD" == "2" ]; then
+    echo -e "${GREEN}Setting up Docker deployment...${NC}"
+
+    # Check docker
+    if ! command -v docker &> /dev/null; then
+        echo -e "${RED}✗ Docker not found${NC}"
+        echo "Install Docker first: https://docs.docker.com/get-docker/"
+        exit 1
+    fi
+
+    # Check docker compose
+    if ! docker compose version &> /dev/null && ! docker-compose --version &> /dev/null; then
+        echo -e "${RED}✗ Docker Compose not found${NC}"
+        exit 1
+    fi
+
+    SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+    PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+    # Create deployment directory
+    read -p "Installation directory [/opt/scheduler]: " INSTALL_DIR
+    INSTALL_DIR=${INSTALL_DIR:-/opt/scheduler}
+
+    sudo mkdir -p "$INSTALL_DIR"
+    sudo chown $USER:$USER "$INSTALL_DIR"
+
+    # Copy files
+    echo "Copying files..."
+    cp "$PROJECT_DIR/agent.py" "$INSTALL_DIR/"
+    cp "$PROJECT_DIR/requirements.txt" "$INSTALL_DIR/"
+    cp "$PROJECT_DIR/Dockerfile" "$INSTALL_DIR/"
+    cp "$PROJECT_DIR/docker-compose.prod.yml" "$INSTALL_DIR/"
+
+    # Create environment file
+    if [ ! -f "$INSTALL_DIR/.env.production" ]; then
+        cp "$PROJECT_DIR/.env.production.example" "$INSTALL_DIR/.env.production"
+        echo -e "${YELLOW}⚠ Edit $INSTALL_DIR/.env.production with your actual values${NC}"
+    fi
+
+    # Create storage directories
+    sudo mkdir -p /mnt/storage/raw_movies /mnt/storage/final_movies
+    sudo mkdir -p /opt/models
+
+    # Download whisper model
+    if [ ! -f "/opt/models/ggml-base.bin" ]; then
+        echo "Downloading whisper model..."
+        sudo wget -q -O /opt/models/ggml-base.bin \
+            https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin
+        echo -e "${GREEN}✓ Model downloaded${NC}"
+    fi
+
+    echo ""
+    echo -e "${GREEN}=== Installation Complete ===${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "1. Edit configuration:"
+    echo "   nano $INSTALL_DIR/.env.production"
+    echo ""
+    echo "2. Build and start:"
+    echo "   cd $INSTALL_DIR"
+    echo "   docker compose -f docker-compose.prod.yml up -d"
+    echo ""
+    echo "3. View logs:"
+    echo "   docker compose -f docker-compose.prod.yml logs -f"
+    echo ""
+    echo "4. Check status:"
+    echo "   docker compose -f docker-compose.prod.yml ps"
+
+else
+    echo -e "${RED}Invalid choice${NC}"
+    exit 1
+fi
+
+echo ""
+echo -e "${BLUE}See PRODUCTION.md for complete documentation${NC}"

start-scheduler.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+
+echo "Starting Movie Scheduler..."
+
+# Wait for config file from init container
+CONFIG_FILE="/config/nocodb_config.env"
+echo "Waiting for initialization to complete..."
+
+for i in {1..60}; do
+    if [ -f "$CONFIG_FILE" ]; then
+        echo "✓ Configuration found!"
+        break
+    fi
+    if [ $i -eq 60 ]; then
+        echo "✗ Timeout waiting for configuration"
+        exit 1
+    fi
+    sleep 1
+done
+
+# Load configuration
+source "$CONFIG_FILE"
+
+# Set environment variables for the scheduler
+export NOCODB_URL="http://nocodb:8080/api/v2/tables/${NOCODB_TABLE_ID}/records"
+export NOCODB_TOKEN="${NOCODB_TOKEN}"
+export RTMP_SERVER="${RTMP_SERVER:-rtmp://rtmp:1935/live/stream}"
+
+echo "Configuration loaded:"
+echo "  NOCODB_URL: $NOCODB_URL"
+echo "  RTMP_SERVER: $RTMP_SERVER"
+echo ""
+echo "Starting scheduler agent..."
+
+# Start the scheduler
+exec python -u agent.py

start-test-environment.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+
+echo "=========================================="
+echo "  Movie Scheduler - Test Environment"
+echo "=========================================="
+echo ""
+
+# Make scripts executable
+chmod +x init-data.sh start-scheduler.sh 2>/dev/null || true
+
+# Check if docker compose is available
+if ! command -v docker &> /dev/null; then
+    echo "✗ Docker is not installed!"
+    echo "Please install Docker first: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+if docker compose version &> /dev/null; then
+    COMPOSE_CMD="docker compose"
+elif docker-compose --version &> /dev/null; then
+    COMPOSE_CMD="docker-compose"
+else
+    echo "✗ Docker Compose is not installed!"
+    echo "Please install Docker Compose first"
+    exit 1
+fi
+
+echo "✓ Using: $COMPOSE_CMD"
+echo ""
+
+# Stop any existing containers
+echo "Stopping any existing containers..."
+$COMPOSE_CMD down 2>/dev/null || true
+
+# Build and start all services
+echo ""
+echo "Building and starting all services..."
+echo "This may take a few minutes on first run..."
+echo ""
+
+$COMPOSE_CMD up --build -d
+
+echo ""
+echo "=========================================="
+echo "  Waiting for services to initialize..."
+echo "=========================================="
+echo ""
+
+# Wait for init to complete
+echo "Waiting for initialization to complete (this may take 30-60 seconds)..."
+sleep 5
+
+# Follow init logs
+echo ""
+echo "--- Initialization Progress ---"
+$COMPOSE_CMD logs -f init &
+LOGS_PID=$!
+
+# Wait for init to complete
+while true; do
+    STATUS=$($COMPOSE_CMD ps init --format json 2>/dev/null | jq -r '.[0].State' 2>/dev/null || echo "unknown")
+
+    if [ "$STATUS" = "exited" ]; then
+        kill $LOGS_PID 2>/dev/null || true
+        wait $LOGS_PID 2>/dev/null || true
+        echo ""
+        echo "✓ Initialization completed!"
+        break
+    fi
+
+    sleep 2
+done
+
+echo ""
+echo "=========================================="
+echo "  Test Environment Ready!"
+echo "=========================================="
+echo ""
+echo "📺 NocoDB Dashboard:"
+echo "   URL: http://localhost:8080"
+echo "   Email: admin@test.com"
+echo "   Password: admin123"
+echo ""
+echo "📡 RTMP Server:"
+echo "   Stream URL: rtmp://localhost:1935/live/stream"
+echo "   Statistics: http://localhost:8081/stat"
+echo ""
+echo "🎬 Scheduler:"
+echo "   Status: Running"
+echo "   Database: ./scheduler.db"
+echo ""
+echo "=========================================="
+echo "  Useful Commands:"
+echo "=========================================="
+echo ""
+echo "View scheduler logs:"
+echo "  $COMPOSE_CMD logs -f scheduler"
+echo ""
+echo "View all logs:"
+echo "  $COMPOSE_CMD logs -f"
+echo ""
+echo "Check service status:"
+echo "  $COMPOSE_CMD ps"
+echo ""
+echo "Stop all services:"
+echo "  $COMPOSE_CMD down"
+echo ""
+echo "Stop and remove all data:"
+echo "  $COMPOSE_CMD down -v"
+echo ""
+echo "=========================================="
+echo ""
+echo "The scheduler is now monitoring NocoDB for movies to process."
+echo "A test movie 'BigBuckBunny' has been added and will be"
+echo "processed 6 hours before its scheduled time."
+echo ""
+echo "To watch the stream, use a player like VLC:"
+echo "  vlc rtmp://localhost:1935/live/stream"
+echo ""