more fixes

backend/scripts/backup.py

@@ -6,41 +6,29 @@ import datetime
 import sqlite3
 from pathlib import Path
 from huggingface_hub import HfApi, hf_hub_download, CommitOperationAdd
+from open_webui.env import DATA_DIR
 
-###############################################################################
-# 1) Determine DB location from your env.py (DATA_DIR), defaulting to /app/backend/data
-###############################################################################
-DATA_DIR = os.environ.get("DATA_DIR", "/app/backend/data")
+# Application database path
 DB_FILE_PATH = os.path.join(DATA_DIR, "webui.db")
 
-###############################################################################
-# 2) Use /workspace (guaranteed writable on HF Spaces) for backups.
-###############################################################################
-BACKUP_DIR = "/workspace/open_webui/db_backup"
+# Backup paths
+BACKUP_DIR = os.environ.get("BACKUP_DIR", "/tmp/open_webui/db_backup")
 TIMESTAMP_FILE_PATH = os.path.join(BACKUP_DIR, "last_backup_time.txt")
 DB_GPG_PATH = os.path.join(BACKUP_DIR, "webui.db.gpg")
 
-# Paths in the Hugging Face repo
+# Hugging Face repo paths
 REPO_TIMESTAMP_FILE = "db_backup/last_backup_time.txt"
 REPO_DB_GPG_FILE = "db_backup/webui.db.gpg"
 
 
 def ensure_directories():
-    """
-    Create/verify /workspace/open_webui/db_backup.
-    """
     try:
         os.makedirs(BACKUP_DIR, mode=0o755, exist_ok=True)
-        dir_stat = os.stat(BACKUP_DIR)
-        print(f"Backup directory {BACKUP_DIR} exists with permissions: {oct(dir_stat.st_mode)[-3:]}")
-        
-        # Quick test to verify we can write
         test_file = os.path.join(BACKUP_DIR, '.write_test')
         with open(test_file, 'w') as f:
             f.write('test')
         os.remove(test_file)
         print(f"Successfully verified write access to {BACKUP_DIR}")
-        
         return True
     except Exception as e:
         print(f"Error creating/verifying backup directory: {e}")
@@ -48,18 +36,11 @@ def ensure_directories():
 
 
 def verify_database():
-    """
-    Check that webui.db exists and passes PRAGMA integrity_check.
-    """
     if not os.path.exists(DB_FILE_PATH):
         print(f"Database file not found at: {DB_FILE_PATH}")
         return False
         
     try:
-        file_stat = os.stat(DB_FILE_PATH)
-        print(f"Database file size: {file_stat.st_size:,} bytes")
-        print(f"Database file permissions: {oct(file_stat.st_mode)[-3:]}")
-        
         with sqlite3.connect(DB_FILE_PATH) as conn:
             cursor = conn.cursor()
             cursor.execute("PRAGMA integrity_check;")
@@ -68,80 +49,52 @@ def verify_database():
             tables = cursor.fetchall()
             
             if result.lower() == "ok" and len(tables) > 0:
-                print("Database integrity verified successfully.")
-                print(f"Found {len(tables)} tables in database.")
+                print(f"Database verified: {len(tables)} tables found")
                 return True
             else:
-                print("Database integrity check failed.")
-                if result.lower() != "ok":
-                    print(f"Integrity check result: {result}")
-                if len(tables) == 0:
-                    print("No tables found in database.")
+                print("Database verification failed")
                 return False
-    except sqlite3.Error as e:
-        print(f"SQLite error: {e}")
-        return False
     except Exception as e:
-        print(f"Unexpected error: {e}")
+        print(f"Database verification error: {e}")
         return False
 
 
 def encrypt_database(passphrase):
-    """
-    Encrypt /app/backend/data/webui.db to /workspace/open_webui/db_backup/webui.db.gpg.
-    """
     try:
-        print("\nPreparing for database encryption...")
-        
-        # Make sure .gnupg is created with correct permissions
-        gnupg_dir = '/root/.gnupg'
-        os.makedirs(gnupg_dir, mode=0o700, exist_ok=True)
+        os.makedirs('/root/.gnupg', mode=0o700, exist_ok=True)
         
-        print("Running GPG encryption...")
         encrypt_cmd = [
             "gpg",
             "--batch",
             "--yes",
             "--passphrase", passphrase,
-            "--pinentry-mode", "loopback",     # <--- important in containers
+            "--pinentry-mode", "loopback",
             "-c",
             "--cipher-algo", "AES256",
             "-o", DB_GPG_PATH,
             DB_FILE_PATH
         ]
         
-        result = subprocess.run(
-            encrypt_cmd,
-            capture_output=True,
-            text=True
-        )
+        result = subprocess.run(encrypt_cmd, capture_output=True, text=True)
         
         if result.returncode != 0:
-            print(f"GPG encryption failed with code {result.returncode}")
-            print(f"GPG stderr: {result.stderr}")
+            print(f"GPG encryption failed: {result.stderr}")
             return False
         
         if os.path.exists(DB_GPG_PATH):
-            size = os.path.getsize(DB_GPG_PATH)
-            print(f"Encryption successful. Encrypted file size: {size:,} bytes")
+            print(f"Encryption successful. File size: {os.path.getsize(DB_GPG_PATH):,} bytes")
             return True
-        else:
-            print("GPG reported success, but webui.db.gpg not found.")
-            return False
+        return False
     except Exception as e:
-        print(f"Encryption failed: {e}")
+        print(f"Encryption error: {e}")
         return False
 
 
 def get_last_backup_time(repo_id, hf_token):
-    """
-    Retrieve last backup timestamp from the HF repo (if it exists).
-    """
     try:
         api = HfApi()
         files = api.list_repo_files(repo_id=repo_id, repo_type="space", token=hf_token)
         if REPO_TIMESTAMP_FILE not in files:
-            print("No timestamp file found in repository.")
             return None
         
         tmp_file = hf_hub_download(
@@ -159,9 +112,6 @@ def get_last_backup_time(repo_id, hf_token):
 
 
 def save_timestamp_locally():
-    """
-    Save the current UTC time to /workspace/open_webui/db_backup/last_backup_time.txt
-    """
     try:
         now = datetime.datetime.now(datetime.timezone.utc)
         os.makedirs(os.path.dirname(TIMESTAMP_FILE_PATH), exist_ok=True)
@@ -170,7 +120,6 @@ def save_timestamp_locally():
         with open(temp_path, "w", encoding="utf-8") as f:
             f.write(now.isoformat())
         os.replace(temp_path, TIMESTAMP_FILE_PATH)
-        
         return True
     except Exception as e:
         print(f"Error saving timestamp: {e}")
@@ -178,26 +127,15 @@ def save_timestamp_locally():
 
 
 def backup_db():
-    """
-    Main backup process:
-      - Read passphrase, HF creds
-      - Create /workspace/open_webui/db_backup
-      - Possibly skip if threshold not met
-      - Verify DB
-      - Encrypt DB
-      - Save timestamp
-      - Upload to HF
-    """
     passphrase = os.environ.get("BACKUP_PASSPHRASE")
     hf_token = os.environ.get("HF_TOKEN")
     space_id = os.environ.get("SPACE_ID")
     
     if not all([passphrase, hf_token, space_id]):
-        print("Error: Missing required environment variables (BACKUP_PASSPHRASE, HF_TOKEN, SPACE_ID).")
+        print("Error: Missing required environment variables (BACKUP_PASSPHRASE, HF_TOKEN, SPACE_ID)")
         return False
     
     if not ensure_directories():
-        print("Failed to create or verify backup directories.")
         return False
     
     threshold_minutes = int(os.environ.get("BACKUP_THRESHOLD_MINUTES", 120))
@@ -209,39 +147,23 @@ def backup_db():
                 last_backup_dt = last_backup_dt.replace(tzinfo=datetime.timezone.utc)
             elapsed = now - last_backup_dt
             if elapsed.total_seconds() < threshold_minutes * 60:
-                print(f"Last backup was only {elapsed.total_seconds()/60:.1f} min ago.")
-                print(f"Threshold is {threshold_minutes} minutes. Skipping backup.")
+                print(f"Last backup was {elapsed.total_seconds()/60:.1f} min ago (threshold: {threshold_minutes})")
                 return True
-    else:
-        print("Backup threshold check disabled (0).")
     
-    # Verify DB
     if not verify_database():
-        print("Database verification failed, aborting backup.")
         return False
     
-    # Encrypt
     if not encrypt_database(passphrase):
-        print("Database encryption failed, aborting backup.")
         return False
     
-    # Save timestamp
     if not save_timestamp_locally():
-        print("Warning: Failed to save timestamp, but continuing upload.")
+        print("Warning: Failed to save timestamp")
     
-    # Upload to HF
-    print("\nUploading to Hugging Face Spaces...")
     try:
         api = HfApi()
         operations = [
-            CommitOperationAdd(
-                path_in_repo=REPO_DB_GPG_FILE,
-                path_or_fileobj=DB_GPG_PATH
-            ),
-            CommitOperationAdd(
-                path_in_repo=REPO_TIMESTAMP_FILE,
-                path_or_fileobj=TIMESTAMP_FILE_PATH
-            )
+            CommitOperationAdd(path_in_repo=REPO_DB_GPG_FILE, path_or_fileobj=DB_GPG_PATH),
+            CommitOperationAdd(path_in_repo=REPO_TIMESTAMP_FILE, path_or_fileobj=TIMESTAMP_FILE_PATH)
         ]
         api.create_commit(
             repo_id=space_id,
@@ -253,7 +175,7 @@ def backup_db():
         print("Backup files uploaded successfully!")
         return True
     except Exception as e:
-        print(f"Error uploading backup to HF: {e}")
+        print(f"Error uploading to HF: {e}")
         return False
 
 

backend/scripts/restore.py

@@ -5,47 +5,32 @@ import subprocess
 import datetime
 import sqlite3
 from pathlib import Path
-
 from huggingface_hub import HfApi, hf_hub_download
+from open_webui.env import DATA_DIR  # Import actual DATA_DIR from application
 
-###############################################################################
-# 1) Determine the *final* database file location.
-#    - We read DATA_DIR from env, defaulting to "/app/backend/data".
-#    - The final DB (decrypted) should be "/app/backend/data/webui.db" so
-#      the app will use the restored DB on startup.
-###############################################################################
-DATA_DIR = os.environ.get("DATA_DIR", "/app/backend/data")
+# Application database path
 DB_FILE_PATH = os.path.join(DATA_DIR, "webui.db")
 
-###############################################################################
-# 2) Where we put the encrypted backup and timestamp locally.
-#    - A writable directory on Hugging Face is "/tmp/open_webui/db_backup".
-###############################################################################
-RESTORE_BACKUP_DIR = "/tmp/open_webui/db_backup"
+# Restore paths
+RESTORE_BACKUP_DIR = os.environ.get("BACKUP_DIR", "/tmp/open_webui/db_backup")
 DB_GPG_PATH = os.path.join(RESTORE_BACKUP_DIR, "webui.db.gpg")
 TIMESTAMP_FILE_PATH = os.path.join(RESTORE_BACKUP_DIR, "last_backup_time.txt")
 
-# Paths in the Hugging Face repo
+# Hugging Face repo paths
 REPO_TIMESTAMP_FILE = "db_backup/last_backup_time.txt"
 REPO_DB_GPG_FILE = "db_backup/webui.db.gpg"
 
 
 def check_requirements():
-    """
-    Verify that GPG is installed and available in the system.
-    """
     try:
         subprocess.run(["gpg", "--version"], check=True, capture_output=True)
         return True
     except (subprocess.CalledProcessError, FileNotFoundError):
-        print("Error: gpg is not installed or not in PATH.")
+        print("Error: gpg is not installed or not in PATH")
         return False
 
 
 def validate_secrets():
-    """
-    Ensure all required environment variables are set: BACKUP_PASSPHRASE, HF_TOKEN, SPACE_ID.
-    """
     required_vars = ["BACKUP_PASSPHRASE", "HF_TOKEN", "SPACE_ID"]
     missing = [var for var in required_vars if not os.environ.get(var)]
     
@@ -56,15 +41,8 @@ def validate_secrets():
 
 
 def ensure_directories():
-    """
-    Create necessary directories for database (DATA_DIR) and backup files (RESTORE_BACKUP_DIR).
-    We must ensure the final DB directory is writable so the decrypted DB can be placed there.
-    """
     try:
-        # Create the final DB folder (if not already existing)
         os.makedirs(DATA_DIR, mode=0o755, exist_ok=True)
-
-        # Create the backup folder in /tmp
         os.makedirs(RESTORE_BACKUP_DIR, mode=0o755, exist_ok=True)
         return True
     except Exception as e:
@@ -73,20 +51,15 @@ def ensure_directories():
 
 
 def get_latest_backup_info(repo_id, hf_token):
-    """
-    Check if a backup (webui.db.gpg) exists in the HF Space. If so, return True + timestamp (or None).
-    """
     api = HfApi()
     try:
         files = api.list_repo_files(repo_id=repo_id, repo_type="space", token=hf_token)
         
-        # Check if the encrypted DB is present
         backup_exists = (REPO_DB_GPG_FILE in files)
         if not backup_exists:
-            print("No backup file found in the repository.")
+            print("No backup file found in repository")
             return False, None
         
-        # Attempt to fetch the timestamp file
         if REPO_TIMESTAMP_FILE in files:
             try:
                 timestamp_file = hf_hub_download(
@@ -101,20 +74,15 @@ def get_latest_backup_info(repo_id, hf_token):
                 print(f"Found backup from: {timestamp} UTC")
                 return True, timestamp
             except Exception as e:
-                print(f"Could not read timestamp (possibly first run): {e}")
+                print(f"Could not read timestamp: {e}")
                 return True, None
-        else:
-            print("No timestamp file found, but backup file exists.")
-            return True, None
+        return True, None
     except Exception as e:
         print(f"Error checking repository: {e}")
         return False, None
 
 
 def download_backup(repo_id, hf_token):
-    """
-    Download the encrypted database backup from Hugging Face to /tmp/open_webui/db_backup.
-    """
     try:
         print("Downloading encrypted database backup...")
         temp_file = hf_hub_download(
@@ -123,9 +91,8 @@ def download_backup(repo_id, hf_token):
             filename=REPO_DB_GPG_FILE,
             token=hf_token
         )
-        # Move the downloaded file to DB_GPG_PATH
         os.replace(temp_file, DB_GPG_PATH)
-        print("Backup downloaded successfully.")
+        print("Backup downloaded successfully")
         return True
     except Exception as e:
         print(f"Error downloading backup: {e}")
@@ -133,20 +100,13 @@ def download_backup(repo_id, hf_token):
 
 
 def decrypt_database(passphrase):
-    """
-    Decrypt the database into DATA_DIR/webui.db so the app can use it.
-    The encrypted file is at /tmp/open_webui/db_backup/webui.db.gpg.
-    """
     if not os.path.exists(DB_GPG_PATH):
-        print("No encrypted backup found locally. Proceeding with fresh DB.")
-        return True  # Not necessarily an error
+        print("No encrypted backup found locally. Starting with fresh DB")
+        return True
     
     try:
-        print("Decrypting database with GPG...")
-        
-        # Ensure /root/.gnupg is set up
-        gnupg_dir = "/root/.gnupg"
-        os.makedirs(gnupg_dir, mode=0o700, exist_ok=True)
+        print("Decrypting database...")
+        os.makedirs("/root/.gnupg", mode=0o700, exist_ok=True)
         
         decrypt_cmd = [
             "gpg",
@@ -161,18 +121,12 @@ def decrypt_database(passphrase):
         print(f"Database decrypted successfully to {DB_FILE_PATH}")
         return True
     except subprocess.CalledProcessError as e:
-        print(f"Failed to decrypt database: {e}")
-        if e.stderr:
-            print(f"GPG error output: {e.stderr.decode(errors='ignore')}")
+        print(f"Decryption failed: {e.stderr.decode(errors='ignore')}")
         return False
 
 
 def verify_database():
-    """
-    Verify the integrity of the restored DB at DATA_DIR/webui.db using SQLite's built-in checks.
-    """
     if not os.path.exists(DB_FILE_PATH):
-        # If there's no DB yet, might be fresh start, not an immediate error
         return True
     
     try:
@@ -185,32 +139,17 @@ def verify_database():
             tables = cursor.fetchall()
             
             if result.lower() == "ok" and len(tables) > 0:
-                print("Database integrity verified successfully.")
-                print(f"Found {len(tables)} tables in database.")
+                print(f"Database verified: {len(tables)} tables found")
                 return True
             else:
-                print("Database integrity check failed.")
-                if result.lower() != "ok":
-                    print(f"Integrity check result: {result}")
-                if len(tables) == 0:
-                    print("No tables found in database.")
+                print("Database verification failed")
                 return False
-    except sqlite3.Error as e:
-        print(f"Database verification failed: {e}")
-        return False
     except Exception as e:
-        print(f"Unexpected error during database verification: {e}")
+        print(f"Database verification error: {e}")
         return False
 
 
 def restore_db():
-    """
-    Main restore function:
-      1. Check GPG + environment
-      2. Create directories
-      3. Check if remote backup exists, download + decrypt
-      4. Verify DB
-    """
     if not check_requirements() or not validate_secrets():
         return False
     
@@ -224,21 +163,17 @@ def restore_db():
     backup_exists, timestamp = get_latest_backup_info(space_id, hf_token)
     if backup_exists:
         if not download_backup(space_id, hf_token):
-            print("Failed to download backup.")
             return False
         
         if not decrypt_database(passphrase):
-            print("Failed to decrypt database.")
             return False
         
         if not verify_database():
-            print("Database integrity verification failed.")
-            # Remove the corrupted DB so we don’t keep a broken file
             if os.path.exists(DB_FILE_PATH):
                 os.unlink(DB_FILE_PATH)
             return False
     else:
-        print("No backup found - starting with an empty/fresh database.")
+        print("No backup found - starting with fresh database")
     
     print("Database restore completed successfully!")
     return True

backend/start.sh

@@ -1,150 +1,97 @@
 #!/usr/bin/env bash
 
-SCRIPT_PATH=$(readlink -f "${BASH_SOURCE[0]}")
-SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
-ORIGINAL_DIR=$(pwd)
+SCRIPT_DIR=$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")
+cd "$SCRIPT_DIR" || exit 1
 
-log_message() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
-}
+# Configure paths and environment
+export DATA_DIR="/app/backend/data"
+export BACKUP_DIR="/tmp/open_webui/db_backup"
 
-validate_environment() {
-    # Check if we're in the expected directory structure
-    if [[ "$(pwd)" != *"/app/backend" ]]; then
-        log_message "Warning: Unexpected working directory: $(pwd)"
-        log_message "Expected path to contain: /app/backend"
-        return 1
-    fi
-    return 0
-}
-
-log_message "Changing to script directory: $SCRIPT_DIR"
-cd "$SCRIPT_DIR" || {
-    log_message "Error: Could not change to directory: $SCRIPT_DIR"
-    exit 1
-}
-
-validate_environment || {
-    log_message "Warning: Environment validation failed, but continuing..."
-}
-
-log_message "Working from directory: $(pwd)"
-
-# ---------------------------------------------------------------------------
-# IMPORTANT: We no longer rely on /app/backend/data or /app/backend/db_backup.
-# We define external paths (matching our updated backup/restore scripts):
-# ---------------------------------------------------------------------------
-SCRIPTS_DIR="$SCRIPT_DIR/scripts"
-DATA_DIR="/tmp/open_webui/data"
-BACKUP_DIR="/tmp/open_webui/db_backup"
-
-# Validate required environment variables for backup/restore operations
+# Validate environment variables
 for var in "BACKUP_PASSPHRASE" "HF_TOKEN" "SPACE_ID"; do
     if [ -z "${!var}" ]; then
-        echo "Error: $var is not set. This is required for database backup/restore operations."
+        echo "Error: $var is not set. Required for database backup/restore."
         exit 1
     fi
 done
 
-# Restore database from backup using absolute path to restore.py
-log_message "Restoring database from backup..."
-python "$SCRIPTS_DIR/restore.py"
+# Restore database from backup
+echo "Restoring database from backup..."
+python "$SCRIPT_DIR/scripts/restore.py"
 restore_status=$?
 if [ $restore_status -ne 0 ]; then
-    log_message "Warning: Database restore failed. Starting with empty database."
+    echo "Warning: Database restore failed. Starting with empty database."
 fi
 
-# Handle WebUI secret key generation/loading
+# Handle WebUI secret key
 KEY_FILE="$SCRIPT_DIR/.webui_secret_key"
 PORT="${PORT:-8080}"
 HOST="${HOST:-0.0.0.0}"
 
 if test "$WEBUI_SECRET_KEY $WEBUI_JWT_SECRET_KEY" = " "; then
-    log_message "Loading WEBUI_SECRET_KEY from file, not provided as an environment variable."
     if ! [ -e "$KEY_FILE" ]; then
-        log_message "Generating WEBUI_SECRET_KEY"
-        head -c 12 /dev/random | base64 > "$KEY_FILE" || {
-            log_message "Error: Could not generate secret key"
-            exit 1
-        }
+        head -c 12 /dev/random | base64 > "$KEY_FILE" || exit 1
     fi
-    log_message "Loading WEBUI_SECRET_KEY from $KEY_FILE"
-    WEBUI_SECRET_KEY=$(cat "$KEY_FILE") || {
-        log_message "Error: Could not read secret key"
-        exit 1
-    }
+    WEBUI_SECRET_KEY=$(cat "$KEY_FILE") || exit 1
 fi
 
-# Optional: Start Ollama if USE_OLLAMA_DOCKER is true
+# Start Ollama if enabled
 if [[ "${USE_OLLAMA_DOCKER,,}" == "true" ]]; then
-    log_message "USE_OLLAMA_DOCKER is set to true, starting ollama serve."
     ollama serve &
 fi
 
-# Configure CUDA environment if enabled
+# Configure CUDA if enabled
 if [[ "${USE_CUDA_DOCKER,,}" == "true" ]]; then
-    log_message "CUDA is enabled, configuring LD_LIBRARY_PATH"
     export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/lib/python3.11/site-packages/torch/lib:/usr/local/lib/python3.11/site-packages/nvidia/cudnn/lib"
 fi
 
 # Handle HuggingFace Space deployment
 if [ -n "$SPACE_ID" ]; then
-    echo "Configuring for HuggingFace Space deployment"
+    echo "Configuring HuggingFace Space deployment"
     if [ -n "$ADMIN_USER_EMAIL" ] && [ -n "$ADMIN_USER_PASSWORD" ]; then
-        echo "Admin user configured, creating"
         WEBUI_SECRET_KEY="$WEBUI_SECRET_KEY" uvicorn open_webui.main:app --host "$HOST" --port "$PORT" --forwarded-allow-ips '*' &
         webui_pid=$!
-        echo "Waiting for webui to start..."
+        
         while ! curl -s http://localhost:8080/health > /dev/null; do
             sleep 1
         done
-        echo "Creating admin user..."
+        
         curl \
             -X POST "http://localhost:8080/api/v1/auths/signup" \
             -H "accept: application/json" \
             -H "Content-Type: application/json" \
             -d "{ \"email\": \"${ADMIN_USER_EMAIL}\", \"password\": \"${ADMIN_USER_PASSWORD}\", \"name\": \"Admin\" }"
-        echo "Shutting down temporary webui instance..."
+            
         kill $webui_pid
     fi
     export WEBUI_URL=${SPACE_HOST}
 fi
 
-# Launch the main web server in the background
-log_message "Starting main web server..."
+# Start the main web server
 WEBUI_SECRET_KEY="$WEBUI_SECRET_KEY" uvicorn open_webui.main:app \
     --host "$HOST" --port "$PORT" --forwarded-allow-ips '*' &
 WEBUI_PID=$!
 
-# Configure backup schedule (set defaults if not provided)
-BACKUP_INITIAL_WAIT="${BACKUP_INITIAL_WAIT:-500}"  # 500 seconds
-BACKUP_INTERVAL="${BACKUP_INTERVAL:-21600}"        # 6 hours
+# Configure backup schedule
+BACKUP_INITIAL_WAIT="${BACKUP_INITIAL_WAIT:-500}"
+BACKUP_INTERVAL="${BACKUP_INTERVAL:-21600}"
 
-# Start the background backup job
+# Start backup scheduler
 (
-    log_message "Starting backup scheduler"
-    log_message "Initial wait: ${BACKUP_INITIAL_WAIT}s, Interval: ${BACKUP_INTERVAL}s"
-    
+    echo "Starting backup scheduler (Initial wait: ${BACKUP_INITIAL_WAIT}s, Interval: ${BACKUP_INTERVAL}s)"
     sleep "$BACKUP_INITIAL_WAIT"
 
     while true; do
-        log_message "=== Starting scheduled backup ==="
-        
-        # Run backup script with absolute path
+        echo "Running scheduled backup"
         BACKUP_THRESHOLD_MINUTES="${BACKUP_THRESHOLD_MINUTES:-120}" \
-            python "$SCRIPTS_DIR/backup.py"
+            python "$SCRIPT_DIR/scripts/backup.py"
         
-        backup_status=$?
-        if [ $backup_status -ne 0 ]; then
-            log_message "Warning: Backup failed with status $backup_status"
-        else
-            log_message "Backup completed successfully"
+        if [ $? -ne 0 ]; then
+            echo "Warning: Backup failed"
         fi
         
-        log_message "Waiting ${BACKUP_INTERVAL} seconds until next backup..."
         sleep "$BACKUP_INTERVAL"
     done
 ) &
 
-# Keep the container alive by waiting on the main web server
 wait $WEBUI_PID