Use local SQLite runtime with bucket snapshots

deploy/huggingface/sqlite_backup.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sqlite3
+import tempfile
+from pathlib import Path
+
+
+def _temp_path_for(destination: Path) -> Path:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    fd, temp_name = tempfile.mkstemp(prefix=destination.stem + ".", suffix=".tmp", dir=destination.parent)
+    os.close(fd)
+    return Path(temp_name)
+
+
+def backup_database(source: Path | str, destination: Path | str) -> bool:
+    source_path = Path(source)
+    destination_path = Path(destination)
+    if not source_path.exists():
+        print(f"[hf-space] backup skipped; source missing: {source_path}")
+        return False
+
+    temp_path = _temp_path_for(destination_path)
+    src_conn = None
+    dst_conn = None
+    try:
+        src_conn = sqlite3.connect(source_path)
+        dst_conn = sqlite3.connect(temp_path)
+        src_conn.backup(dst_conn)
+        dst_conn.commit()
+        dst_conn.close()
+        dst_conn = None
+        src_conn.close()
+        src_conn = None
+        os.replace(temp_path, destination_path)
+        print(f"[hf-space] backup updated: {destination_path}")
+        return True
+    finally:
+        if dst_conn is not None:
+            dst_conn.close()
+        if src_conn is not None:
+            src_conn.close()
+        if temp_path.exists():
+            temp_path.unlink(missing_ok=True)
+
+
+def restore_database(source: Path | str, destination: Path | str) -> bool:
+    source_path = Path(source)
+    destination_path = Path(destination)
+    if not source_path.exists():
+        print(f"[hf-space] restore skipped; source missing: {source_path}")
+        return False
+
+    temp_path = _temp_path_for(destination_path)
+    try:
+        shutil.copy2(source_path, temp_path)
+        os.replace(temp_path, destination_path)
+        print(f"[hf-space] restore completed: {destination_path}")
+        return True
+    finally:
+        if temp_path.exists():
+            temp_path.unlink(missing_ok=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Backup or restore a SQLite database for HF Spaces.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    for command in ("backup", "restore"):
+        command_parser = subparsers.add_parser(command)
+        command_parser.add_argument("--source", required=True)
+        command_parser.add_argument("--destination", required=True)
+
+    args = parser.parse_args()
+    if args.command == "backup":
+        backup_database(args.source, args.destination)
+    else:
+        restore_database(args.source, args.destination)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

deploy/huggingface/start.sh

@@ -2,38 +2,82 @@
 set -euo pipefail
 
 APP_ROOT="/app"
+RUNTIME_ROOT="${HF_RUNTIME_ROOT:-/tmp/codex-console}"
+PERSIST_ROOT=""
 
 effective_host="${APP_HOST:-${WEBUI_HOST:-0.0.0.0}}"
 effective_port="${APP_PORT:-${WEBUI_PORT:-${PORT:-1455}}}"
 effective_password="${APP_ACCESS_PASSWORD:-${WEBUI_ACCESS_PASSWORD:-${SPACE_PASSWORD:-}}}"
+configured_database_url="${APP_DATABASE_URL:-${DATABASE_URL:-}}"
+
+if [[ -z "${configured_database_url}" && -d "/data" ]]; then
+  PERSIST_ROOT="/data"
+fi
 
 if [[ -n "${APP_DATA_DIR:-}" ]]; then
   data_dir="${APP_DATA_DIR}"
-elif [[ -d "/data" ]]; then
-  data_dir="/data"
+elif [[ -n "${PERSIST_ROOT}" ]]; then
+  data_dir="${RUNTIME_ROOT}/data"
 else
   data_dir="${APP_ROOT}/data"
 fi
 
+if [[ -n "${APP_LOGS_DIR:-}" ]]; then
+  logs_dir="${APP_LOGS_DIR}"
+elif [[ -n "${PERSIST_ROOT}" ]]; then
+  logs_dir="${RUNTIME_ROOT}/logs"
+else
+  logs_dir="${data_dir}/logs"
+fi
+
 export APP_HOST="${effective_host}"
 export APP_PORT="${effective_port}"
 export APP_DATA_DIR="${data_dir}"
-export APP_LOGS_DIR="${APP_LOGS_DIR:-${data_dir}/logs}"
+export APP_LOGS_DIR="${logs_dir}"
 
 mkdir -p "${APP_DATA_DIR}" "${APP_LOGS_DIR}"
 
-if [[ -z "${APP_DATABASE_URL:-}" && -z "${DATABASE_URL:-}" ]]; then
-  export APP_DATABASE_URL="sqlite:///${APP_DATA_DIR}/database.db"
+local_db_path="${APP_DATA_DIR}/database.db"
+backup_pid=""
+
+if [[ -z "${configured_database_url}" ]]; then
+  export APP_DATABASE_URL="sqlite:///${local_db_path}"
 fi
 
 if [[ -n "${effective_password}" ]]; then
   export APP_ACCESS_PASSWORD="${effective_password}"
 fi
 
+if [[ -n "${PERSIST_ROOT}" ]]; then
+  persist_db_path="${PERSIST_ROOT}/database.db"
+  backup_interval="${HF_BACKUP_INTERVAL_SECONDS:-60}"
+
+  python /app/deploy/huggingface/sqlite_backup.py restore \
+    --source "${persist_db_path}" \
+    --destination "${local_db_path}" || true
+
+  backup_loop() {
+    while true; do
+      sleep "${backup_interval}"
+      python /app/deploy/huggingface/sqlite_backup.py backup \
+        --source "${local_db_path}" \
+        --destination "${persist_db_path}" || true
+    done
+  }
+
+  backup_loop &
+  backup_pid="$!"
+fi
+
 echo "[hf-space] starting codex-console"
 echo "[hf-space] listen: ${APP_HOST}:${APP_PORT}"
 echo "[hf-space] data dir: ${APP_DATA_DIR}"
 echo "[hf-space] logs dir: ${APP_LOGS_DIR}"
+if [[ -n "${PERSIST_ROOT}" ]]; then
+  echo "[hf-space] persistence: sqlite runtime at ${local_db_path}, bucket snapshot at ${persist_db_path}"
+else
+  echo "[hf-space] persistence: direct filesystem"
+fi
 if [[ -n "${APP_ACCESS_PASSWORD:-}" ]]; then
   echo "[hf-space] access password: configured"
 else
@@ -45,4 +89,19 @@ if [[ -n "${APP_ACCESS_PASSWORD:-}" ]]; then
   cmd+=(--access-password "${APP_ACCESS_PASSWORD}")
 fi
 
-exec "${cmd[@]}"
+"${cmd[@]}" &
+app_pid="$!"
+set +e
+wait "${app_pid}"
+app_status="$?"
+set -e
+
+if [[ -n "${backup_pid}" ]]; then
+  python /app/deploy/huggingface/sqlite_backup.py backup \
+    --source "${local_db_path}" \
+    --destination "${persist_db_path}" || true
+  kill "${backup_pid}" 2>/dev/null || true
+  wait "${backup_pid}" 2>/dev/null || true
+fi
+
+exit "${app_status}"