dsh-plugin-image-workbench 0.0.0-stage → 1.1.5

package/vendor/chatgpt2api/source/services/editable_file_task_service.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import json
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from services.account_service import account_service
+from services.config import DATA_DIR
+from services.content_filter import request_text
+from services.log_service import LOG_TYPE_CALL, log_service
+from services.openai_backend_api import EDITABLE_FILE_MODEL, OpenAIBackendAPI
+from utils.helper import new_uuid
+
+TASK_STATUS_QUEUED = "queued"
+TASK_STATUS_RUNNING = "running"
+TASK_STATUS_SUCCESS = "success"
+TASK_STATUS_ERROR = "error"
+UNFINISHED_STATUSES = {TASK_STATUS_QUEUED, TASK_STATUS_RUNNING}
+EDITABLE_FILE_PLAN_TYPES = ("Plus", "Team", "Pro", "Enterprise")
+EDITABLE_FILE_ROOT = DATA_DIR / "files"
+EDITABLE_FILE_TASKS_PATH = DATA_DIR / "editable_file_tasks.json"
+
+
+def _now_iso() -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _clean(value: object, default: str = "") -> str:
+    return str(value or default).strip()
+
+
+def _owner_id(identity: dict[str, object]) -> str:
+    return _clean(identity.get("id")) or "anonymous"
+
+
+def _task_key(owner_id: str, task_id: str) -> str:
+    return f"{owner_id}:{task_id}"
+
+
+def _elapsed_seconds(task: dict[str, Any]) -> int:
+    start = float(task.get("started_ts") or task.get("created_ts") or 0)
+    end = float(task.get("ended_ts") or time.time())
+    return max(0, int(end - start)) if start else 0
+
+
+def _file_url(path: Path, base_url: str) -> str:
+    rel = path.resolve().relative_to(EDITABLE_FILE_ROOT.resolve()).as_posix()
+    prefix = str(base_url or "").strip().rstrip("/")
+    return f"{prefix}/files/{quote(rel, safe='/')}" if prefix else f"/files/{quote(rel, safe='/')}"
+
+
+def _editable_access_token() -> str:
+    accounts = [
+        item for item in account_service.list_accounts()
+        if _clean(item.get("access_token"))
+           and item.get("status") not in {"禁用", "异常"}
+           and account_service._account_matches_any_plan_type(item, EDITABLE_FILE_PLAN_TYPES)
+    ]
+    if not accounts:
+        raise RuntimeError("no available plus/team/pro account")
+    accounts.sort(key=lambda item: _clean(item.get("last_used_at")))
+    token = _clean(accounts[0].get("access_token"))
+    return account_service.refresh_access_token(token, event="editable_file_task") or token
+
+
+def _public_task(task: dict[str, Any]) -> dict[str, Any]:
+    item = {
+        "id": task.get("id"),
+        "taskId": task.get("id"),
+        "status": task.get("status"),
+        "kind": task.get("kind"),
+        "created_at": task.get("created_at"),
+        "updated_at": task.get("updated_at"),
+        "elapsed_seconds": _elapsed_seconds(task),
+    }
+    for key in ("result", "error"):
+        if task.get(key):
+            item[key] = task[key]
+    return item
+
+
+class EditableFileTaskService:
+    def __init__(self, path: Path = EDITABLE_FILE_TASKS_PATH) -> None:
+        self.path = path
+        self._lock = threading.RLock()
+        self._tasks: dict[str, dict[str, Any]] = {}
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self._lock:
+            self._tasks = self._load_locked()
+            if self._recover_unfinished_locked():
+                self._save_locked()
+
+    def submit_ppt(self, identity: dict[str, object], *, client_task_id: str = "", prompt: str = "", base64_images: list[str] | None = None, base_url: str = "") -> dict[str, Any]:
+        return self._submit(identity, client_task_id=client_task_id, kind="ppt", prompt=prompt, base64_images=base64_images or [], base_url=base_url)
+
+    def submit_psd(self, identity: dict[str, object], *, client_task_id: str = "", prompt: str = "", base64_images: list[str] | None = None, base_url: str = "") -> dict[str, Any]:
+        return self._submit(identity, client_task_id=client_task_id, kind="psd", prompt=prompt, base64_images=base64_images or [], base_url=base_url)
+
+    def list_tasks(self, identity: dict[str, object], task_ids: list[str]) -> dict[str, Any]:
+        owner = _owner_id(identity)
+        requested = [_clean(item) for item in task_ids if _clean(item)]
+        with self._lock:
+            if requested:
+                items = [task for task_id in requested if (task := self._tasks.get(_task_key(owner, task_id)))]
+                return {"items": [_public_task(item) for item in items], "missing_ids": [task_id for task_id in requested if _task_key(owner, task_id) not in self._tasks]}
+            items = [task for task in self._tasks.values() if task.get("owner_id") == owner]
+        items.sort(key=lambda item: str(item.get("updated_at") or ""), reverse=True)
+        return {"items": [_public_task(item) for item in items], "missing_ids": []}
+
+    def _submit(self, identity: dict[str, object], *, client_task_id: str, kind: str, prompt: str, base64_images: list[str], base_url: str) -> dict[str, Any]:
+        task_id = _clean(client_task_id) or new_uuid()
+        owner = _owner_id(identity)
+        key = _task_key(owner, task_id)
+        now = _now_iso()
+        with self._lock:
+            if key in self._tasks:
+                return _public_task(self._tasks[key])
+            ts = time.time()
+            self._tasks[key] = {"id": task_id, "owner_id": owner, "status": TASK_STATUS_QUEUED, "kind": kind, "model": EDITABLE_FILE_MODEL, "created_at": now, "updated_at": now, "created_ts": ts, "updated_ts": ts}
+            task = dict(self._tasks[key])
+            self._save_locked()
+        threading.Thread(target=self._run_task, args=(key, kind, prompt, base64_images, dict(identity), base_url), name=f"{kind}-file-task-{task_id[:16]}", daemon=True).start()
+        return _public_task(task)
+
+    def _run_task(self, key: str, kind: str, prompt: str, base64_images: list[str], identity: dict[str, object], base_url: str) -> None:
+        started = time.time()
+        token = ""
+        account_email = ""
+        self._update_task(key, status=TASK_STATUS_RUNNING, error="", started_ts=started)
+        backend = None
+        try:
+            if kind == "psd" and not base64_images:
+                raise ValueError("base64_images is empty")
+            token = _editable_access_token()
+            account = account_service.get_account(token) or {}
+            account_email = _clean(account.get("email"))
+            backend = OpenAIBackendAPI(token)
+            output_dir = EDITABLE_FILE_ROOT / kind / key.rsplit(":", 1)[-1]
+            result = backend.export_psd_zip(base64_images, prompt, output_dir) if kind == "psd" else backend.export_ppt_zip(base64_images, prompt, output_dir)
+            account_service.mark_text_used(token)
+            data = {"conversation_id": result.conversation_id, "primary_url": _file_url(result.primary_path, base_url), "zip_url": _file_url(result.zip_path, base_url)}
+            self._update_task(key, status=TASK_STATUS_SUCCESS, result=data, account_email=account_email, error="", ended_ts=time.time())
+            self._log_call(identity, kind, started, request_text(prompt), account_email=account_email, result=data)
+        except Exception as exc:
+            error = str(exc) or "editable file task failed"
+            self._update_task(key, status=TASK_STATUS_ERROR, error=error, account_email=account_email, ended_ts=time.time())
+            self._log_call(identity, kind, started, request_text(prompt), status="failed", error=error, account_email=account_email)
+        finally:
+            if backend is not None:
+                backend.close()
+
+    def public_file_path(self, relative_path: str) -> Path:
+        raw = str(relative_path or "").replace("\\", "/").lstrip("/")
+        path = (EDITABLE_FILE_ROOT / raw).resolve()
+        path.relative_to(EDITABLE_FILE_ROOT.resolve())
+        if not path.is_file():
+            raise FileNotFoundError(raw)
+        return path
+
+    def _update_task(self, key: str, **updates: Any) -> None:
+        with self._lock:
+            task = self._tasks.get(key)
+            if task is None:
+                return
+            task.update(updates)
+            task["updated_at"] = _now_iso()
+            task["updated_ts"] = time.time()
+            self._save_locked()
+
+    def _load_locked(self) -> dict[str, dict[str, Any]]:
+        if not self.path.exists():
+            return {}
+        try:
+            raw = json.loads(self.path.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+        tasks: dict[str, dict[str, Any]] = {}
+        for item in (raw.get("tasks") if isinstance(raw, dict) else raw) or []:
+            if not isinstance(item, dict):
+                continue
+            task_id = _clean(item.get("id"))
+            owner = _clean(item.get("owner_id"))
+            if not task_id or not owner:
+                continue
+            task = {
+                "id": task_id,
+                "owner_id": owner,
+                "status": _clean(item.get("status"), TASK_STATUS_ERROR),
+                "kind": "psd" if item.get("kind") == "psd" else "ppt",
+                "created_at": _clean(item.get("created_at"), _now_iso()),
+                "updated_at": _clean(item.get("updated_at"), _clean(item.get("created_at"), _now_iso())),
+                "created_ts": float(item.get("created_ts") or 0),
+                "updated_ts": float(item.get("updated_ts") or 0),
+            }
+            for field in ("result", "error", "started_ts", "ended_ts"):
+                if item.get(field):
+                    task[field] = item[field]
+            tasks[_task_key(owner, task_id)] = task
+        return tasks
+
+    def _save_locked(self) -> None:
+        items = sorted(self._tasks.values(), key=lambda item: str(item.get("updated_at") or ""), reverse=True)
+        tmp_path = self.path.with_suffix(self.path.suffix + ".tmp")
+        tmp_path.write_text(json.dumps({"tasks": items}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        tmp_path.replace(self.path)
+
+    def _recover_unfinished_locked(self) -> bool:
+        changed = False
+        for task in self._tasks.values():
+            if task.get("status") in UNFINISHED_STATUSES:
+                task["status"] = TASK_STATUS_ERROR
+                task["error"] = "服务已重启，未完成的任务已中断"
+                task["ended_ts"] = time.time()
+                task["updated_at"] = _now_iso()
+                task["updated_ts"] = time.time()
+                changed = True
+        return changed
+
+    def _log_call(
+            self,
+            identity: dict[str, object],
+            kind: str,
+            started: float,
+            request_preview: str,
+            *,
+            status: str = "success",
+            error: str = "",
+            account_email: str = "",
+            result: dict[str, str] | None = None,
+    ) -> None:
+        detail = {
+            "key_id": identity.get("id"),
+            "key_name": identity.get("name"),
+            "role": identity.get("role"),
+            "endpoint": f"/v1/{kind}/generations",
+            "model": EDITABLE_FILE_MODEL,
+            "started_at": datetime.fromtimestamp(started).strftime("%Y-%m-%d %H:%M:%S"),
+            "ended_at": _now_iso(),
+            "duration_ms": int((time.time() - started) * 1000),
+            "status": status,
+        }
+        if request_preview:
+            detail["request_text"] = request_preview
+        if account_email:
+            detail["account_email"] = account_email
+        if error:
+            detail["error"] = error
+        if result:
+            detail["result"] = result
+        try:
+            log_service.add(LOG_TYPE_CALL, f"{kind.upper()}生成任务{'失败' if status == 'failed' else '完成'}", detail)
+        except Exception:
+            pass
+
+
+editable_file_task_service = EditableFileTaskService()

package/vendor/chatgpt2api/source/services/image_service.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+
+import io
+import shutil
+import threading
+import time
+import zipfile
+from pathlib import Path
+
+from fastapi import HTTPException
+from fastapi.responses import FileResponse, Response
+from PIL import Image, ImageOps
+
+from services.config import config
+from services.image_storage_service import image_storage_service
+from services.image_tags_service import load_tags, remove_tags
+from utils.log import logger
+
+THUMBNAIL_SIZE = (320, 320)
+
+
+def _cleanup_empty_dirs(root: Path) -> None:
+    for path in sorted((p for p in root.rglob("*") if p.is_dir()), key=lambda p: len(p.parts), reverse=True):
+        try:
+            path.rmdir()
+        except OSError:
+            pass
+
+
+def _safe_relative_path(path: str) -> str:
+    value = str(path or "").strip().replace("\\", "/").lstrip("/")
+    if not value:
+        raise HTTPException(status_code=404, detail="image not found")
+    parts = Path(value).parts
+    if any(part in {"", ".", ".."} for part in parts):
+        raise HTTPException(status_code=404, detail="image not found")
+    return Path(*parts).as_posix()
+
+
+def _safe_image_path(relative_path: str) -> Path:
+    rel = _safe_relative_path(relative_path)
+    root = config.images_dir.resolve()
+    path = (root / rel).resolve()
+    try:
+        path.relative_to(root)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail="image not found") from exc
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail="image not found")
+    return path
+
+
+def get_image_response(relative_path: str) -> FileResponse | Response:
+    headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+    }
+    if image_storage_service.has_local(relative_path):
+        return FileResponse(_safe_image_path(relative_path), headers=headers)
+    return Response(content=image_storage_service.get_bytes(relative_path), media_type="image/png", headers=headers)
+
+
+def _thumbnail_path(relative_path: str) -> Path:
+    rel = _safe_relative_path(relative_path)
+    return config.image_thumbnails_dir / f"{rel}.png"
+
+
+def thumbnail_url(base_url: str, relative_path: str) -> str:
+    return f"{base_url.rstrip('/')}/image-thumbnails/{_safe_relative_path(relative_path)}"
+
+
+def _image_dimensions(path: Path) -> tuple[int, int] | None:
+    try:
+        with Image.open(path) as image:
+            return image.size
+    except Exception:
+        return None
+
+
+def ensure_thumbnail(relative_path: str) -> Path:
+    target = _thumbnail_path(relative_path)
+    source_mtime = 0.0
+    source: Path | None = None
+    if image_storage_service.has_local(relative_path):
+        source = _safe_image_path(relative_path)
+        source_mtime = source.stat().st_mtime
+    if target.exists() and (not source_mtime or target.stat().st_mtime >= source_mtime):
+        return target
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        image_source = source if source is not None else io.BytesIO(image_storage_service.get_bytes(relative_path))
+        with Image.open(image_source) as image:
+            image = ImageOps.exif_transpose(image)
+            if image.mode not in {"RGB", "RGBA"}:
+                image = image.convert("RGBA" if "A" in image.getbands() else "RGB")
+            image.thumbnail(THUMBNAIL_SIZE, Image.Resampling.LANCZOS)
+            image.save(target, format="PNG", optimize=True)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=422, detail="failed to create thumbnail") from exc
+    return target
+
+
+def get_thumbnail_response(relative_path: str) -> FileResponse:
+    headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+    }
+    return FileResponse(ensure_thumbnail(relative_path), headers=headers)
+
+
+def get_image_download_response(relative_path: str) -> FileResponse:
+    cors_headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+    }
+    if image_storage_service.has_local(relative_path):
+        path = _safe_image_path(relative_path)
+        headers = {**cors_headers, "Content-Disposition": f'attachment; filename="{path.name}"'}
+        return FileResponse(path, filename=path.name, headers=headers)
+    rel = _safe_relative_path(relative_path)
+    headers = {
+        **cors_headers,
+        "Content-Disposition": f'attachment; filename="{Path(rel).name}"',
+    }
+    return Response(
+        content=image_storage_service.get_bytes(rel),
+        media_type="image/png",
+        headers=headers,
+    )
+
+
+def cleanup_image_thumbnails() -> int:
+    thumbnails_root = config.image_thumbnails_dir
+    removed = 0
+    for path in thumbnails_root.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(thumbnails_root).as_posix()
+        if not rel.endswith(".png") or not image_storage_service.exists(rel[:-4]):
+            path.unlink()
+            removed += 1
+    _cleanup_empty_dirs(thumbnails_root)
+    return removed
+
+def list_images(base_url: str, start_date: str = "", end_date: str = "") -> dict[str, object]:
+    config.cleanup_old_images()
+    cleanup_image_thumbnails()
+    all_tags = load_tags()
+    items = [
+        {
+            **item,
+            "url": str(item.get("url") or f"{base_url.rstrip('/')}/images/{item['path']}"),
+            "thumbnail_url": thumbnail_url(base_url, str(item["path"])),
+            "tags": all_tags.get(str(item["path"]), []),
+        }
+        for item in image_storage_service.list_items(base_url, start_date, end_date)
+    ]
+    groups: dict[str, list[dict[str, object]]] = {}
+    for item in items:
+        groups.setdefault(str(item["date"]), []).append(item)
+    return {"items": items, "groups": [{"date": key, "items": value} for key, value in groups.items()]}
+
+
+def delete_images(paths: list[str] | None = None, start_date: str = "", end_date: str = "", all_matching: bool = False) -> dict[str, int]:
+    root = config.images_dir.resolve()
+    targets = [
+        str(item["path"])
+        for item in image_storage_service.list_items("", start_date=start_date, end_date=end_date)
+    ] if all_matching else (paths or [])
+    removed = 0
+    for item in targets:
+        path = (root / item).resolve()
+        try:
+            path.relative_to(root)
+        except ValueError:
+            continue
+        if image_storage_service.delete(item):
+            removed += 1
+        for thumbnail in (_thumbnail_path(item), config.image_thumbnails_dir / _safe_relative_path(item)):
+            if thumbnail.is_file():
+                thumbnail.unlink()
+        remove_tags(item)
+    _cleanup_empty_dirs(root)
+    _cleanup_empty_dirs(config.image_thumbnails_dir)
+    return {"removed": removed}
+
+
+def download_images_zip(paths: list[str]) -> io.BytesIO:
+    root = config.images_dir.resolve()
+    buf = io.BytesIO()
+    added = 0
+    used_names: set[str] = set()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for item in paths:
+            rel = _safe_relative_path(item)
+            path = (root / rel).resolve()
+            payload: bytes | None = None
+            try:
+                path.relative_to(root)
+            except ValueError:
+                continue
+            if path.is_file():
+                payload = path.read_bytes()
+            else:
+                try:
+                    payload = image_storage_service.get_bytes(rel)
+                except Exception:
+                    continue
+            name = path.name
+            if name in used_names:
+                stem = path.stem
+                suffix = path.suffix
+                counter = 2
+                while f"{stem}_{counter}{suffix}" in used_names:
+                    counter += 1
+                name = f"{stem}_{counter}{suffix}"
+            used_names.add(name)
+            zf.writestr(name, payload)
+            added += 1
+    if added == 0:
+        raise HTTPException(status_code=404, detail="no images found")
+    buf.seek(0)
+    return buf
+def storage_stats() -> dict:
+    import shutil
+    usage = shutil.disk_usage(config.images_dir)
+    total_mb = usage.total // (1024 * 1024)
+    used_mb = usage.used // (1024 * 1024)
+    free_mb = usage.free // (1024 * 1024)
+
+    image_count = 0
+    image_size = 0
+    for p in config.images_dir.rglob("*"):
+        if p.is_file():
+            image_count += 1
+            image_size += p.stat().st_size
+
+    return {
+        "disk_total_mb": total_mb,
+        "disk_used_mb": used_mb,
+        "disk_free_mb": free_mb,
+        "image_count": image_count,
+        "image_size_mb": image_size // (1024 * 1024),
+        "image_size_bytes": image_size,
+    }
+
+
+def compress_images(quality: int = 60) -> dict:
+    """重新压缩所有图片，返回节省的空间"""
+    saved = 0
+    count = 0
+    for p in sorted(config.images_dir.rglob("*.png")):
+        if not p.is_file():
+            continue
+        try:
+            orig = p.stat().st_size
+            with Image.open(p) as img:
+                img = ImageOps.exif_transpose(img)
+                img.save(str(p) + ".tmp", format="PNG", optimize=True)
+            new_size = Path(str(p) + ".tmp").stat().st_size
+            if new_size < orig:
+                Path(str(p) + ".tmp").replace(p)
+                saved += orig - new_size
+                count += 1
+            else:
+                Path(str(p) + ".tmp").unlink()
+        except Exception:
+            pass
+    return {"compressed": count, "saved_bytes": saved, "saved_mb": saved // (1024 * 1024)}
+
+
+def delete_to_target(target_free_mb: int, dry_run: bool = False) -> dict:
+    """删除最旧的图片直到剩余空间达到 target_free_mb"""
+    import shutil
+    usage = shutil.disk_usage(config.images_dir)
+    current_free = usage.free // (1024 * 1024)
+    if current_free >= target_free_mb and not dry_run:
+        return {"removed": 0, "current_free_mb": current_free, "target_free_mb": target_free_mb, "done": True}
+
+    files = sorted(
+        (p for p in config.images_dir.rglob("*.png") if p.is_file()),
+        key=lambda p: p.stat().st_mtime,
+    )
+    removed = 0
+    freed = 0
+    for p in files:
+        if current_free + freed // (1024 * 1024) >= target_free_mb:
+            break
+        size = p.stat().st_size
+        if not dry_run:
+            rel = p.relative_to(config.images_dir).as_posix()
+            for tp in (_thumbnail_path(rel), config.image_thumbnails_dir / _safe_relative_path(rel)):
+                if tp.is_file():
+                    tp.unlink()
+            remove_tags(rel)
+            p.unlink()
+        freed += size
+        removed += 1
+
+    if not dry_run:
+        _cleanup_empty_dirs(config.images_dir)
+        _cleanup_empty_dirs(config.image_thumbnails_dir)
+
+    return {
+        "removed": removed,
+        "freed_mb": freed // (1024 * 1024),
+        "target_free_mb": target_free_mb,
+        "current_free_mb": current_free + (freed // (1024 * 1024)),
+        "done": (current_free + freed // (1024 * 1024)) >= target_free_mb,
+        "dry_run": dry_run,
+    }
+
+
+def download_images_zip(paths: list[str]) -> io.BytesIO:
+    root = config.images_dir.resolve()
+    buf = io.BytesIO()
+    added = 0
+    used_names: set[str] = set()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for item in paths:
+            rel = _safe_relative_path(item)
+            path = (root / rel).resolve()
+            try:
+                path.relative_to(root)
+            except ValueError:
+                continue
+            if not path.is_file():
+                continue
+            name = path.name
+            if name in used_names:
+                stem = path.stem
+                suffix = path.suffix
+                counter = 2
+                while f"{stem}_{counter}{suffix}" in used_names:
+                    counter += 1
+                name = f"{stem}_{counter}{suffix}"
+            used_names.add(name)
+            zf.write(path, name)
+            added += 1
+    if added == 0:
+        raise HTTPException(status_code=404, detail="no images found")
+    buf.seek(0)
+    return buf
+
+
+def _auto_cleanup_worker(stop_event: threading.Event) -> None:
+    """后台线程：每30分钟检查存储，空间低于阈值自动清理最旧图片"""
+    import shutil
+    min_free_mb = getattr(config, "image_min_free_mb", None)
+    if min_free_mb is None:
+        min_free_mb = 500
+
+    while not stop_event.wait(1800):  # 每30分钟
+        try:
+            config.cleanup_old_images()
+            cleanup_image_thumbnails()
+            usage = shutil.disk_usage(config.images_dir)
+            free_mb = usage.free // (1024 * 1024)
+            if free_mb < min_free_mb:
+                logger.info({"event": "image_auto_cleanup", "free_mb": free_mb, "min_free_mb": min_free_mb})
+                result = delete_to_target(min_free_mb)
+                logger.info({"event": "image_auto_cleanup_done", **result})
+        except Exception:
+            pass
+
+
+def start_image_cleanup_scheduler(stop_event: threading.Event) -> threading.Thread:
+    t = threading.Thread(target=_auto_cleanup_worker, args=(stop_event,), daemon=True, name="image-cleanup")
+    t.start()
+    return t