Add media cache retention cleanup

README.md

@@ -51,6 +51,8 @@ With this model:
 - `GROK2API_PROXY_ASSET_URL`
 - `GROK2API_CF_CLEARANCE`
 - `GROK2API_CF_COOKIES`
+- `SERVER_STORAGE_TYPE`
+- `SERVER_STORAGE_URL`
 - `LOG_LEVEL`
 - `SERVER_WORKERS`
 - `DATA_DIR`
@@ -114,3 +116,5 @@ Without those secrets, the Space can build, but the backend protection will eith
 - The start script preserves existing `data/config.toml` keys and only overlays values supplied through environment variables.
 - `/health` stays public so Cloudflare Worker cron can warm the Space.
 - The backend API remains protected because `app.api_key` / `app.function_key` / `app.app_key` are written from secrets at startup.
+- For durable token/config storage on HF Space, prefer `SERVER_STORAGE_TYPE=pgsql` with `SERVER_STORAGE_URL`.
+- Media cache now defaults to `cache.retention_days = 7` and the app cleans expired image/video files every 24 hours.

app/services/grok/utils/cache.py

@@ -2,6 +2,7 @@
 Local cache utilities.
 """
 
+import time
 from typing import Any, Dict
 
 from app.core.storage import DATA_DIR
@@ -26,15 +27,21 @@ class CacheService:
     def _allowed_exts(self, media_type: str):
         return IMAGE_EXTS if media_type == "image" else VIDEO_EXTS
 
-    def get_stats(self, media_type: str = "image") -> Dict[str, Any]:
+    def _media_files(self, media_type: str):
         cache_dir = self._cache_dir(media_type)
         if not cache_dir.exists():
-            return {"count": 0, "size_mb": 0.0}
-
+            return []
         allowed = self._allowed_exts(media_type)
-        files = [
+        return [
             f for f in cache_dir.glob("*") if f.is_file() and f.suffix.lower() in allowed
         ]
+
+    def get_stats(self, media_type: str = "image") -> Dict[str, Any]:
+        cache_dir = self._cache_dir(media_type)
+        if not cache_dir.exists():
+            return {"count": 0, "size_mb": 0.0}
+
+        files = self._media_files(media_type)
         total_size = sum(f.stat().st_size for f in files)
         return {"count": len(files), "size_mb": round(total_size / 1024 / 1024, 2)}
 
@@ -45,10 +52,7 @@ class CacheService:
         if not cache_dir.exists():
             return {"total": 0, "page": page, "page_size": page_size, "items": []}
 
-        allowed = self._allowed_exts(media_type)
-        files = [
-            f for f in cache_dir.glob("*") if f.is_file() and f.suffix.lower() in allowed
-        ]
+        files = self._media_files(media_type)
 
         items = []
         for f in files:
@@ -106,5 +110,39 @@ class CacheService:
 
         return {"count": count, "size_mb": round(total_size / 1024 / 1024, 2)}
 
+    def cleanup_expired_files(
+        self, retention_days: int, now: float | None = None
+    ) -> Dict[str, Any]:
+        if retention_days <= 0:
+            return {"deleted": 0, "deleted_bytes": 0, "deleted_by_type": {"image": 0, "video": 0}}
+
+        current_time = now if now is not None else time.time()
+        expire_before = current_time - retention_days * 24 * 60 * 60
+        deleted = 0
+        deleted_bytes = 0
+        deleted_by_type = {"image": 0, "video": 0}
+
+        for media_type in ("image", "video"):
+            for path in self._media_files(media_type):
+                try:
+                    stat = path.stat()
+                except Exception:
+                    continue
+                if stat.st_mtime > expire_before:
+                    continue
+                try:
+                    path.unlink()
+                    deleted += 1
+                    deleted_bytes += stat.st_size
+                    deleted_by_type[media_type] += 1
+                except Exception:
+                    continue
+
+        return {
+            "deleted": deleted,
+            "deleted_bytes": deleted_bytes,
+            "deleted_by_type": deleted_by_type,
+        }
+
 
 __all__ = ["CacheService"]

app/services/grok/utils/cache_scheduler.py

@@ -0,0 +1,65 @@
+"""Background scheduler for cache retention cleanup."""
+
+import asyncio
+
+from app.core.config import get_config
+from app.core.logger import logger
+from app.services.grok.utils.cache import CacheService
+from app.services.grok.utils.locks import _file_lock
+
+_task: asyncio.Task | None = None
+
+
+async def cleanup_once() -> dict:
+    retention_days = int(get_config("cache.retention_days", 0) or 0)
+    if retention_days <= 0:
+        return {"deleted": 0, "deleted_bytes": 0, "deleted_by_type": {"image": 0, "video": 0}}
+
+    async with _file_lock("cache_cleanup", timeout=5):
+        service = CacheService()
+        result = service.cleanup_expired_files(retention_days=retention_days)
+
+    if result["deleted"] > 0:
+        logger.info(
+            "Cache retention cleanup removed "
+            f"{result['deleted']} files "
+            f"({result['deleted_bytes'] / 1024 / 1024:.2f}MB)"
+        )
+    else:
+        logger.debug("Cache retention cleanup found no expired media files")
+    return result
+
+
+async def _scheduler_loop():
+    logger.info("cache retention scheduler started")
+    while True:
+        try:
+            await cleanup_once()
+        except Exception as exc:
+            logger.warning(f"Cache retention cleanup failed: {exc}")
+
+        interval_hours = int(get_config("cache.cleanup_interval_hours", 24) or 24)
+        interval_seconds = max(1, interval_hours) * 60 * 60
+        await asyncio.sleep(interval_seconds)
+
+
+def start():
+    global _task
+    if _task is not None:
+        return
+    if int(get_config("cache.retention_days", 0) or 0) <= 0:
+        logger.info("cache retention scheduler disabled")
+        return
+    _task = asyncio.get_event_loop().create_task(_scheduler_loop())
+    logger.info("cache retention background task started")
+
+
+def stop():
+    global _task
+    if _task is not None:
+        _task.cancel()
+        _task = None
+        logger.info("cache retention background task stopped")
+
+
+__all__ = ["cleanup_once", "start", "stop"]

config.defaults.toml

@@ -97,6 +97,10 @@ reload_interval_sec = 30
 enable_auto_clean = true
 # 缓存大小上限（MB）
 limit_mb = 512
+# 媒体缓存保留天数（<=0 表示禁用按天清理）
+retention_days = 7
+# 按天清理的执行间隔（小时）
+cleanup_interval_hours = 24
 
 # ==================== 对话配置 ====================
 [chat]

deploy/hf-space/.env.example

@@ -9,6 +9,8 @@ GROK2API_PROXY_BASE_URL=
 GROK2API_PROXY_ASSET_URL=
 GROK2API_CF_CLEARANCE=
 GROK2API_CF_COOKIES=
+SERVER_STORAGE_TYPE=pgsql
+SERVER_STORAGE_URL=
 
 LOG_LEVEL=INFO
 SERVER_HOST=0.0.0.0

deploy/hf-space/README.md

@@ -51,6 +51,8 @@ With this model:
 - `GROK2API_PROXY_ASSET_URL`
 - `GROK2API_CF_CLEARANCE`
 - `GROK2API_CF_COOKIES`
+- `SERVER_STORAGE_TYPE`
+- `SERVER_STORAGE_URL`
 - `LOG_LEVEL`
 - `SERVER_WORKERS`
 - `DATA_DIR`
@@ -114,3 +116,5 @@ Without those secrets, the Space can build, but the backend protection will eith
 - The start script preserves existing `data/config.toml` keys and only overlays values supplied through environment variables.
 - `/health` stays public so Cloudflare Worker cron can warm the Space.
 - The backend API remains protected because `app.api_key` / `app.function_key` / `app.app_key` are written from secrets at startup.
+- For durable token/config storage on HF Space, prefer `SERVER_STORAGE_TYPE=pgsql` with `SERVER_STORAGE_URL`.
+- Media cache now defaults to `cache.retention_days = 7` and the app cleans expired image/video files every 24 hours.

main.py

@@ -93,6 +93,9 @@ async def lifespan(app: FastAPI):
     from app.services.cf_refresh import start as cf_refresh_start
     cf_refresh_start()
 
+    from app.services.grok.utils.cache_scheduler import start as cache_cleanup_start
+    cache_cleanup_start()
+
     logger.info("Application startup complete.")
     yield
 
@@ -102,6 +105,9 @@ async def lifespan(app: FastAPI):
     from app.services.cf_refresh import stop as cf_refresh_stop
     cf_refresh_stop()
 
+    from app.services.grok.utils.cache_scheduler import stop as cache_cleanup_stop
+    cache_cleanup_stop()
+
     from app.core.storage import StorageFactory
 
     if StorageFactory._instance: