feat(model-modal): improve transition animations and fix navigation logic

- Add `!important` to overlay background and closing opacity for consistent styling
- Remove navigation spam prevention to allow consecutive transitions
- Implement in-place content updates during model transitions instead of reopening modal
- Add opacity transitions for showcase and metadata components
- Fetch complete Civitai metadata during transitions for updated model data

.agents/skills/lora-manager-runtime-context/SKILL.md

@@ -1,69 +0,0 @@
----
-name: lora-manager-runtime-context
-description: Inspect ComfyUI LoRA Manager runtime configuration and local diagnostic state. Use when debugging LoRA Manager issues that require locating or reading settings.json, active library paths, model metadata JSON sidecars, recipe metadata JSON files, example image folders, SQLite caches, symlink maps, download history, aria2 state, or other cache files under the LoRA Manager user config directory.
----
-
-# LoRA Manager Runtime Context
-
-## Core Rules
-
-- Treat runtime state as local user data. Prefer read-only inspection unless the user explicitly asks for mutation.
-- Never print secret-like settings values. Redact keys containing `key`, `token`, `secret`, `password`, `auth`, or `credential`, including `civitai_api_key`.
-- Resolve paths from the runtime configuration before guessing. In this environment the settings file is normally `/home/miao/.config/ComfyUI-LoRA-Manager/settings.json`, but portable settings can override this through the repository `settings.json`.
-- Use the active library when selecting per-library caches and paths. Read `active_library` from settings; fall back to `default` if missing.
-- Normalize and expand `~` before comparing paths. Symlinks are common in this repo.
-
-## Quick Start
-
-Use the bundled helper for a safe first pass:
-
-```bash
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py summary
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py caches
-```
-
-The script redacts sensitive settings, opens SQLite databases read-only, and reports inaccessible or locked databases as warnings.
-
-For focused checks:
-
-```bash
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py recipes
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py model --path /path/to/model.safetensors
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py sqlite --db /path/to/cache.sqlite --limit 3
-```
-
-## Runtime Path Rules
-
-- Settings directory: use `py/utils/settings_paths.py`. Default platform path is `platformdirs.user_config_dir("ComfyUI-LoRA-Manager", appauthor=False)`.
-- Settings file: `<settings_dir>/settings.json`.
-- Cache root: `<settings_dir>/cache`.
-- Canonical cache files:
-  - Model cache: `cache/model/<active_library>.sqlite`.
-  - Recipe cache: `cache/recipe/<active_library>.sqlite`.
-  - Model update cache: `cache/model_update/<active_library>.sqlite`.
-  - Recipe FTS: `cache/fts/recipe_fts.sqlite`.
-  - Tag FTS: `cache/fts/tag_fts.sqlite`.
-  - Symlink map: `cache/symlink/symlink_map.json`.
-  - Download history: `cache/download_history/downloaded_versions.sqlite`.
-  - aria2 state: `cache/aria2/downloads.json`.
-- Legacy cache locations may exist; prefer canonical paths unless diagnosing migrations.
-
-## Data Location Rules
-
-- Model roots come from `settings.folder_paths` and the active library payload under `settings.libraries[active_library]`.
-- Model metadata JSON sidecars live next to the model file as `<model basename>.metadata.json`.
-- Recipes root is `settings.recipes_path` when it is a non-empty string. If empty, use the first configured LoRA root plus `/recipes`.
-- Recipe JSON files are named `*.recipe.json` under the recipes root and may be nested in folders.
-- Example image root is `settings.example_images_path`.
-- If multiple libraries are configured, example images are stored under `<example_images_path>/<sanitized_library>/<sha256>/`; otherwise they are under `<example_images_path>/<sha256>/`.
-
-## Useful Cache Tables
-
-- Model cache: `models`, `model_tags`, `hash_index`, `excluded_models`.
-- Recipe cache: `recipes`, `cache_metadata`.
-- Model update cache: `model_update_status`, `model_update_versions`.
-- Tag FTS cache: `tags`, `fts_metadata`, plus FTS internal tables.
-- Recipe FTS cache: `recipe_rowid`, `fts_metadata`, plus FTS internal tables.
-- Download history: `downloaded_model_versions`.
-
-Prefer querying only counts, schema, and a few sample rows unless the user asks for full output.

.agents/skills/lora-manager-runtime-context/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "LoRA Manager Runtime Context"
-  short_description: "Inspect LoRA Manager runtime state"
-  default_prompt: "Use $lora-manager-runtime-context to inspect LoRA Manager settings, metadata paths, and caches for debugging."

.agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py

@@ -1,381 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import re
-import shutil
-import sqlite3
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any
-
-SECRET_PATTERN = re.compile(r"(key|token|secret|password|auth|credential)", re.IGNORECASE)
-APP_NAME = "ComfyUI-LoRA-Manager"
-CACHE_SQLITE = {
-    "model": ("model", "{library}.sqlite"),
-    "recipe": ("recipe", "{library}.sqlite"),
-    "model_update": ("model_update", "{library}.sqlite"),
-    "recipe_fts": ("fts", "recipe_fts.sqlite"),
-    "tag_fts": ("fts", "tag_fts.sqlite"),
-    "download_history": ("download_history", "downloaded_versions.sqlite"),
-}
-CACHE_JSON = {
-    "symlink": ("symlink", "symlink_map.json"),
-    "aria2": ("aria2", "downloads.json"),
-}
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Inspect LoRA Manager runtime state read-only.")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    subparsers.add_parser("summary", help="Print redacted settings and resolved paths.")
-    subparsers.add_parser("caches", help="Print cache paths and SQLite table summaries.")
-    subparsers.add_parser("recipes", help="Print resolved recipes root and recipe JSON count.")
-
-    model_parser = subparsers.add_parser("model", help="Inspect a model metadata sidecar path.")
-    model_parser.add_argument("--path", required=True, help="Path to a model file or metadata JSON file.")
-
-    sqlite_parser = subparsers.add_parser("sqlite", help="Inspect a SQLite database read-only.")
-    sqlite_parser.add_argument("--db", required=True, help="Path to the SQLite database.")
-    sqlite_parser.add_argument("--limit", type=int, default=3, help="Rows to sample from each user table.")
-
-    args = parser.parse_args()
-    context = build_context()
-
-    if args.command == "summary":
-        print_json(summary_payload(context))
-    elif args.command == "caches":
-        print_json(caches_payload(context))
-    elif args.command == "recipes":
-        print_json(recipes_payload(context))
-    elif args.command == "model":
-        print_json(model_payload(args.path))
-    elif args.command == "sqlite":
-        print_json(sqlite_payload(Path(args.db).expanduser(), args.limit))
-    return 0
-
-
-def build_context() -> dict[str, Any]:
-    settings_path = resolve_settings_path()
-    settings = load_json(settings_path)
-    settings_dir = settings_path.parent
-    active_library = settings.get("active_library") or "default"
-    safe_library = sanitize_library_name(str(active_library))
-    cache_root = settings_dir / "cache"
-    return {
-        "settings_path": str(settings_path),
-        "settings_dir": str(settings_dir),
-        "settings": settings,
-        "active_library": active_library,
-        "safe_library": safe_library,
-        "cache_root": str(cache_root),
-        "cache_paths": resolve_cache_paths(cache_root, safe_library),
-    }
-
-
-def resolve_settings_path() -> Path:
-    repo_root = find_repo_root()
-    portable = repo_root / "settings.json"
-    if portable.exists():
-        payload = load_json(portable)
-        if isinstance(payload, dict) and payload.get("use_portable_settings") is True:
-            return portable
-
-    config_home = os.environ.get("XDG_CONFIG_HOME")
-    if config_home:
-        return Path(config_home).expanduser() / APP_NAME / "settings.json"
-    return Path.home() / ".config" / APP_NAME / "settings.json"
-
-
-def find_repo_root() -> Path:
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        if (parent / "py").is_dir() and (parent / "standalone.py").exists():
-            return parent
-    return Path.cwd()
-
-
-def load_json(path: Path) -> dict[str, Any]:
-    try:
-        with path.open("r", encoding="utf-8") as handle:
-            payload = json.load(handle)
-    except FileNotFoundError:
-        return {}
-    except json.JSONDecodeError as exc:
-        return {"_error": f"invalid JSON: {exc}"}
-    except OSError as exc:
-        return {"_error": f"unreadable: {exc}"}
-    return payload if isinstance(payload, dict) else {"_error": "JSON root is not an object"}
-
-
-def resolve_cache_paths(cache_root: Path, library: str) -> dict[str, str]:
-    paths: dict[str, str] = {}
-    for name, (subdir, filename) in CACHE_SQLITE.items():
-        paths[name] = str(cache_root / subdir / filename.format(library=library))
-    for name, (subdir, filename) in CACHE_JSON.items():
-        paths[name] = str(cache_root / subdir / filename)
-    return paths
-
-
-def summary_payload(context: dict[str, Any]) -> dict[str, Any]:
-    settings = context["settings"]
-    return {
-        "settings_path": context["settings_path"],
-        "settings_dir": context["settings_dir"],
-        "active_library": context["active_library"],
-        "settings": redact(settings),
-        "model_roots": model_roots(settings, context["active_library"]),
-        "recipes_root": str(resolve_recipes_root(settings, context["active_library"]) or ""),
-        "example_images": example_images_payload(settings, context["active_library"]),
-        "cache_root": context["cache_root"],
-        "cache_paths": context["cache_paths"],
-    }
-
-
-def caches_payload(context: dict[str, Any]) -> dict[str, Any]:
-    caches: dict[str, Any] = {}
-    for name, path_string in context["cache_paths"].items():
-        path = Path(path_string)
-        item: dict[str, Any] = {
-            "path": str(path),
-            "exists": path.exists(),
-            "size": path.stat().st_size if path.exists() else None,
-        }
-        if path.suffix == ".sqlite":
-            item["sqlite"] = sqlite_payload(path, limit=0)
-        elif path.suffix == ".json":
-            item["json"] = json_file_summary(path)
-        caches[name] = item
-    return {"active_library": context["active_library"], "caches": caches}
-
-
-def recipes_payload(context: dict[str, Any]) -> dict[str, Any]:
-    root = resolve_recipes_root(context["settings"], context["active_library"])
-    files: list[str] = []
-    if root and root.exists():
-        files = [str(path) for path in sorted(root.rglob("*.recipe.json"))[:20]]
-    return {
-        "recipes_root": str(root or ""),
-        "exists": bool(root and root.exists()),
-        "recipe_json_count": count_recipe_files(root),
-        "sample_recipe_json": files,
-        "recipe_cache": context["cache_paths"].get("recipe"),
-    }
-
-
-def model_payload(raw_path: str) -> dict[str, Any]:
-    path = Path(raw_path).expanduser()
-    metadata_path = path if path.name.endswith(".metadata.json") else path.with_suffix(".metadata.json")
-    payload = {
-        "input_path": str(path),
-        "metadata_path": str(metadata_path),
-        "model_exists": path.exists(),
-        "metadata_exists": metadata_path.exists(),
-    }
-    if metadata_path.exists():
-        data = load_json(metadata_path)
-        payload["metadata_summary"] = redact(summarize_value(data))
-    return payload
-
-
-def sqlite_payload(path: Path, limit: int = 3, allow_copy: bool = True) -> dict[str, Any]:
-    result: dict[str, Any] = {"path": str(path), "exists": path.exists(), "tables": {}}
-    if not path.exists():
-        return result
-    try:
-        conn = connect_sqlite_readonly(path)
-    except sqlite3.Error as exc:
-        result["error"] = str(exc)
-        return result
-    try:
-        table_rows = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-        ).fetchall()
-        for table_row in table_rows:
-            table = table_row["name"]
-            columns = [
-                row["name"]
-                for row in conn.execute(f"PRAGMA table_info({quote_identifier(table)})").fetchall()
-            ]
-            table_info: dict[str, Any] = {"columns": columns}
-            try:
-                table_info["count"] = conn.execute(
-                    f"SELECT COUNT(*) FROM {quote_identifier(table)}"
-                ).fetchone()[0]
-            except sqlite3.Error as exc:
-                table_info["count_error"] = str(exc)
-            if limit > 0 and columns and not is_internal_sqlite_table(table):
-                try:
-                    rows = conn.execute(
-                        f"SELECT * FROM {quote_identifier(table)} LIMIT ?", (limit,)
-                    ).fetchall()
-                    table_info["sample"] = [redact(dict(row)) for row in rows]
-                except sqlite3.Error as exc:
-                    table_info["sample_error"] = str(exc)
-            result["tables"][table] = table_info
-    except sqlite3.Error as exc:
-        fallback = sqlite_copy_payload(path, limit, str(exc)) if allow_copy else None
-        if fallback is not None:
-            result.update(fallback)
-        else:
-            result["error"] = str(exc)
-    finally:
-        conn.close()
-    return result
-
-
-def connect_sqlite_readonly(path: Path) -> sqlite3.Connection:
-    errors: list[str] = []
-    for query in ("mode=ro", "mode=ro&immutable=1"):
-        try:
-            conn = sqlite3.connect(f"file:{path}?{query}", uri=True)
-            conn.row_factory = sqlite3.Row
-            return conn
-        except sqlite3.Error as exc:
-            errors.append(f"{query}: {exc}")
-    raise sqlite3.OperationalError("; ".join(errors))
-
-
-def sqlite_copy_payload(path: Path, limit: int, original_error: str) -> dict[str, Any] | None:
-    try:
-        with tempfile.TemporaryDirectory(prefix="lm-cache-inspect-") as temp_dir:
-            copy_path = Path(temp_dir) / path.name
-            shutil.copy2(path, copy_path)
-            payload = sqlite_payload(copy_path, limit, allow_copy=False)
-            payload["path"] = str(path)
-            payload["inspected_copy"] = True
-            payload["original_error"] = original_error
-            return payload
-    except Exception:
-        return None
-
-
-def json_file_summary(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        return {"exists": False}
-    data = load_json(path)
-    return {"exists": True, "summary": redact(summarize_value(data))}
-
-
-def model_roots(settings: dict[str, Any], active_library: str) -> dict[str, list[str]]:
-    roots: dict[str, list[str]] = {}
-    sources = [settings]
-    library = settings.get("libraries", {}).get(active_library)
-    if isinstance(library, dict):
-        sources.insert(0, library)
-    for source in sources:
-        folder_paths = source.get("folder_paths")
-        if isinstance(folder_paths, dict):
-            for key, value in folder_paths.items():
-                roots.setdefault(key, []).extend(normalize_path_list(value))
-    for default_key, folder_key in (
-        ("default_lora_root", "loras"),
-        ("default_checkpoint_root", "checkpoints"),
-        ("default_embedding_root", "embeddings"),
-        ("default_unet_root", "unet"),
-    ):
-        value = settings.get(default_key)
-        if isinstance(value, str) and value:
-            roots.setdefault(folder_key, []).append(expand_path(value))
-    return {key: dedupe(values) for key, values in roots.items()}
-
-
-def resolve_recipes_root(settings: dict[str, Any], active_library: str) -> Path | None:
-    recipes_path = settings.get("recipes_path")
-    library = settings.get("libraries", {}).get(active_library)
-    if isinstance(library, dict) and isinstance(library.get("recipes_path"), str):
-        recipes_path = library["recipes_path"] or recipes_path
-    if isinstance(recipes_path, str) and recipes_path.strip():
-        return Path(expand_path(recipes_path.strip()))
-    lora_roots = model_roots(settings, active_library).get("loras") or []
-    return Path(lora_roots[0]) / "recipes" if lora_roots else None
-
-
-def example_images_payload(settings: dict[str, Any], active_library: str) -> dict[str, Any]:
-    root = settings.get("example_images_path") or ""
-    libraries = settings.get("libraries")
-    library_count = len(libraries) if isinstance(libraries, dict) else 0
-    scoped = library_count > 1
-    root_path = Path(expand_path(root)) if isinstance(root, str) and root else None
-    library_root = root_path / sanitize_library_name(active_library) if root_path and scoped else root_path
-    return {
-        "root": str(root_path or ""),
-        "uses_library_scoped_folders": scoped,
-        "library_root": str(library_root or ""),
-    }
-
-
-def count_recipe_files(root: Path | None) -> int:
-    if not root or not root.exists():
-        return 0
-    return sum(1 for _ in root.rglob("*.recipe.json"))
-
-
-def normalize_path_list(value: Any) -> list[str]:
-    if isinstance(value, str):
-        return [expand_path(value)] if value else []
-    if isinstance(value, list):
-        return [expand_path(item) for item in value if isinstance(item, str) and item]
-    return []
-
-
-def expand_path(value: str) -> str:
-    return str(Path(value).expanduser().resolve(strict=False))
-
-
-def sanitize_library_name(name: str) -> str:
-    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", name or "default")
-    return safe or "default"
-
-
-def dedupe(values: list[str]) -> list[str]:
-    seen: set[str] = set()
-    result: list[str] = []
-    for value in values:
-        if value not in seen:
-            result.append(value)
-            seen.add(value)
-    return result
-
-
-def redact(value: Any, key: str = "") -> Any:
-    if key and SECRET_PATTERN.search(key):
-        return "<redacted>"
-    if isinstance(value, dict):
-        return {str(k): redact(v, str(k)) for k, v in value.items()}
-    if isinstance(value, list):
-        return [redact(item) for item in value]
-    return value
-
-
-def summarize_value(value: Any) -> Any:
-    if isinstance(value, dict):
-        return {key: summarize_value(item) for key, item in value.items()}
-    if isinstance(value, list):
-        return {
-            "type": "array",
-            "length": len(value),
-            "first": summarize_value(value[0]) if value else None,
-        }
-    return value
-
-
-def quote_identifier(identifier: str) -> str:
-    return '"' + identifier.replace('"', '""') + '"'
-
-
-def is_internal_sqlite_table(table: str) -> bool:
-    return table.startswith("sqlite_") or table.endswith(("_data", "_idx", "_docsize", "_config", "_content"))
-
-
-def print_json(payload: Any) -> None:
-    json.dump(payload, sys.stdout, indent=2, ensure_ascii=False)
-    sys.stdout.write("\n")
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

.github/ISSUE_TEMPLATE/feature_request.md

@@ -13,5 +13,8 @@ A clear and concise description of what the problem is. Ex. I'm always frustrate
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
 **Additional context**
 Add any other context or screenshots about the feature request here.

.github/workflows/update-supporters.yml

@@ -1,31 +0,0 @@
-name: Update Supporters in README
-
-on:
-  push:
-    paths:
-      - 'data/supporters.json'
-    branches:
-      - main
-  workflow_dispatch: # Allow manual trigger
-
-jobs:
-  update-readme:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-          
-      - name: Update README
-        run: python scripts/update_supporters.py
-        
-      - name: Commit and push changes
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "docs: auto-update supporters list in README"
-          file_pattern: "README.md"

.gitignore

@@ -12,22 +12,10 @@ coverage/
 .coverage
 model_cache/
 
-# agent / dev tooling
+# agent
 .opencode/
-.claude/
-.sisyphus/
-.codex
-.omo
-reasonix.toml
-.codegraph/
 
 # Vue widgets development cache (but keep build output)
 vue-widgets/node_modules/
 vue-widgets/.vite/
 vue-widgets/dist/
-
-# Hypothesis test cache
-.hypothesis/
-
-# Working/research notes (not committed)
-.docs/

.omo/plans/embeddings-hybrid-approach.md

@@ -1,181 +0,0 @@
-# Embeddings Usage Tracking — Hybrid Approach (Plan C)
-
-> **Status**: Reference document for future implementation
-> **Current implementation**: Plan A (prompt text parsing only, see `usage_stats.py:_process_embeddings`)
-> **Next step**: Add Plan B as a supplement when edge-case coverage is needed
-
-## Problem
-
-Embeddings in ComfyUI are not loaded through dedicated ComfyUI nodes like LoRAs or
-Checkpoints. They are resolved during CLIP tokenization when the prompt text contains
-`embedding:<name>` syntax (see `comfy/sd1_clip.py:SDTokenizer.tokenize_with_weights`).
-
-This means the existing metadata_collector hook (which intercepts node execution via
-`_map_node_over_list`) cannot capture embeddings the same way it captures LoRAs and
-checkpoints — there is no "EmbeddingLoader" node to intercept.
-
-## Solution Architecture
-
-The hybrid approach combines **two complementary mechanisms** to capture embedding
-usage from all possible paths.
-
-```
-┌─────────────────────────────────────────────────────────┐
-│                 Plan A (已实现)                          │
-│                                                         │
-│  MetadataRegistry.prompt_metadata["prompts"]            │
-│       │                                                  │
-│       ▼                                                  │
-│  _process_embeddings()                                   │
-│       │                                                  │
-│       ├─ Iterate all prompt node texts                   │
-│       ├─ regex extract "embedding:<name>"                │
-│       ├─ resolve name → sha256 via EmbeddingScanner      │
-│       └─ UsageStats.stats["embeddings"][sha256]++        │
-│                                                         │
-│  Coverage: ~95% — all CLIPTextEncode/Flux/etc nodes     │
-│                                                         │
-│  Gap: Custom nodes that load embeddings programmatically │
-│       without putting embedding:name in prompt text      │
-└─────────────────────────────────────────────────────────┘
-
-                         +
-                         ↓  (future: enable Plan B when needed)
-
-┌─────────────────────────────────────────────────────────┐
-│                 Plan B (未来 — monkey-patch)              │
-│                                                         │
-│  comfy/sd1_clip.py:load_embed()                         │
-│       │                                                  │
-│       ▼                                                  │
-│  Monkey-patch intercepts EVERY embedding file load       │
-│       │                                                  │
-│       ├─ Records embedding_name + success/failure        │
-│       ├─ Associates with current prompt_id (via registry)│
-│       └─ Feeds into UsageStats same as Plan A            │
-│                                                         │
-│  Coverage: 100% — catches ALL embedding loads            │
-│                                                         │
-│  Cost: Requires patching into ComfyUI internals          │
-│        (sd1_clip.py, sdxl_clip.py, some text_encoders)   │
-└─────────────────────────────────────────────────────────┘
-```
-
-## Plan B Detail — Monkey-patch `load_embed`
-
-### Target Function
-
-**`comfy.sd1_clip.load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None)`**
-at line 415 of `sd1_clip.py`.
-
-This is the **single choke point** for all embedding file loads in ComfyUI. Every
-CLIP variant (SD1, SDXL, SD3, Flux) calls this same function.
-
-### Implementation Sketch
-
-```python
-# In metadata_collector/metadata_hook.py (or a new module)
-import comfy.sd1_clip as sd1_clip
-
-_original_load_embed = sd1_clip.load_embed
-
-def _patched_load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None):
-    result = _original_load_embed(
-        embedding_name, embedding_directory, embedding_size, embed_key
-    )
-    if result is not None:
-        _record_embedding_usage(embedding_name)
-    return result
-
-sd1_clip.load_embed = _patched_load_embed
-```
-
-### Prompt ID Association
-
-The challenge is associating the `load_embed` call with the current `prompt_id`.
-Options:
-
-1. **Thread-local / contextvar**: Store current `prompt_id` in a `contextvars.ContextVar`
-   that the metadata_collector sets at the start of each prompt execution.
-
-2. **MetadataRegistry singleton**: The MetadataRegistry already has `current_prompt_id`.
-   The patch can read it directly since both run in the same thread.
-
-3. **Lazy aggregation**: Instead of associating with prompt_id at load time, collect
-   all loaded embedding names in a global set during execution, then flush to
-   UsageStats after the prompt completes.
-
-### Files to Patch
-
-| File | Function | Coverage |
-|------|----------|----------|
-| `comfy/sd1_clip.py:415` | `load_embed()` | Primary — SD1.x, SDXL, SD3, Flux |
-| `comfy/sdxl_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-| `comfy/text_encoders/sd3_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-| `comfy/text_encoders/flux.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-
-The SD1 tokenizer is the base class for all CLIP variants' tokenizers, so patching
-`load_embed` covers them all.
-
-### Edge Cases
-
-| Edge Case | Plan A | Plan B |
-|-----------|--------|--------|
-| `embedding:name` in CLIPTextEncode | ✅ | ✅ |
-| `embedding:name` in CLIPTextEncodeFlux | ✅ | ✅ |
-| `embedding:name` in PromptLM (LoRA Manager) | ✅ | ✅ |
-| `embedding:name` in WAS_Text_to_Conditioning | ✅ | ✅ |
-| Custom node that loads embedding programmatically | ❌ | ✅ |
-| Embedding loaded multiple times in same prompt | ✅ (dedup via set) | ✅ (dedup via set) |
-| Embedding file not found | N/A | ✅ (can log) |
-| Embedding dimension mismatch | N/A | ✅ (can log) |
-| Text encoder with non-standard tokenizer (LLaMA, T5...) | Partial | ✅ (if it calls load_embed) |
-
-## Migration Path: Standalone → Hybrid
-
-### Phase 1 — Plan A (当前状态)
-- Prompt text parsing only
-- No monkey-patching required
-- Covers all standard workflows
-
-### Phase 2 — Enable Plan B (未来工作)
-1. Add monkey-patch of `load_embed` in `metadata_collector/metadata_hook.py` (alongside
-   the existing `_map_node_over_list` hook)
-2. Collect loaded embedding names in a `set()` on the registry
-3. In `UsageStats._process_embeddings()`, merge the Plan A results (from prompt text)
-   with the Plan B results (from the patch)
-4. Add `prompt_data` field on MetadataRegistry to store loaded embeddings per prompt
-
-### Deduplication
-
-```python
-# Merge Plan A + Plan B results in _process_embeddings
-plan_a_names = extract_from_prompt_texts(prompts_data)
-plan_b_names = registry.get_loaded_embeddings(prompt_id)
-
-all_names = plan_a_names | plan_b_names
-```
-
-## Testing the Hybrid
-
-| Scenario | What to verify |
-|----------|---------------|
-| Standard `embedding:name` in prompt | Plan A captures it |
-| Embedding loaded by custom node script | Plan B captures it |
-| Both paths fire for same embedding | No double-counting (dedup) |
-| Embedding name resolves to hash | EmbeddingScanner.get_hash_by_filename works |
-| No embedding scanner available | Graceful skip, no crash |
-| Missing embedding file | Plan B logs warning, Plan A skips gracefully |
-| Empty prompt | No crash, no entries |
-| Standalone mode | Both plans disabled gracefully |
-
-## Key Files Reference
-
-| File | Role |
-|------|------|
-| `py/utils/usage_stats.py` | Core — `_process_embeddings()` for Plan A |
-| `py/metadata_collector/constants.py` | `EMBEDDINGS` category constant |
-| `py/metadata_collector/metadata_hook.py` | Future — monkey-patch for Plan B |
-| `py/services/embedding_scanner.py` | Hash resolution service |
-| `py/routes/stats_routes.py` | Already handles `usage_data.get('embeddings', {})` |
-| `comfy/sd1_clip.py` (ComfyUI) | `load_embed()` — Plan B target |

.specs/metadata.schema.json

@@ -1,464 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://github.com/willmiao/ComfyUI-Lora-Manager/.specs/metadata.schema.json",
-  "title": "ComfyUI LoRa Manager Model Metadata",
-  "description": "Schema for .metadata.json sidecar files used by ComfyUI LoRa Manager",
-  "type": "object",
-  "oneOf": [
-    {
-      "title": "LoRA Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string",
-          "description": "Filename without extension"
-        },
-        "model_name": {
-          "type": "string",
-          "description": "Display name of the model"
-        },
-        "file_path": {
-          "type": "string",
-          "description": "Full absolute path to the model file"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0,
-          "description": "File size in bytes at time of import/download"
-        },
-        "modified": {
-          "type": "number",
-          "description": "Unix timestamp when model was imported/added (Date Added)"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$",
-          "description": "SHA256 hash of the model file (lowercase)"
-        },
-        "base_model": {
-          "type": "string",
-          "description": "Base model type (SD1.5, SD2.1, SDXL, SD3, Flux, Unknown, etc.)"
-        },
-        "preview_url": {
-          "type": "string",
-          "description": "Path to preview image file"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "default": 0,
-          "description": "NSFW level using bitmask values: 0 (none), 1 (PG), 2 (PG13), 4 (R), 8 (X), 16 (XXX), 32 (Blocked)"
-        },
-        "notes": {
-          "type": "string",
-          "default": "",
-          "description": "User-defined notes"
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true,
-          "description": "Whether the model originated from Civitai"
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": [],
-          "description": "Model tags"
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": "",
-          "description": "Full model description"
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether the model was deleted from Civitai"
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether the model is marked as favorite"
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether to exclude from cache/scanning"
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether checked against archive database"
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false,
-          "description": "Skip this model during bulk metadata refresh"
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null,
-          "description": "Last provider that supplied metadata"
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0,
-          "description": "Unix timestamp of last metadata check"
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed",
-          "description": "Hash calculation status"
-        },
-        "usage_tips": {
-          "type": "string",
-          "default": "{}",
-          "description": "JSON string containing recommended usage parameters (LoRA only)"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    },
-    {
-      "title": "Checkpoint Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string"
-        },
-        "model_name": {
-          "type": "string"
-        },
-        "file_path": {
-          "type": "string"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "modified": {
-          "type": "number"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$"
-        },
-        "base_model": {
-          "type": "string"
-        },
-        "preview_url": {
-          "type": "string"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 3,
-          "default": 0
-        },
-        "notes": {
-          "type": "string",
-          "default": ""
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": []
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": ""
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed"
-        },
-        "sub_type": {
-          "type": "string",
-          "default": "checkpoint",
-          "description": "Model sub-type (checkpoint, diffusion_model, etc.)"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    },
-    {
-      "title": "Embedding Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string"
-        },
-        "model_name": {
-          "type": "string"
-        },
-        "file_path": {
-          "type": "string"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "modified": {
-          "type": "number"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$"
-        },
-        "base_model": {
-          "type": "string"
-        },
-        "preview_url": {
-          "type": "string"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 3,
-          "default": 0
-        },
-        "notes": {
-          "type": "string",
-          "default": ""
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": []
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": ""
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed"
-        },
-        "sub_type": {
-          "type": "string",
-          "default": "embedding",
-          "description": "Model sub-type"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    }
-  ],
-  "definitions": {
-    "civitaiObject": {
-      "type": "object",
-      "default": {},
-      "description": "Civitai/CivArchive API data and user-defined fields",
-      "properties": {
-        "id": {
-          "type": "integer",
-          "description": "Version ID from Civitai"
-        },
-        "modelId": {
-          "type": "integer",
-          "description": "Model ID from Civitai"
-        },
-        "name": {
-          "type": "string",
-          "description": "Version name"
-        },
-        "description": {
-          "type": "string",
-          "description": "Version description"
-        },
-        "baseModel": {
-          "type": "string",
-          "description": "Base model type from Civitai"
-        },
-        "type": {
-          "type": "string",
-          "description": "Model type (checkpoint, embedding, etc.)"
-        },
-        "trainedWords": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Trigger words for the model (from API or user-defined)"
-        },
-        "customImages": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          },
-          "description": "Custom example images added by user"
-        },
-        "model": {
-          "type": "object",
-          "properties": {
-            "name": {
-              "type": "string"
-            },
-            "description": {
-              "type": "string"
-            },
-            "tags": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "files": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          }
-        },
-        "images": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          }
-        },
-        "creator": {
-          "type": "object"
-        }
-      },
-      "additionalProperties": true
-    },
-    "usageTips": {
-      "type": "object",
-      "description": "Structure for usage_tips JSON string (LoRA models)",
-      "properties": {
-        "strength_min": {
-          "type": "number",
-          "description": "Minimum recommended model strength"
-        },
-        "strength_max": {
-          "type": "number",
-          "description": "Maximum recommended model strength"
-        },
-        "strength_range": {
-          "type": "string",
-          "description": "Human-readable strength range"
-        },
-        "strength": {
-          "type": "number",
-          "description": "Single recommended strength value"
-        },
-        "clip_strength": {
-          "type": "number",
-          "description": "Recommended CLIP/embedding strength"
-        },
-        "clip_skip": {
-          "type": "integer",
-          "description": "Recommended CLIP skip value"
-        }
-      },
-      "additionalProperties": true
-    }
-  }
-}

AGENTS.md

@@ -25,134 +25,168 @@ pytest tests/test_recipes.py::test_function_name
 
 # Run backend tests with coverage
 COVERAGE_FILE=coverage/backend/.coverage pytest \
-  --cov=py --cov=standalone \
+  --cov=py \
+  --cov=standalone \
   --cov-report=term-missing \
   --cov-report=html:coverage/backend/html \
-  --cov-report=xml:coverage/backend/coverage.xml
+  --cov-report=xml:coverage/backend/coverage.xml \
+  --cov-report=json:coverage/backend/coverage.json
 ```
 
-### Frontend Development (Standalone Web UI)
+### Frontend Development
 
 ```bash
+# Install frontend dependencies
 npm install
-npm test                    # Run all tests (JS + Vue)
-npm run test:js             # Run JS tests only
-npm run test:watch          # Watch mode
-npm run test:coverage       # Generate coverage report
-```
 
-### Vue Widget Development
+# Run frontend tests
+npm test
 
-```bash
+# Run frontend tests in watch mode
-cd vue-widgets
+npm run test:watch
-npm install
+
-npm run dev                 # Build in watch mode
+# Run frontend tests with coverage
-npm run build               # Build production bundle
+npm run test:coverage
-npm run typecheck           # Run TypeScript type checking
-npm test                    # Run Vue widget tests
-npm run test:watch          # Watch mode
-npm run test:coverage       # Generate coverage report
 ```
 
 ## Python Code Style
 
-### Imports & Formatting
+### Imports
 
-- Use `from __future__ import annotations` for forward references
+- Use `from __future__ import annotations` for forward references in type hints
-- Group imports: standard library, third-party, local (blank line separated)
+- Group imports: standard library, third-party, local (separated by blank lines)
-- Absolute imports within `py/`: `from ..services import X`
+- Use absolute imports within `py/` package: `from ..services import X`
-- PEP 8 with 4-space indentation, type hints required
+- Mock ComfyUI dependencies in tests using `tests/conftest.py` patterns
+
+### Formatting & Types
+
+- PEP 8 with 4-space indentation
+- Type hints required for function signatures and class attributes
+- Use `TYPE_CHECKING` guard for type-checking-only imports
+- Prefer dataclasses for simple data containers
+- Use `Optional[T]` for nullable types, `Union[T, None]` only when necessary
 
 ### Naming Conventions
 
-- Files: `snake_case.py`, Classes: `PascalCase`, Functions/vars: `snake_case`
+- Files: `snake_case.py` (e.g., `model_scanner.py`, `lora_service.py`)
-- Constants: `UPPER_SNAKE_CASE`, Private: `_protected`, `__mangled`
+- Classes: `PascalCase` (e.g., `ModelScanner`, `LoraService`)
+- Functions/variables: `snake_case` (e.g., `get_instance`, `model_type`)
+- Constants: `UPPER_SNAKE_CASE` (e.g., `VALID_LORA_TYPES`)
+- Private members: `_single_underscore` (protected), `__double_underscore` (name-mangled)
 
-### Error Handling & Async
+### Error Handling
 
-- Use `logging.getLogger(__name__)`, define custom exceptions in `py/services/errors.py`
+- Use `logging.getLogger(__name__)` for module-level loggers
-- `async def` for I/O, `@pytest.mark.asyncio` for async tests
+- Define custom exceptions in `py/services/errors.py`
-- Singleton with `asyncio.Lock`: see `ModelScanner.get_instance()`
+- Use `asyncio.Lock` for thread-safe singleton patterns
-- Return `aiohttp.web.json_response` or `web.Response`
+- Raise specific exceptions with descriptive messages
+- Log errors at appropriate levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
 
-### Testing
+### Async Patterns
 
-- `pytest` with `--import-mode=importlib`
+- Use `async def` for I/O-bound operations
-- Fixtures in `tests/conftest.py`, use `tmp_path_factory` for isolation
+- Mark async tests with `@pytest.mark.asyncio`
-- Mark tests needing real paths: `@pytest.mark.no_settings_dir_isolation`
+- Use `async with` for context managers
-- Mock ComfyUI dependencies via conftest patterns
+- Singleton pattern with class-level locks: see `ModelScanner.get_instance()`
+- Use `aiohttp.web.Response` for HTTP responses
 
-## JavaScript/TypeScript Code Style
+### Testing Patterns
+
+- Use `pytest` with `--import-mode=importlib`
+- Fixtures in `tests/conftest.py` handle ComfyUI mocking
+- Use `@pytest.mark.no_settings_dir_isolation` for tests needing real paths
+- Test files: `tests/test_*.py`
+- Use `tmp_path_factory` for temporary directory isolation
+
+## JavaScript Code Style
 
 ### Imports & Modules
 
-- ES modules: `import { app } from "../../scripts/app.js"` for ComfyUI
+- ES modules with `import`/`export`
-- Vue: `import { ref, computed } from 'vue'`, type imports: `import type { Foo }`
+- Use `import { app } from "../../scripts/app.js"` for ComfyUI integration
-- Export named functions: `export function foo() {}`
+- Export named functions/classes: `export function foo() {}`
+- Widget files use `*_widget.js` suffix
 
 ### Naming & Formatting
 
-- camelCase for functions/vars/props, PascalCase for classes
+- camelCase for functions, variables, object properties
-- Constants: `UPPER_SNAKE_CASE`, Files: `snake_case.js` or `kebab-case.js`
+- PascalCase for classes/constructors
+- Constants: `UPPER_SNAKE_CASE` (e.g., `CONVERTED_TYPE`)
+- Files: `snake_case.js` or `kebab-case.js`
 - 2-space indentation preferred (follow existing file conventions)
-- Vue Single File Components: `<script setup lang="ts">` preferred
 
 ### Widget Development
 
-- ComfyUI: `app.registerExtension()`, `node.addDOMWidget(name, type, element, options)`
+- Use `app.registerExtension()` to register ComfyUI extensions
-- Event handlers via `addEventListener` or widget callbacks
+- Use `node.addDOMWidget(name, type, element, options)` for custom widgets
-- Shared utilities: `web/comfyui/utils.js`
+- Event handlers attached via `addEventListener` or widget callbacks
-
+- See `web/comfyui/utils.js` for shared utilities
-### Vue Composables Pattern
-
-- Use composition API: `useXxxState(widget)`, return reactive refs and methods
-- Guard restoration loops with flag: `let isRestoring = false`
-- Build config from state: `const buildConfig = (): Config => { ... }`
 
 ## Architecture Patterns
 
 ### Service Layer
 
-- `ServiceRegistry` singleton for DI, services use `get_instance()` classmethod
+- Use `ServiceRegistry` singleton for dependency injection
+- Services follow singleton pattern via `get_instance()` class method
 - Separate scanners (discovery) from services (business logic)
-- Handlers in `py/routes/handlers/` are pure functions with deps as params
+- Handlers in `py/routes/handlers/` implement route logic
 
-### Model Types & Routes
+### Model Types
 
-- `BaseModelService` base for LoRA, Checkpoint, Embedding
+- BaseModelService is abstract base for LoRA, Checkpoint, Embedding services
-- `ModelScanner` for file discovery, hash deduplication
+- ModelScanner provides file discovery and hash-based deduplication
-- `PersistentModelCache` (SQLite) for persistence
+- Persistent cache in SQLite via `PersistentModelCache`
-- Route registrars: `ModelRouteRegistrar`, endpoints: `/loras/*`, `/checkpoints/*`, `/embeddings/*`
+- Metadata sync from CivitAI/CivArchive via `MetadataSyncService`
-- WebSocket via `WebSocketManager` for real-time updates
+
+### Routes & Handlers
+
+- Route registrars organize endpoints by domain: `ModelRouteRegistrar`, etc.
+- Handlers are pure functions taking dependencies as parameters
+- Use `WebSocketManager` for real-time progress updates
+- Return `aiohttp.web.json_response` or `web.Response`
 
 ### Recipe System
 
-- Base: `py/recipes/base.py`, Enrichment: `RecipeEnrichmentService`
+- Base metadata in `py/recipes/base.py`
-- Parsers: `py/recipes/parsers/`
+- Enrichment adds model metadata: `RecipeEnrichmentService`
+- Parsers for different formats in `py/recipes/parsers/`
 
 ## Important Notes
 
-- ALWAYS use English for comments (per copilot-instructions.md)
+- Always use English for comments (per copilot-instructions.md)
-- Dual mode: ComfyUI plugin (folder_paths) vs standalone (settings.json)
+- Dual mode: ComfyUI plugin (uses folder_paths) vs standalone (reads settings.json)
 - Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
-- Run `python scripts/sync_translation_keys.py` after adding UI strings to `locales/en.json`
+- Settings auto-saved in user directory or portable mode
-- Symlinks require normalized paths
+- WebSocket broadcasts for real-time updates (downloads, scans)
-
+- Symlink handling requires normalized paths
-## Git / Commit Messages
+- API endpoints follow `/loras/*`, `/checkpoints/*`, `/embeddings/*` patterns
-
+- Run `python scripts/sync_translation_keys.py` after UI string updates
-- Follow the style of recent repository commits when writing commit messages
-- Prefer the repo's existing `feat(...)`, `fix(...)`, `chore:` style where applicable
-- If the user has provided a GitHub issue link or issue ID for the task, mention that issue in the commit message, for example `(#871)`
-- When unrelated local changes exist, stage and commit only the files relevant to the requested task
 
 ## Frontend UI Architecture
 
-### 1. Standalone Web UI
+This project has two distinct UI systems:
+
+### 1. Standalone Lora Manager Web UI
 - Location: `./static/` and `./templates/`
-- Tech: Vanilla JS + CSS, served by standalone server
+- Purpose: Full-featured web application for managing LoRA models
-- Tests via npm in root directory
+- Tech stack: Vanilla JS + CSS, served by the standalone server
+- Development: Uses npm for frontend testing (`npm test`, `npm run test:watch`, etc.)
 
 ### 2. ComfyUI Custom Node Widgets
-- Location: `./web/comfyui/` (Vanilla JS) + `./vue-widgets/` (Vue)
+- Location: `./web/comfyui/`
-- Primary styles: `./web/comfyui/lm_styles.css` (NOT `./static/css/`)
+- Purpose: Widgets and UI logic that ComfyUI loads as custom node extensions
-- Vue builds to `./web/comfyui/vue-widgets/`, typecheck via `vue-tsc`
+- Tech stack: Vanilla JS + Vue.js widgets (in `./vue-widgets/` and built to `./web/comfyui/vue-widgets/`)
+- Widget styling: Primary styles in `./web/comfyui/lm_styles.css` (NOT `./static/css/`)
+- Development: No npm build step for these widgets (Vue widgets use build system)
+
+### Widget Development Guidelines
+- Use `app.registerExtension()` to register ComfyUI extensions (ComfyUI integration layer)
+- Use `node.addDOMWidget()` for custom DOM widgets
+- Widget styles should follow the patterns in `./web/comfyui/lm_styles.css`
+  - Selected state: `rgba(66, 153, 225, 0.3)` background, `rgba(66, 153, 225, 0.6)` border
+  - Hover state: `rgba(66, 153, 225, 0.2)` background
+  - Color palette matches the Lora Manager accent color (blue #4299e1)
+  - Use oklch() for color values when possible (defined in `./static/css/base.css`)
+- Vue widget components are in `./vue-widgets/src/components/` and built to `./web/comfyui/vue-widgets/`
+- When modifying widget styles, check `./web/comfyui/lm_styles.css` for consistency with other ComfyUI widgets
+

CLAUDE.md

@@ -8,22 +8,17 @@ ComfyUI LoRA Manager is a comprehensive LoRA management system for ComfyUI that
 
 ## Development Commands
 
-### Backend
+### Backend Development
-
 ```bash
+# Install dependencies
 pip install -r requirements.txt
+
+# Install development dependencies (for testing)
 pip install -r requirements-dev.txt
 
 # Run standalone server (port 8188 by default)
 python standalone.py --port 8188
 
-# Run all backend tests
-pytest
-
-# Run specific test file or function
-pytest tests/test_recipes.py
-pytest tests/test_recipes.py::test_function_name
-
 # Run backend tests with coverage
 COVERAGE_FILE=coverage/backend/.coverage pytest \
   --cov=py \
@@ -32,158 +27,185 @@ COVERAGE_FILE=coverage/backend/.coverage pytest \
   --cov-report=html:coverage/backend/html \
   --cov-report=xml:coverage/backend/coverage.xml \
   --cov-report=json:coverage/backend/coverage.json
+
+# Run specific test file
+pytest tests/test_recipes.py
 ```
 
-### Frontend
+### Frontend Development
-
-There are three test suites run by `npm test`: vanilla JS tests (vitest at root) and Vue widget tests (`vue-widgets/` vitest).
-
 ```bash
+# Install frontend dependencies
 npm install
-cd vue-widgets && npm install && cd ..
 
-# Run all frontend tests (JS + Vue)
+# Run frontend tests
 npm test
 
-# Run only vanilla JS tests
+# Run frontend tests in watch mode
-npm run test:js
-
-# Run only Vue widget tests
-npm run test:vue
-
-# Watch mode (JS tests only)
 npm run test:watch
 
-# Frontend coverage
+# Run frontend tests with coverage
 npm run test:coverage
-
-# Build Vue widgets (output to web/comfyui/vue-widgets/)
-cd vue-widgets && npm run build
-
-# Vue widget dev mode (watch + rebuild)
-cd vue-widgets && npm run dev
-
-# Typecheck Vue widgets
-cd vue-widgets && npm run typecheck
 ```
 
 ### Localization
-
 ```bash
 # Sync translation keys after UI string updates
 python scripts/sync_translation_keys.py
 ```
 
-Locale files are in `locales/` (en, zh-CN, zh-TW, ja, ko, fr, de, es, ru, he).
-
 ## Architecture
 
-### Dual Mode Operation
+### Backend Structure (Python)
 
-The system runs in two modes:
+**Core Entry Points:**
-- **ComfyUI plugin mode**: Integrates with ComfyUI's PromptServer, uses `folder_paths` for model discovery
+- `__init__.py` - ComfyUI plugin entry point, registers nodes and routes
-- **Standalone mode**: `standalone.py` mocks ComfyUI dependencies, reads paths from `settings.json`
+- `standalone.py` - Standalone server that mocks ComfyUI dependencies
-- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+- `py/lora_manager.py` - Main LoraManager class that registers HTTP routes
 
-### Backend (Python)
+**Service Layer** (`py/services/`):
+- `ServiceRegistry` - Singleton service registry for dependency management
+- `ModelServiceFactory` - Factory for creating model services (LoRA, Checkpoint, Embedding)
+- Scanner services (`lora_scanner.py`, `checkpoint_scanner.py`, `embedding_scanner.py`) - Model file discovery and indexing
+- `model_scanner.py` - Base scanner with hash-based deduplication and metadata extraction
+- `persistent_model_cache.py` - SQLite-based cache for model metadata
+- `metadata_sync_service.py` - Syncs metadata from CivitAI/CivArchive APIs
+- `civitai_client.py` / `civarchive_client.py` - API clients for external services
+- `downloader.py` / `download_manager.py` - Model download orchestration
+- `recipe_scanner.py` - Recipe file management and image association
+- `settings_manager.py` - Application settings with migration support
+- `websocket_manager.py` - WebSocket broadcasting for real-time updates
+- `use_cases/` - Business logic orchestration (auto-organize, bulk refresh, downloads)
 
-**Entry points:**
+**Routes Layer** (`py/routes/`):
-- `__init__.py` — ComfyUI plugin entry: registers nodes via `NODE_CLASS_MAPPINGS`, sets `WEB_DIRECTORY`, calls `LoraManager.add_routes()`
+- Route registrars organize endpoints by domain (models, recipes, previews, example images, updates)
-- `standalone.py` — Standalone server: mocks `folder_paths` and node modules, starts aiohttp server
+- `handlers/` - Request handlers implementing business logic
-- `py/lora_manager.py` — Main `LoraManager` class that registers all HTTP routes
+- Routes use aiohttp and integrate with ComfyUI's PromptServer
 
-**Service layer** (`py/services/`):
+**Recipe System** (`py/recipes/`):
-- `ServiceRegistry` singleton for dependency injection; services follow `get_instance()` singleton pattern
+- `base.py` - Base recipe metadata structure
-- `BaseModelService` abstract base → `LoraService`, `CheckpointService`, `EmbeddingService`
+- `enrichment.py` - Enriches recipes with model metadata
-- `ModelScanner` base → `LoraScanner`, `CheckpointScanner`, `EmbeddingScanner` for file discovery with hash-based deduplication
+- `merger.py` - Merges recipe data from multiple sources
-- `PersistentModelCache` — SQLite-based metadata cache
+- `parsers/` - Parsers for different recipe formats (PNG, JSON, workflow)
-- `MetadataSyncService` — Background sync from CivitAI/CivArchive APIs
-- `SettingsManager` — Settings with schema migration support
-- `WebSocketManager` — Real-time progress broadcasting
-- `ModelServiceFactory` — Creates the right service for each model type
-- Use cases in `py/services/use_cases/` orchestrate complex business logic (auto-organize, bulk refresh, downloads)
 
-**Routes** (`py/routes/`):
+**Custom Nodes** (`py/nodes/`):
-- Route registrars organize endpoints by domain: `ModelRouteRegistrar`, `RecipeRouteRegistrar`, etc.
+- `lora_loader.py` - LoRA loader nodes with preset support
-- Request handlers in `py/routes/handlers/` implement route logic
+- `save_image.py` - Enhanced save image with pattern-based filenames
-- API endpoints follow `/loras/*`, `/checkpoints/*`, `/embeddings/*` patterns
+- `trigger_word_toggle.py` - Toggle trigger words in prompts
-- All routes use aiohttp, return `web.json_response` or `web.Response`
+- `lora_stacker.py` - Stack multiple LoRAs
-
+- `prompt.py` - Prompt node with autocomplete
-**Recipe system** (`py/recipes/`):
+- `wanvideo_lora_select.py` - WanVideo-specific LoRA selection
-- `base.py` — Recipe metadata structure
-- `enrichment.py` — Enriches recipes with model metadata
-- `parsers/` — Parsers for PNG metadata, JSON, and workflow formats
-
-**Custom nodes** (`py/nodes/`):
-- Each node class has a `NAME` class attribute used as key in `NODE_CLASS_MAPPINGS`
-- Standard ComfyUI node pattern: `INPUT_TYPES()` classmethod, `RETURN_TYPES`, `FUNCTION`
-- All nodes registered in `__init__.py`
 
 **Configuration** (`py/config.py`):
-- Manages folder paths for models, handles symlink mappings
+- Manages folder paths for models, checkpoints, embeddings
+- Handles symlink mappings for complex directory structures
 - Auto-saves paths to settings.json in ComfyUI mode
 
-### Frontend — Two Distinct UI Systems
+### Frontend Structure (JavaScript)
 
-#### 1. Standalone Manager Web UI
+**ComfyUI Widgets** (`web/comfyui/`):
-- **Location:** `static/` (JS/CSS) and `templates/` (HTML)
+- Vanilla JavaScript ES modules extending ComfyUI's LiteGraph-based UI
-- **Tech:** Vanilla JS + CSS, served by standalone server
+- `loras_widget.js` - Main LoRA selection widget with preview
-- **Structure:** `static/js/core.js` (shared), `loras.js`, `checkpoints.js`, `embeddings.js`, `recipes.js`, `statistics.js`
+- `loras_widget_events.js` - Event handling for widget interactions
-- **Tests:** `tests/frontend/**/*.test.js` (vitest + jsdom)
+- `autocomplete.js` - Autocomplete for trigger words and embeddings
+- `preview_tooltip.js` - Preview tooltip for model cards
+- `top_menu_extension.js` - Adds "Launch LoRA Manager" menu item
+- `trigger_word_highlight.js` - Syntax highlighting for trigger words
+- `utils.js` - Shared utilities and API helpers
 
-#### 2. ComfyUI Custom Node Widgets
+**Widget Development:**
-- **Vanilla JS widgets:** `web/comfyui/*.js` — ES modules extending ComfyUI's LiteGraph UI
+- Widgets use `app.registerExtension` and `getCustomWidgets` hooks
-  - `loras_widget.js` / `loras_widget_events.js` — Main LoRA selection widget
+- `node.addDOMWidget(name, type, element, options)` embeds HTML in nodes
-  - `autocomplete.js` — Trigger word and embedding autocomplete
+- See `docs/dom_widget_dev_guide.md` for complete DOMWidget development guide
-  - `preview_tooltip.js` — Model card preview tooltips
-  - `top_menu_extension.js` — "Launch LoRA Manager" menu item
-  - `utils.js` — Shared utilities and API helpers
-  - Widget styling in `web/comfyui/lm_styles.css` (NOT `static/css/`)
-- **Vue widgets:** `vue-widgets/src/` → built to `web/comfyui/vue-widgets/`
-  - Vue 3 + TypeScript + PrimeVue + vue-i18n
-  - Vite build with CSS-injected-by-JS plugin
-  - Components: `LoraPoolWidget`, `LoraRandomizerWidget`, `LoraCyclerWidget`, `AutocompleteTextWidget`
-  - Auto-built on ComfyUI startup via `py/vue_widget_builder.py`
-  - Tests: `vue-widgets/tests/**/*.test.ts` (vitest)
 
-**Widget registration pattern:**
+**Web Source** (`web-src/`):
-- Widgets use `app.registerExtension()` and `getCustomWidgets` hooks
+- Modern frontend components (if migrating from static)
-- `node.addDOMWidget(name, type, element, options)` embeds HTML in LiteGraph nodes
+- `components/` - Reusable UI components
-- See `docs/dom_widget_dev_guide.md` for DOMWidget development guide
+- `styles/` - CSS styling
+
+### Key Patterns
+
+**Dual Mode Operation:**
+- ComfyUI plugin mode: Integrates with ComfyUI's PromptServer, uses folder_paths
+- Standalone mode: Mocks ComfyUI dependencies via `standalone.py`, reads paths from settings.json
+- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+
+**Settings Management:**
+- Settings stored in user directory (via `platformdirs`) or portable mode (in repo)
+- Migration system tracks settings schema version
+- Template in `settings.json.example` defines defaults
+
+**Model Scanning Flow:**
+1. Scanner walks folder paths, computes file hashes
+2. Hash-based deduplication prevents duplicate processing
+3. Metadata extracted from safetensors headers
+4. Persistent cache stores results in SQLite
+5. Background sync fetches CivitAI/CivArchive metadata
+6. WebSocket broadcasts updates to connected clients
+
+**Recipe System:**
+- Recipes store LoRA combinations with parameters
+- Supports import from workflow JSON, PNG metadata
+- Images associated with recipes via sibling file detection
+- Enrichment adds model metadata for display
+
+**Frontend-Backend Communication:**
+- REST API for CRUD operations
+- WebSocket for real-time progress updates (downloads, scans)
+- API endpoints follow `/loras/*` pattern
 
 ## Code Style
 
 **Python:**
-- PEP 8, 4-space indentation, English comments only
+- PEP 8 with 4-space indentation
-- Use `from __future__ import annotations` for forward references
+- snake_case for files, functions, variables
-- Use `TYPE_CHECKING` guard for type-checking-only imports
+- PascalCase for classes
+- Type hints preferred
+- English comments only (per copilot-instructions.md)
 - Loggers via `logging.getLogger(__name__)`
-- Custom exceptions in `py/services/errors.py`
-- Async patterns: `async def` for I/O, `@pytest.mark.asyncio` for async tests
-- Singleton pattern with class-level `asyncio.Lock` (see `ModelScanner.get_instance()`)
 
 **JavaScript:**
-- ES modules, camelCase functions/variables, PascalCase classes
+- ES modules with camelCase
-- Widget files use `*_widget.js` suffix
+- Files use `*_widget.js` suffix for ComfyUI widgets
-- Prefer vanilla JS for `web/comfyui/` widgets, avoid framework dependencies (except Vue widgets)
+- Prefer vanilla JS, avoid framework dependencies
 
 ## Testing
 
-**Backend (pytest):**
+**Backend Tests:**
-- Config in `pytest.ini`: `--import-mode=importlib`, testpaths=`tests`
+- pytest with `--import-mode=importlib`
-- Fixtures in `tests/conftest.py` handle ComfyUI dependency mocking
+- Test files: `tests/test_*.py`
-- Markers: `@pytest.mark.asyncio`, `@pytest.mark.no_settings_dir_isolation`
+- Fixtures in `tests/conftest.py`
-- Uses `tmp_path_factory` for directory isolation
+- Mock ComfyUI dependencies using standalone.py patterns
+- Markers: `@pytest.mark.asyncio` for async tests, `@pytest.mark.no_settings_dir_isolation` for real paths
 
-**Frontend (vitest):**
+**Frontend Tests:**
-- Vanilla JS tests: `tests/frontend/**/*.test.js` with jsdom
+- Vitest with jsdom environment
-- Vue widget tests: `vue-widgets/tests/**/*.test.ts` with jsdom + @vue/test-utils
+- Test files: `tests/frontend/**/*.test.js`
 - Setup in `tests/frontend/setup.js`
+- Coverage via `npm run test:coverage`
 
-## Key Integration Points
+## Important Notes
 
-- **Settings:** Stored in user directory (via `platformdirs`) or portable mode (`"use_portable_settings": true`)
+**Settings Location:**
-- **CivitAI/CivArchive:** API clients for metadata sync and model downloads; CivitAI API key in settings
+- ComfyUI mode: Auto-saves folder paths to user settings directory
-- **Symlink handling:** Config scans symlinks to map virtual→physical paths; fingerprinting prevents redundant rescans
+- Standalone mode: Use `settings.json` (copy from `settings.json.example`)
-- **WebSocket:** Broadcasts real-time progress for downloads, scans, and metadata sync
+- Portable mode: Set `"use_portable_settings": true` in settings.json
-- **Model scanning flow:** Walk folders → compute hashes → deduplicate → extract safetensors metadata → cache in SQLite → background CivitAI sync → WebSocket broadcast
+
+**API Integration:**
+- CivitAI API key required for downloads (add to settings)
+- CivArchive API used as fallback for deleted models
+- Metadata archive database available for offline metadata
+
+**Symlink Handling:**
+- Config scans symlinks to map virtual paths to physical locations
+- Preview validation uses normalized preview root paths
+- Fingerprinting prevents redundant symlink rescans
+
+**ComfyUI Node Development:**
+- Nodes defined in `py/nodes/`, registered in `__init__.py`
+- Frontend widgets in `web/comfyui/`, matched by node type
+- Use `WEB_DIRECTORY = "./web/comfyui"` convention
+
+**Recipe Image Association:**
+- Recipes scan for sibling images in same directory
+- Supports repair/migration of recipe image paths
+- See `py/services/recipe_scanner.py` for implementation details

__init__.py

@@ -1,13 +1,10 @@
 try:  # pragma: no cover - import fallback for pytest collection
     from .py.lora_manager import LoraManager
     from .py.nodes.lora_loader import LoraLoaderLM, LoraTextLoaderLM
-    from .py.nodes.checkpoint_loader import CheckpointLoaderLM
-    from .py.nodes.unet_loader import UNETLoaderLM
     from .py.nodes.trigger_word_toggle import TriggerWordToggleLM
     from .py.nodes.prompt import PromptLM
     from .py.nodes.text import TextLM
     from .py.nodes.lora_stacker import LoraStackerLM
-    from .py.nodes.lora_stack_combiner import LoraStackCombinerLM
     from .py.nodes.save_image import SaveImageLM
     from .py.nodes.debug_metadata import DebugMetadataLM
     from .py.nodes.wanvideo_lora_select import WanVideoLoraSelectLM
@@ -30,19 +27,16 @@ except (
     PromptLM = importlib.import_module("py.nodes.prompt").PromptLM
     TextLM = importlib.import_module("py.nodes.text").TextLM
     LoraManager = importlib.import_module("py.lora_manager").LoraManager
-    LoraLoaderLM = importlib.import_module("py.nodes.lora_loader").LoraLoaderLM
+    LoraLoaderLM = importlib.import_module(
-    LoraTextLoaderLM = importlib.import_module("py.nodes.lora_loader").LoraTextLoaderLM
+        "py.nodes.lora_loader"
-    CheckpointLoaderLM = importlib.import_module(
+    ).LoraLoaderLM
-        "py.nodes.checkpoint_loader"
+    LoraTextLoaderLM = importlib.import_module(
-    ).CheckpointLoaderLM
+        "py.nodes.lora_loader"
-    UNETLoaderLM = importlib.import_module("py.nodes.unet_loader").UNETLoaderLM
+    ).LoraTextLoaderLM
     TriggerWordToggleLM = importlib.import_module(
         "py.nodes.trigger_word_toggle"
     ).TriggerWordToggleLM
     LoraStackerLM = importlib.import_module("py.nodes.lora_stacker").LoraStackerLM
-    LoraStackCombinerLM = importlib.import_module(
-        "py.nodes.lora_stack_combiner"
-    ).LoraStackCombinerLM
     SaveImageLM = importlib.import_module("py.nodes.save_image").SaveImageLM
     DebugMetadataLM = importlib.import_module("py.nodes.debug_metadata").DebugMetadataLM
     WanVideoLoraSelectLM = importlib.import_module(
@@ -55,7 +49,9 @@ except (
     LoraRandomizerLM = importlib.import_module(
         "py.nodes.lora_randomizer"
     ).LoraRandomizerLM
-    LoraCyclerLM = importlib.import_module("py.nodes.lora_cycler").LoraCyclerLM
+    LoraCyclerLM = importlib.import_module(
+        "py.nodes.lora_cycler"
+    ).LoraCyclerLM
     init_metadata_collector = importlib.import_module("py.metadata_collector").init
 
 NODE_CLASS_MAPPINGS = {
@@ -63,11 +59,8 @@ NODE_CLASS_MAPPINGS = {
     TextLM.NAME: TextLM,
     LoraLoaderLM.NAME: LoraLoaderLM,
     LoraTextLoaderLM.NAME: LoraTextLoaderLM,
-    CheckpointLoaderLM.NAME: CheckpointLoaderLM,
-    UNETLoaderLM.NAME: UNETLoaderLM,
     TriggerWordToggleLM.NAME: TriggerWordToggleLM,
     LoraStackerLM.NAME: LoraStackerLM,
-    LoraStackCombinerLM.NAME: LoraStackCombinerLM,
     SaveImageLM.NAME: SaveImageLM,
     DebugMetadataLM.NAME: DebugMetadataLM,
     WanVideoLoraSelectLM.NAME: WanVideoLoraSelectLM,

data/supporters.json

@@ -1,833 +0,0 @@
-{
-  "specialThanks": [
-    "dispenser",
-    "EbonEagle",
-    "DanielMagPizza",
-    "Scott R"
-  ],
-  "allSupporters": [
-    "megakirbs",
-    "Brennok",
-    "Insomnia Art Designs",
-    "2018cfh",
-    "Arlecchino Shion",
-    "Charles Blakemore",
-    "Rob Williams",
-    "W+K+White",
-    "$MetaSamsara",
-    "wackop",
-    "Phil",
-    "Carl G.",
-    "stone9k",
-    "Rosenthal",
-    "itismyelement",
-    "Mozzel",
-    "Gingko Biloba",
-    "Kiba",
-    "onesecondinosaur",
-    "Christian Byrne",
-    "DM",
-    "Sen314",
-    "Estragon",
-    "ClockDaemon",
-    "Francisco Tatis",
-    "Tobi_Swagg",
-    "SG",
-    "jmack",
-    "Andrew Wilson",
-    "Greybush",
-    "Ricky Carter",
-    "JongWon Han",
-    "VantAI",
-    "レプサイ",
-    "Michael Wong",
-    "runte3221",
-    "Illrigger",
-    "Tom Corrigan",
-    "JackieWang",
-    "FreelancerZ",
-    "fnkylove",
-    "Echo",
-    "Lilleman",
-    "Robert Stacey",
-    "PM",
-    "Edgar Tejeda",
-    "Fraser Cross",
-    "Liam MacDougal",
-    "Polymorphic Indeterminate",
-    "Sterilized",
-    "JORGE+LUIZ+HUSSNI+MESSIAS",
-    "Marc Whiffen",
-    "Skalabananen",
-    "Birdy",
-    "quarz",
-    "Reno Lam",
-    "JSST",
-    "sig",
-    "J\\B/ 8r0wns0n",
-    "Snaggwort",
-    "Takkan",
-    "Matt+J",
-    "Baekdoosixt",
-    "Jonathan Ross",
-    "KD",
-    "Omnidex",
-    "Nazono_hito",
-    "Melville Parrish",
-    "daniel dove",
-    "Lustre",
-    "Tyler Trebuchon",
-    "Release Cabrakan",
-    "JW Sin",
-    "Alex",
-    "bh",
-    "carozzz",
-    "Marlon Daniels",
-    "James Dooley",
-    "zenbound",
-    "Buzzard",
-    "Aaron Bleuer",
-    "Adam Shaw",
-    "Mark Corneglio",
-    "SarcasticHashtag",
-    "Anthony Rizzo",
-    "iamresist",
-    "RedrockVP",
-    "Wolffen",
-    "James Todd",
-    "Wicked Choices by ASLPro3D",
-    "FinalyFree",
-    "Weasyl",
-    "Steven Pfeiffer",
-    "Timmy",
-    "Johnny",
-    "Tak",
-    "Lisster",
-    "Big Red",
-    "whudunit",
-    "Luc Job",
-    "dl0901dm",
-    "corde",
-    "nwalker94",
-    "Yushio",
-    "Vik71it",
-    "Bishoujoker",
-    "Todd Keck",
-    "Briton Heilbrun",
-    "Tori",
-    "wildnut",
-    "Aleksander Wujczyk",
-    "AM Kuro",
-    "BadassArabianMofo",
-    "Pascal Dahle",
-    "Greg",
-    "Sangheili460",
-    "MagnaInsomnia",
-    "Akira_HentAI",
-    "lmsupporter",
-    "andrew.tappan",
-    "N/A",
-    "Greenmoustache",
-    "zounic",
-    "wfpearl",
-    "Eldithor",
-    "Jack B Nimble",
-    "JaxMax",
-    "contrite831",
-    "Jwk0205",
-    "Starkselle",
-    "Olive",
-    "LacesOut!",
-    "greebles",
-    "Some Guy Named Barry",
-    "M Postkasse",
-    "Gooohokrbe",
-    "wamekukyouzin",
-    "OldBones",
-    "Jacob Hoehler",
-    "Dogmaster",
-    "Matt Wenzel",
-    "Lex Song",
-    "Cory Paza",
-    "Gonzalo Andre Allendes Lopez",
-    "Zach Gonser",
-    "Serge Bekenkamp",
-    "Jimmy Ledbetter",
-    "Philip Hempel",
-    "dan",
-    "aai",
-    "Mouthlessman",
-    "otaku fra",
-    "jean jahren",
-    "MiraiKuriyamaSy",
-    "Ran C",
-    "ViperC",
-    "Penfore",
-    "Karl P.",
-    "Gordon Cole",
-    "Adam Taylor",
-    "AbstractAss",
-    "Weird_With_A_Beard",
-    "The Spawn",
-    "graysock",
-    "Pozadine1",
-    "Qarob",
-    "AIGooner",
-    "Luc",
-    "ProtonPrince",
-    "DiffDuck",
-    "Jackthemind",
-    "fancypants",
-    "Joboshy",
-    "Digital",
-    "takyamtom",
-    "Bohemian Corporal",
-    "Dan",
-    "Bro Xie",
-    "yer fey",
-    "batblue",
-    "carey6409",
-    "太郎 ゲーム",
-    "Roslynd",
-    "jinxedx",
-    "Neco28",
-    "Cosmosis",
-    "David Ortega",
-    "AELOX",
-    "Dankin",
-    "Nicfit23",
-    "FloPro4Sho",
-    "Cristian Vazquez",
-    "drum matthieu",
-    "Frank Nitty",
-    "Magic Noob",
-    "Christopher Michel",
-    "DougPeterson",
-    "LeoZero",
-    "Antonio Pontes",
-    "ApathyJones",
-    "Bruce",
-    "Julian V",
-    "Steven Owens",
-    "nahinahi9",
-    "Kevin John Duck",
-    "Dustin Chen",
-    "Blackfish95",
-    "Paul Kroll",
-    "Bas Imagineer",
-    "John Statham",
-    "yuxz69",
-    "esthe",
-    "decoy",
-    "elu3199",
-    "Hasturkun",
-    "Jon Sandman",
-    "Ubivis",
-    "CloudValley",
-    "thesoftwaredruid",
-    "wundershark",
-    "mr_dinosaur",
-    "Tyrswood",
-    "Ray Wing",
-    "Ranzitho",
-    "Gus",
-    "MJG",
-    "David LaVallee",
-    "linnfrey",
-    "ae",
-    "Tr4shP4nda",
-    "IamAyam",
-    "skaterb949",
-    "Brian M",
-    "Josef Lanzl",
-    "Nerezza",
-    "sanborondon",
-    "confiscated Zyra",
-    "Error_Rule34_Not_found",
-    "Taylor Funk",
-    "aezin",
-    "jcay015",
-    "Gerald Welly",
-    "Erik Lopez",
-    "Mateo Curić",
-    "Tee Gee",
-    "Geolog",
-    "tarek helmi",
-    "Eris3D",
-    "Max Marklund",
-    "Pronredn",
-    "Jamie Ogletree",
-    "a _",
-    "Jeff",
-    "lh qwe",
-    "James Coleman",
-    "conner",
-    "Kevin Christopher",
-    "Chad Idk",
-    "dd",
-    "Princess Bright Eyes",
-    "Dušan Ryban",
-    "Felipe dos Santos",
-    "Sam",
-    "sjon kreutz",
-    "Douglas Gaspar",
-    "Metryman55",
-    "AlexDuKaNa",
-    "George",
-    "dw",
-    "地獄の禄",
-    "Gamalonia",
-    "WRL_SPR",
-    "capn",
-    "Joseph",
-    "Mirko Katzula",
-    "dan",
-    "Piccio08",
-    "kumakichi",
-    "cppbel",
-    "Moon Knight",
-    "몽타주",
-    "Kland",
-    "Hailshem",
-    "kudari",
-    "Naomi Hale Danchi",
-    "ken",
-    "epicgamer0020690",
-    "Joshua Porrata",
-    "SuBu",
-    "RedPIXel",
-    "Richard",
-    "奚明 刘",
-    "Andrew",
-    "Robert Wegemund",
-    "Littlehuggy",
-    "준희 김",
-    "Brian Buie",
-    "Thought2Form",
-    "Kevin Picco",
-    "Sadlip",
-    "Joey Callahan",
-    "Tomohiro Baba",
-    "m",
-    "Noora",
-    "Pierce McBride",
-    "Joshua Gray",
-    "Mattssn",
-    "Mikko Hemilä",
-    "Jacob McDaniel",
-    "Temikus",
-    "Artokun",
-    "Michael Taylor",
-    "Derek Baker",
-    "Martial",
-    "Michael Anthony Scott",
-    "Emil Andersson",
-    "Ouro Boros",
-    "Atilla Berke Pekduyar",
-    "Steam Steam",
-    "CryptoTraderJK",
-    "Decx _",
-    "Yuji Kaneko",
-    "Davaitamin",
-    "Rops Alot",
-    "tedcor",
-    "Fotek Design",
-    "Ace Ventura",
-    "四糸凜音",
-    "Nihongasuki",
-    "LarsesFPC",
-    "MadSpin",
-    "inbijiburu",
-    "Nick “Loadstone” D",
-    "momokai",
-    "starbugx",
-    "dc7431",
-    "Crocket",
-    "keemun",
-    "Wind",
-    "Nexus",
-    "Ramneek“Guy”Ashok",
-    "squid_actually",
-    "Nat_20",
-    "Edward Weeks",
-    "kyoumei",
-    "RadStorm04",
-    "JohnDoe42054",
-    "BillyHill",
-    "emyth",
-    "chriphost",
-    "KitKatM",
-    "socrasteeze",
-    "OrganicArtifact",
-    "ResidentDeviant",
-    "MudkipMedkitz",
-    "deanbrian",
-    "Alex Wortman",
-    "Cody",
-    "emadsultan",
-    "InformedViewz",
-    "CHKeeho80",
-    "Bubbafett",
-    "leaf",
-    "Vir",
-    "Skyfire83",
-    "Adam Rinehart",
-    "Pitpe11",
-    "TheD1rtyD03",
-    "gzmzmvp",
-    "Gregory Kozhemiak",
-    "Draven T",
-    "mrjuan",
-    "Eric Whitney",
-    "Aquatic Coffee",
-    "Ivan Tadic",
-    "Mike Simone",
-    "John J Linehan",
-    "ethanfel",
-    "Elliot E",
-    "Morgandel",
-    "Theerat Jiramate",
-    "Focuschannel",
-    "Noah",
-    "X",
-    "Sloan Steddy",
-    "hexxish",
-    "Anthony Faxlandez",
-    "battu",
-    "Nathan",
-    "NICHOLAS BAXLEY",
-    "Pat Hen",
-    "Xeeosat",
-    "Saya",
-    "Ed Wang",
-    "Jordan Shaw",
-    "g unit",
-    "Srdb",
-    "JC",
-    "Prompt Pirate",
-    "uwutismxd",
-    "FrxzenSnxw",
-    "zenobeus",
-    "ryoma",
-    "Stryker",
-    "Ginnie",
-    "Raku",
-    "smart.edge5178",
-    "Menard",
-    "moonpetal",
-    "SomeDude",
-    "g9p0o",
-    "Pkrsky",
-    "TheHolySheep",
-    "raf8osz",
-    "Monte Won",
-    "SpringBootisTrash",
-    "carsten",
-    "ikok",
-    "quantenmecha",
-    "Jason+Nash",
-    "DarkRoast",
-    "letzte",
-    "Nasty+Hobbit",
-    "Sora+Yori",
-    "lrdchs2",
-    "Duk3+Rand0m",
-    "Nathen+Choi",
-    "T",
-    "cocona",
-    "ElitaSSJ4",
-    "David Schenck",
-    "Wolfe7D1",
-    "blikkies",
-    "Chris",
-    "Time Valentine",
-    "elleshar666",
-    "Shock Shockor",
-    "ACTUALLY_the_Real_Willem_Dafoe",
-    "Михал Михалыч",
-    "Matt",
-    "Goldwaters",
-    "Kauffy",
-    "Zude",
-    "SPJ",
-    "Kyler",
-    "Edward Kennedy",
-    "Justin Blaylock",
-    "aRtFuL_DodGeR",
-    "Nick Kage",
-    "Vane Holzer",
-    "psytrax",
-    "Cyrus Fett",
-    "Xenon Xue",
-    "notedfakes",
-    "Billy Gladky",
-    "Michael Scott",
-    "Probis",
-    "Solixer",
-    "Wes Sims",
-    "ItsGeneralButtNaked",
-    "Donor4115",
-    "Distortik",
-    "Filippo Ferrari",
-    "Youguang",
-    "andrewzpong",
-    "BossGame",
-    "lrdchs",
-    "Tree Tagger",
-    "Inversity",
-    "AIVORY3D",
-    "Kevinj",
-    "Mitchell Robson",
-    "Whitepinetrader",
-    "POPPIN",
-    "nanana",
-    "D",
-    "Dark_Pest",
-    "Alex",
-    "Karru",
-    "ChaChanoKo",
-    "ghoulars",
-    "null",
-    "Beau",
-    "redcarrot",
-    "powerbot99",
-    "Fthehappy",
-    "g",
-    "J",
-    "Alan+Cano",
-    "FeralOpticsAI",
-    "Pavlaki",
-    "Doug+Rintoul",
-    "Noor",
-    "Yorunai",
-    "BillyBoy84",
-    "Buecyb99",
-    "Welkor",
-    "John Martin",
-    "Ink Temptation",
-    "JBsuede",
-    "moranqianlong",
-    "Kalli Core",
-    "Christian Schäfer",
-    "りん あめ",
-    "Joaquin Hierrezuelo",
-    "Locrospiel",
-    "Frogmilk",
-    "Sean voets",
-    "Kor",
-    "Joseph Hanson",
-    "John Rednoulf",
-    "Kyron Mahan",
-    "Bryan Rutkowski",
-    "TBitz33",
-    "Anonym dkjglfleeoeldldldlkf",
-    "Ezokewn",
-    "SendingRavens",
-    "Steven",
-    "JackJohnnyJim",
-    "TenaciousD",
-    "Dmitry Ryzhov",
-    "Khánh Đặng",
-    "Edward Ten Eyck",
-    "Michael Docherty",
-    "Jimmy Borup",
-    "Paul Hartsuyker",
-    "elitassj",
-    "Pete Pain",
-    "Jacob Winter",
-    "Ryan Presley Ng",
-    "jinksta187",
-    "RHopkirk",
-    "Andrew Wilkinson",
-    "Manu Thetug",
-    "Karlanx",
-    "Lyavph",
-    "Maxim",
-    "David",
-    "Meilo",
-    "operationancut",
-    "shinonomeiro",
-    "Snille",
-    "MaartenAlbers",
-    "khanh duy",
-    "xybrightsummer",
-    "jreedatchison",
-    "PhilW",
-    "Marcus thronico",
-    "Janik",
-    "Cruel",
-    "MRBlack",
-    "Kiyoe",
-    "humptynutz",
-    "michael.isaza",
-    "Kalnei",
-    "Scott",
-    "Muratoraccio",
-    "D",
-    "Mobius2020",
-    "ExLightSaber",
-    "YaboiRay",
-    "nickname",
-    "Sildoren",
-    "Darv",
-    "Seon+Song",
-    "2turbo",
-    "Somebody",
-    "Balut+Omelette",
-    "Dmitry+Viznesenskiy",
-    "tanjin90",
-    "sternenkrieger",
-    "eriick",
-    "Patrick+Bryan",
-    "Pascalou",
-    "lighthawke",
-    "Lev+Lanevskiy",
-    "low9",
-    "Winged",
-    "YassineKhaled",
-    "Y",
-    "MatteKey",
-    "Flob",
-    "ShiroSenpai",
-    "Inkognito",
-    "G",
-    "Tan+Huynh",
-    "Jacky+Ho",
-    "generic404",
-    "abattoirblues",
-    "zounik",
-    "4IXplr0r3r",
-    "hayden",
-    "ahoystan",
-    "Bob Barker",
-    "edk",
-    "Tú Nguyễn Lý Hoàng",
-    "shira1011",
-    "Ben D",
-    "G",
-    "Ronan Delevacq",
-    "ja s",
-    "Leslie Andrew Ridings",
-    "Doug Mason",
-    "Jeremy Townsend",
-    "Dave Abraham",
-    "Owen Gwosdz",
-    "Jarrid Lee",
-    "Poophead27 Blyat",
-    "Spire",
-    "AZ Party Oasis",
-    "Boba Smith",
-    "Devil Lude",
-    "David Murcko",
-    "MR.Bear",
-    "Jack Dole",
-    "matt",
-    "somethingtosay8",
-    "Terminuz",
-    "ivistorm",
-    "max blo",
-    "Sauv",
-    "CptNeo",
-    "Borte",
-    "Maso",
-    "Ted Cart",
-    "Sage Himeros",
-    "Eric Ketchum",
-    "Kevin Wallace",
-    "David Spearing",
-    "ChicRic",
-    "Tigon",
-    "BastardSama",
-    "mercur",
-    "SkibidiRizzler",
-    "Tania Nayelli Fernandez",
-    "Draconach",
-    "Yavizu3d",
-    "Yves Poezevara",
-    "Teriak47",
-    "Just me",
-    "Raf Stahelin",
-    "Nacho Ferrando",
-    "Вячеслав Маринин",
-    "Marcos Tortosa Carmona",
-    "Dkommander22",
-    "Cola Matthew",
-    "OniNoKen",
-    "Iain Wisely",
-    "Zertens",
-    "NOHOW",
-    "Apo",
-    "nekotxt",
-    "choowkee",
-    "Clusters",
-    "ibrahim",
-    "Highlandrise",
-    "philcoraz",
-    "mztn",
-    "ImagineerNL",
-    "MrAcrtosSursus",
-    "al300680",
-    "pixl",
-    "Robin",
-    "chahknoir",
-    "nd",
-    "keno94d",
-    "James Melzer",
-    "Bartleby",
-    "Renvertere",
-    "Rahuy",
-    "Hermann003",
-    "D",
-    "Foolish",
-    "RevyHiep",
-    "Captain_Swag",
-    "obkircher",
-    "gwyar",
-    "ResidentDeviant",
-    "D",
-    "edgecase",
-    "Neoxena",
-    "mrmhalo",
-    "dg",
-    "Maarten Harms",
-    "Israel",
-    "SelfishMedic",
-    "adderleighn",
-    "EnragedAntelope",
-    "shw",
-    "Celestial+Kitten",
-    "bakeliteboy",
-    "TequiTequi",
-    "Homero+Banda",
-    "Nick",
-    "Jim",
-    "Monix",
-    "Trolinka",
-    "IshouI;_;",
-    "PredragR",
-    "Clauzmak",
-    "Nerick",
-    "JoL",
-    "Gold_miner_ego",
-    "SundayRage",
-    "YoruHime",
-    "matter",
-    "SRCRCOSS",
-    "imer",
-    "Akkas+Haque",
-    "Kachac",
-    "tyrant2811",
-    "Kevin",
-    "Rune+Osnes",
-    "jcx29",
-    "cloudghost",
-    "Yongkwan+Lee",
-    "PoorStudent",
-    "lucites",
-    "Alex+Zaw",
-    "Drizzly",
-    "Nebuleux",
-    "Join+Chun",
-    "GDS+DEV",
-    "4rt+r3d",
-    "you+halo9",
-    "Somebody",
-    "Somebody",
-    "Crescent~San",
-    "AiGirlTS",
-    "datasl4ve",
-    "Somebody",
-    "koopa990",
-    "The+Forgetful+Dev",
-    "Mateusz+Kosela",
-    "Bula",
-    "KUJYAKU",
-    "Coeur+de+cochon",
-    "Obsidian.Studios",
-    "han b",
-    "Zomba Mann",
-    "Aquaneo",
-    "Nico",
-    "Maximilian Krischan",
-    "Banana Joe",
-    "proto merp",
-    "_ G3n",
-    "Donovan Jenkins",
-    "Hans Meier",
-    "sicarius",
-    "Michael Eid",
-    "Wolf and Fox Legends",
-    "beersandbacon",
-    "Neko Desco",
-    "Bob barker",
-    "Ninja Tom",
-    "karim ben brik",
-    "Vinarus",
-    "Josh Snyder",
-    "Michael Zhu",
-    "Nemisu",
-    "Seraphy",
-    "雨の心 落",
-    "AllTimeNoobie",
-    "jumpd",
-    "John C",
-    "Rim",
-    "yfx507",
-    "Room Light",
-    "Jairus Knudsen",
-    "Xan Dionysus",
-    "Patryk Serious",
-    "Nathan lee",
-    "lylepaul",
-    "Middo",
-    "Forbidden Atelier",
-    "Thomas Sankowski",
-    "DrB",
-    "Adictedtohumping",
-    "Snorklebort",
-    "vinter",
-    "Towelie",
-    "TheFusion",
-    "Jean-françois SEMA",
-    "3zS4QNQ4",
-    "Kurt",
-    "Matt M.",
-    "Ivan Imes",
-    "J M",
-    "Slacks",
-    "Bouya shaka",
-    "john Greene",
-    "Faburizu",
-    "Jack Lawfield",
-    "jimyjomson",
-    "JaeHyun Jang",
-    "Homero Banda",
-    "Chase Kwon",
-    "Bob Ling",
-    "yyuvuvu",
-    "Inyoshu",
-    "Chad Barnes",
-    "Person Y",
-    "Nomki",
-    "inusanorthcape",
-    "James Ming",
-    "vanditking",
-    "kripitonga",
-    "Rizzi",
-    "nimin",
-    "OMAR LUCIANO",
-    "Somebody",
-    "CoffeeMage",
-    "Ken+Suzuki",
-    "hannibal",
-    "Jo+Example",
-    "BrentBertram",
-    "eumelzocker",
-    "dxjaymz",
-    "L C",
-    "Dude",
-    "Somebody",
-    "CK"
-  ],
-  "totalCount": 826
-}

docs/LM-Extension-Wiki.md

@@ -0,0 +1,180 @@
+## Overview
+
+The **LoRA Manager Civitai Extension** is a Browser extension designed to work seamlessly with [LoRA Manager](https://github.com/willmiao/ComfyUI-Lora-Manager) to significantly enhance your browsing experience on [Civitai](https://civitai.com).
+It also supports browsing on [CivArchive](https://civarchive.com/) (formerly CivitaiArchive).
+
+With this extension, you can:
+
+✅ Instantly see which models are already present in your local library  
+✅ Download new models with a single click  
+✅ Manage downloads efficiently with queue and parallel download support  
+✅ Keep your downloaded models automatically organized according to your custom settings    
+
+![Civitai Models page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-models-page.png)  
+![CivArchive Models page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civarchive-models-page.png)  
+
+---
+
+## Why Are All Features for Supporters Only?
+
+I love building tools for the Stable Diffusion and ComfyUI communities, and LoRA Manager is a passion project that I've poured countless hours into. When I created this companion extension, my hope was to offer its core features for free, as a thank-you to all of you.
+
+Unfortunately, I've reached a point where I need to be realistic. The level of support from the free model has been far lower than what's needed to justify the continuous development and maintenance for both projects. It was a difficult decision, but I've chosen to make the extension's features exclusive to supporters.
+
+This change is crucial for me to be able to continue dedicating my time to improving the free and open-source LoRA Manager, which I'm committed to keeping available for everyone.
+
+Your support does more than just unlock a few features—it allows me to keep innovating and ensures the core LoRA Manager project thrives. I'm incredibly grateful for your understanding and any support you can offer. ❤️
+
+(_For those who previously supported me on Ko-fi with a one-time donation, I'll be sending out license keys individually as a thank-you._)
+
+
+---
+
+## Installation
+
+### Supported Browsers & Installation Methods
+
+| Browser            | Installation Method                                                                 |
+|--------------------|-------------------------------------------------------------------------------------|
+| **Google Chrome**   | [Chrome Web Store link](https://chromewebstore.google.com/detail/capigligggeijgmocnaflanlbghnamgm?utm_source=item-share-cb) |
+| **Microsoft Edge**  | Install via Chrome Web Store (compatible)                                          |
+| **Brave Browser**   | Install via Chrome Web Store (compatible)                                          |
+| **Opera**           | Install via Chrome Web Store (compatible)                                          |
+| **Firefox**         | <div id="firefox-install" class="install-ok"><a href="https://github.com/willmiao/lm-civitai-extension-firefox/releases/latest/download/extension.xpi">📦 Install Firefox Extension (reviewed and verified by Mozilla)</a></div>             |
+
+For non-Chrome browsers (e.g., Microsoft Edge), you can typically install extensions from the Chrome Web Store by following these steps: open the extension’s Chrome Web Store page, click 'Get extension', then click 'Allow' when prompted to enable installations from other stores, and finally click 'Add extension' to complete the installation.
+
+---
+
+## Privacy & Security
+
+I understand concerns around browser extensions and privacy, and I want to be fully transparent about how the **LM Civitai Extension** works:
+
+- **Reviewed and Verified**  
+  This extension has been **manually reviewed and approved by the Chrome Web Store**. The Firefox version uses the **exact same code** (only the packaging format differs) and has passed **Mozilla’s Add-on review**.
+
+- **Minimal Network Access**  
+  The only external server this extension connects to is:  
+  **`https://willmiao.shop`** — used solely for **license validation**.
+
+  It does **not collect, transmit, or store any personal or usage data**.  
+  No browsing history, no user IDs, no analytics, no hidden trackers.
+
+- **Local-Only Model Detection**  
+  Model detection and LoRA Manager communication all happen **locally** within your browser, directly interacting with your local LoRA Manager backend.
+
+I value your trust and are committed to keeping your local setup private and secure. If you have any questions, feel free to reach out!
+
+---
+
+## How to Use
+
+After installing the extension, you'll automatically receive a **7-day trial** to explore all features.
+
+When the extension is correctly installed and your license is valid:
+
+- Open **Civitai**, and you'll see visual indicators added by the extension on model cards, showing:
+  - ✅ Models already present in your local library  
+  - ⬇️ A download button for models not in your library  
+
+Clicking the download button adds the corresponding model version to the download queue, waiting to be downloaded. You can set up to **5 models to download simultaneously**.
+
+### Visual Indicators Appear On:
+
+- **Home Page** — Featured models  
+- **Models Page**  
+- **Creator Profiles** — If the creator has set their models to be visible  
+- **Recommended Resources** — On individual model pages  
+
+### Version Buttons on Model Pages
+
+On a specific model page, visual indicators also appear on version buttons, showing which versions are already in your local library.
+
+When switching to a specific version by clicking a version button:
+
+- Clicking the download button will open a dropdown:
+  - Download via **LoRA Manager**  
+  - Download via **Original Download** (browser download)  
+
+You can check **Remember my choice** to set your preferred default. You can change this setting anytime in the extension's settings.
+
+![Civitai Model Page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-model-page.png)
+
+### Resources on Image Pages (2025-08-05) — now shows in-library indicators for image resources. ‘Import image as recipe’ coming soon!
+
+![Civitai Image Page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-image-page.jpg)
+
+---
+
+## Model Download Location & LoRA Manager Settings
+
+To use the **one-click download function**, you must first set:
+
+- Your **Default LoRAs Root**  
+- Your **Default Checkpoints Root**  
+
+These are set within LoRA Manager's settings.
+
+When everything is configured, downloaded model files will be placed in:  
+
+`<Default_Models_Root>/<Base_Model_of_the_Model>/<First_Tag_of_the_Model>`
+
+
+### Update: Default Path Customization (2025-07-21)  
+
+A new setting to customize the default download path has been added in the nightly version. You can now personalize where models are saved when downloading via the LM Civitai Extension.
+
+![Default Path Customization](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/default-path-customization.png)
+
+The previous YAML path mapping file will be deprecated—settings will now be unified in settings.json to simplify configuration.
+
+---
+
+## Backend Port Configuration
+
+If your **ComfyUI** or **LoRA Manager** backend is running on a port **other than the default 8188**, you must configure the backend port in the extension's settings.
+
+After correctly setting and saving the port, you'll see in the extension's header area:  
+- A **Healthy** status with the tooltip:  `Connected to LoRA Manager on port xxxx`
+
+
+---
+
+## Advanced Usage
+
+### Connecting to a Remote LoRA Manager
+
+If your LoRA Manager is running on another computer, you can still connect from your browser using port forwarding.
+
+> **Why can't you set a remote IP directly?**
+>
+> For privacy and security, the extension only requests access to `http://127.0.0.1/*`. Supporting remote IPs would require much broader permissions, which may be rejected by browser stores and could raise user concerns.
+
+**Solution: Port Forwarding with `socat`**
+
+On your browser computer, run:
+
+`socat TCP-LISTEN:8188,bind=127.0.0.1,fork TCP:REMOTE.IP.ADDRESS.HERE:8188`
+
+- Replace `REMOTE.IP.ADDRESS.HERE` with the IP of the machine running LoRA Manager.
+- Adjust the port if needed.
+
+This lets the extension connect to `127.0.0.1:8188` as usual, with traffic forwarded to your remote server.
+
+_Thanks to user **Temikus** for sharing this solution!_
+
+---
+
+## Roadmap
+
+The extension will evolve alongside **LoRA Manager** improvements. Planned features include:
+
+- [x] Support for **additional model types** (e.g., embeddings)
+- [ ] One-click **Recipe Import**  
+- [x] Display of in-library status for all resources in the **Resources Used** section of the image page  
+- [x] One-click **Auto-organize Models**
+
+**Stay tuned — and thank you for your support!**
+
+---
+

docs/features/recipe-batch-import-requirements.md

@@ -1,170 +0,0 @@
-# Recipe Batch Import Feature Requirements
-
-## Overview
-Enable users to import multiple images as recipes in a single operation, rather than processing them individually. This feature addresses the need for efficient bulk recipe creation from existing image collections.
-
-## User Stories
-
-### US-1: Directory Batch Import
-As a user with a folder of reference images or workflow screenshots, I want to import all images from a directory at once so that I don't have to import them one by one.
-
-**Acceptance Criteria:**
-- User can specify a local directory path containing images
-- System discovers all supported image files in the directory
-- Each image is analyzed for metadata and converted to a recipe
-- Results show which images succeeded, failed, or were skipped
-
-### US-2: URL Batch Import
-As a user with a list of image URLs (e.g., from Civitai or other sources), I want to import multiple images by URL in one operation.
-
-**Acceptance Criteria:**
-- User can provide multiple image URLs (one per line or as a list)
-- System downloads and processes each image
-- URL-specific metadata (like Civitai info) is preserved when available
-- Failed URLs are reported with clear error messages
-
-### US-3: Concurrent Processing Control
-As a user with varying system resources, I want to control how many images are processed simultaneously to balance speed and system load.
-
-**Acceptance Criteria:**
-- User can configure the number of concurrent operations (1-10)
-- System provides sensible defaults based on common hardware configurations
-- Processing respects the concurrency limit to prevent resource exhaustion
-
-### US-4: Import Results Summary
-As a user performing a batch import, I want to see a clear summary of the operation results so I understand what succeeded and what needs attention.
-
-**Acceptance Criteria:**
-- Total count of images processed is displayed
-- Number of successfully imported recipes is shown
-- Number of failed imports with error details is provided
-- Number of skipped images (no metadata) is indicated
-- Results can be exported or saved for reference
-
-### US-5: Progress Visibility
-As a user importing a large batch, I want to see the progress of the operation so I know it's working and can estimate completion time.
-
-**Acceptance Criteria:**
-- Progress indicator shows current status (e.g., "Processing image 5 of 50")
-- Real-time updates as each image completes
-- Ability to view partial results before completion
-- Clear indication when the operation is finished
-
-## Functional Requirements
-
-### FR-1: Image Discovery
-The system shall discover image files in a specified directory recursively or non-recursively based on user preference.
-
-**Supported formats:** JPG, JPEG, PNG, WebP, GIF, BMP
-
-### FR-2: Metadata Extraction
-For each image, the system shall:
-- Extract EXIF metadata if present
-- Parse embedded workflow data (ComfyUI PNG metadata)
-- Fetch external metadata for known URL patterns (e.g., Civitai)
-- Generate recipes from extracted information
-
-### FR-3: Concurrent Processing
-The system shall support concurrent processing of multiple images with:
-- Configurable concurrency limit (default: 3)
-- Resource-aware execution
-- Graceful handling of individual failures without stopping the batch
-
-### FR-4: Error Handling
-The system shall handle various error conditions:
-- Invalid directory paths
-- Inaccessible files
-- Network errors for URL imports
-- Images without extractable metadata
-- Malformed or corrupted image files
-
-### FR-5: Recipe Persistence
-Successfully analyzed images shall be persisted as recipes with:
-- Extracted generation parameters
-- Preview image association
-- Tags and metadata
-- Source information (file path or URL)
-
-## Non-Functional Requirements
-
-### NFR-1: Performance
-- Batch operations should complete in reasonable time (< 5 seconds per image on average)
-- UI should remain responsive during batch operations
-- Memory usage should scale gracefully with batch size
-
-### NFR-2: Scalability
-- Support batches of 1-1000 images
-- Handle mixed success/failure scenarios gracefully
-- No hard limits on concurrent operations (configurable)
-
-### NFR-3: Usability
-- Clear error messages for common failure cases
-- Intuitive UI for configuring import options
-- Accessible from the main Recipes interface
-
-### NFR-4: Reliability
-- Failed individual imports should not crash the entire batch
-- Partial results should be preserved on unexpected termination
-- All operations should be idempotent (re-importing same image doesn't create duplicates)
-
-## API Requirements
-
-### Batch Import Endpoints
-The system should expose endpoints for:
-
-1. **Directory Import**
-   - Accept directory path and configuration options
-   - Return operation ID for status tracking
-   - Async or sync operation support
-
-2. **URL Import**
-   - Accept list of URLs and configuration options
-   - Support URL validation before processing
-   - Return operation ID for status tracking
-
-3. **Status/Progress**
-   - Query operation status by ID
-   - Get current progress and partial results
-   - Retrieve final results after completion
-
-## UI/UX Requirements
-
-### UIR-1: Entry Point
-Batch import should be accessible from the Recipes page via a clearly labeled button in the toolbar.
-
-### UIR-2: Import Modal
-A modal dialog should provide:
-- Tab or section for Directory import
-- Tab or section for URL import
-- Configuration options (concurrency, options)
-- Start/Stop controls
-- Results display area
-
-### UIR-3: Results Display
-Results should be presented with:
-- Summary statistics (total, success, failed, skipped)
-- Expandable details for each category
-- Export or copy functionality for results
-- Clear visual distinction between success/failure/skip
-
-## Future Considerations
-
-- **Scheduled Imports**: Ability to schedule batch imports for later execution
-- **Import Templates**: Save import configurations for reuse
-- **Cloud Storage**: Import from cloud storage services (Google Drive, Dropbox)
-- **Duplicate Detection**: Advanced duplicate detection based on image hash
-- **Tag Suggestions**: AI-powered tag suggestions for imported recipes
-- **Batch Editing**: Apply tags or organization to multiple imported recipes at once
-
-## Dependencies
-
-- Recipe analysis service (metadata extraction)
-- Recipe persistence service (storage)
-- Image download capability (for URL imports)
-- Recipe scanner (for refresh after import)
-- Civitai client (for enhanced URL metadata)
-
----
-
-*Document Version: 1.0*
-*Status: Requirements Definition*

docs/metadata-json-schema.md

@@ -1,363 +0,0 @@
-# metadata.json Schema Documentation
-
-This document defines the complete schema for `.metadata.json` files used by Lora Manager. These sidecar files store model metadata alongside model files (LoRA, Checkpoint, Embedding).
-
-## Overview
-
-- **File naming**: `<model_name>.metadata.json` (e.g., `my_lora.safetensors` → `my_lora.metadata.json`)
-- **Format**: JSON with UTF-8 encoding
-- **Purpose**: Store model metadata, tags, descriptions, preview images, and Civitai/CivArchive integration data
-- **Extensibility**: Unknown fields are preserved via `_unknown_fields` mechanism for forward compatibility
-
----
-
-## Base Fields (All Model Types)
-
-These fields are present in all model metadata files.
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `file_name` | string | ✅ Yes | ✅ Yes | Filename without extension (e.g., `"my_lora"`) |
-| `model_name` | string | ✅ Yes | ❌ No | Display name of the model. **Default**: `file_name` if no other source |
-| `file_path` | string | ✅ Yes | ✅ Yes | Full absolute path to the model file (normalized with `/` separators) |
-| `size` | integer | ✅ Yes | ❌ No | File size in bytes. **Set at**: Initial scan or download completion. Does not change thereafter. |
-| `modified` | float | ✅ Yes | ❌ No | **Import timestamp** — Unix timestamp when the model was first imported/added to the system. Used for "Date Added" sorting. Does not change after initial creation. |
-| `sha256` | string | ⚠️ Conditional | ✅ Yes | SHA256 hash of the model file (lowercase). **LoRA**: Required. **Checkpoint**: May be empty when `hash_status="pending"` (lazy hash calculation) |
-| `base_model` | string | ❌ No | ❌ No | Base model type. **Examples**: `"SD 1.5"`, `"SDXL 1.0"`, `"SDXL Lightning"`, `"Flux.1 D"`, `"Flux.1 S"`, `"Flux.1 Krea"`, `"Illustrious"`, `"Pony"`, `"AuraFlow"`, `"Kolors"`, `"ZImageTurbo"`, `"Wan Video"`, etc. **Default**: `"Unknown"` or `""` |
-| `preview_url` | string | ❌ No | ✅ Yes | Path to preview image file |
-| `preview_nsfw_level` | integer | ❌ No | ❌ No | NSFW level using **bitmask values** from Civitai: `1` (PG), `2` (PG13), `4` (R), `8` (X), `16` (XXX), `32` (Blocked). **Default**: `0` (none) |
-| `notes` | string | ❌ No | ❌ No | User-defined notes |
-| `from_civitai` | boolean | ❌ No (default: `true`) | ❌ No | Whether the model originated from Civitai |
-| `civitai` | object | ❌ No | ⚠️ Partial | Civitai/CivArchive API data and user-defined fields |
-| `tags` | array[string] | ❌ No | ⚠️ Partial | Model tags (merged from API and user input) |
-| `modelDescription` | string | ❌ No | ⚠️ Partial | Full model description (from API or user) |
-| `civitai_deleted` | boolean | ❌ No (default: `false`) | ❌ No | Whether the model was deleted from Civitai |
-| `favorite` | boolean | ❌ No (default: `false`) | ❌ No | Whether the model is marked as favorite |
-| `exclude` | boolean | ❌ No (default: `false`) | ❌ No | Whether to exclude from cache/scanning. User can set from `false` to `true` (currently no UI to revert) |
-| `db_checked` | boolean | ❌ No (default: `false`) | ❌ No | Whether checked against archive database |
-| `skip_metadata_refresh` | boolean | ❌ No (default: `false`) | ❌ No | Skip this model during bulk metadata refresh |
-| `metadata_source` | string\|null | ❌ No | ✅ Yes | Last provider that supplied metadata (see below) |
-| `last_checked_at` | float | ❌ No (default: `0`) | ✅ Yes | Unix timestamp of last metadata check |
-| `hash_status` | string | ❌ No (default: `"completed"`) | ✅ Yes | Hash calculation status: `"pending"`, `"calculating"`, `"completed"`, `"failed"` |
-
----
-
-## Model-Specific Fields
-
-### LoRA Models
-
-LoRA models do not have a `model_type` field in metadata.json. The type is inferred from context or `civitai.type` (e.g., `"LoRA"`, `"LoCon"`, `"DoRA"`).
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `usage_tips` | string (JSON) | ❌ No (default: `"{}"`) | ❌ No | JSON string containing recommended usage parameters |
-
-**`usage_tips` JSON structure:**
-
-```json
-{
-  "strength_min": 0.3,
-  "strength_max": 0.8,
-  "strength_range": "0.3-0.8",
-  "strength": 0.6,
-  "clip_strength": 0.5,
-  "clip_skip": 2
-}
-```
-
-| Key | Type | Description |
-|-----|------|-------------|
-| `strength_min` | number | Minimum recommended model strength |
-| `strength_max` | number | Maximum recommended model strength |
-| `strength_range` | string | Human-readable strength range |
-| `strength` | number | Single recommended strength value |
-| `clip_strength` | number | Recommended CLIP/embedding strength |
-| `clip_skip` | integer | Recommended CLIP skip value |
-
----
-
-### Checkpoint Models
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `model_type` | string | ❌ No (default: `"checkpoint"`) | ❌ No | Model type: `"checkpoint"`, `"diffusion_model"` |
-
----
-
-### Embedding Models
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `model_type` | string | ❌ No (default: `"embedding"`) | ❌ No | Model type: `"embedding"` |
-
----
-
-## The `civitai` Field Structure
-
-The `civitai` object stores the complete Civitai/CivArchive API response. Lora Manager preserves all fields from the API for future compatibility and extracts specific fields for use in the application.
-
-### Version-Level Fields (Civitai API)
-
-**Fields Used by Lora Manager:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `id` | integer | Version ID |
-| `modelId` | integer | Parent model ID |
-| `name` | string | Version name (e.g., `"v1.0"`, `"v2.0-pruned"`) |
-| `nsfwLevel` | integer | NSFW level (bitmask: 1=PG, 2=PG13, 4=R, 8=X, 16=XXX, 32=Blocked) |
-| `baseModel` | string | Base model (e.g., `"SDXL 1.0"`, `"Flux.1 D"`, `"Illustrious"`, `"Pony"`) |
-| `trainedWords` | array[string] | **Trigger words** for the model |
-| `type` | string | Model type (`"LoRA"`, `"Checkpoint"`, `"TextualInversion"`) |
-| `earlyAccessEndsAt` | string\|null | Early access end date (used for update notifications) |
-| `description` | string | Version description (HTML) |
-| `model` | object | Parent model object (see Model-Level Fields below) |
-| `creator` | object | Creator information (see Creator Fields below) |
-| `files` | array[object] | File list with hashes, sizes, download URLs (used for metadata extraction) |
-| `images` | array[object] | Image list with metadata, prompts, NSFW levels (used for preview/examples) |
-
-**Fields Stored but Not Currently Used:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `createdAt` | string (ISO 8601) | Creation timestamp |
-| `updatedAt` | string (ISO 8601) | Last update timestamp |
-| `status` | string | Version status (e.g., `"Published"`, `"Draft"`) |
-| `publishedAt` | string (ISO 8601) | Publication timestamp |
-| `baseModelType` | string | Base model type (e.g., `"Standard"`, `"Inpaint"`, `"Refiner"`) |
-| `earlyAccessConfig` | object | Early access configuration |
-| `uploadType` | string | Upload type (`"Created"`, `"FineTuned"`, etc.) |
-| `usageControl` | string | Usage control setting |
-| `air` | string | Artifact ID (URN format: `urn:air:sdxl:lora:civitai:122359@135867`) |
-| `stats` | object | Download count, ratings, thumbs up count |
-| `videos` | array[object] | Video list |
-| `downloadUrl` | string | Direct download URL |
-| `trainingStatus` | string\|null | Training status (for on-site training) |
-| `trainingDetails` | object\|null | Training configuration |
-
-### Model-Level Fields (`civitai.model.*`)
-
-**Fields Used by Lora Manager:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `name` | string | Model name |
-| `type` | string | Model type (`"LoRA"`, `"Checkpoint"`, `"TextualInversion"`) |
-| `description` | string | Model description (HTML, used for `modelDescription`) |
-| `tags` | array[string] | Model tags (used for `tags` field) |
-| `allowNoCredit` | boolean | License: allow use without credit |
-| `allowCommercialUse` | array[string] | License: allowed commercial uses. **Values**: `"Image"` (sell generated images), `"Video"` (sell generated videos), `"RentCivit"` (rent on Civitai), `"Rent"` (rent elsewhere) |
-| `allowDerivatives` | boolean | License: allow derivatives |
-| `allowDifferentLicense` | boolean | License: allow different license |
-
-**Fields Stored but Not Currently Used:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `nsfw` | boolean | Model NSFW flag |
-| `poi` | boolean | Person of Interest flag |
-
-### Creator Fields (`civitai.creator.*`)
-
-Both fields are used by Lora Manager:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `username` | string | Creator username (used for author display and search) |
-| `image` | string | Creator avatar URL (used for display) |
-
-### Model Type Field (Top-Level, Outside `civitai`)
-
-| Field | Type | Values | Description |
-|-------|------|--------|-------------|
-| `model_type` | string | `"checkpoint"`, `"diffusion_model"`, `"embedding"` | Stored in metadata.json for Checkpoint and Embedding models. **Note**: LoRA models do not have this field; type is inferred from `civitai.type` or context. |
-
-### User-Defined Fields (Within `civitai`)
-
-For models not from Civitai or user-added data:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `trainedWords` | array[string] | **Trigger words** — manually added by user |
-| `customImages` | array[object] | Custom example images added by user |
-
-### customImages Structure
-
-Each custom image entry has the following structure:
-
-```json
-{
-  "url": "",
-  "id": "short_id",
-  "nsfwLevel": 0,
-  "width": 832,
-  "height": 1216,
-  "type": "image",
-  "meta": {
-    "prompt": "...",
-    "negativePrompt": "...",
-    "steps": 20,
-    "cfgScale": 7,
-    "seed": 123456
-  },
-  "hasMeta": true,
-  "hasPositivePrompt": true
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `url` | string | Empty for local custom images |
-| `id` | string | Short ID or filename |
-| `nsfwLevel` | integer | NSFW level (bitmask) |
-| `width` | integer | Image width in pixels |
-| `height` | integer | Image height in pixels |
-| `type` | string | `"image"` or `"video"` |
-| `meta` | object\|null | Generation metadata (prompt, seed, etc.) extracted from image |
-| `hasMeta` | boolean | Whether metadata is available |
-| `hasPositivePrompt` | boolean | Whether a positive prompt is available |
-
-### Minimal Non-Civitai Example
-
-```json
-{
-  "civitai": {
-    "trainedWords": ["my_trigger_word"]
-  }
-}
-```
-
-### Non-Civitai Example Without Trigger Words
-
-```json
-{
-  "civitai": {}
-}
-```
-
-### Example: User-Added Custom Images
-
-```json
-{
-  "civitai": {
-    "trainedWords": ["custom_style"],
-    "customImages": [
-      {
-        "url": "",
-        "id": "example_1",
-        "nsfwLevel": 0,
-        "width": 832,
-        "height": 1216,
-        "type": "image",
-        "meta": {
-          "prompt": "example prompt",
-          "seed": 12345
-        },
-        "hasMeta": true,
-        "hasPositivePrompt": true
-      }
-    ]
-  }
-}
-```
-
----
-
-## Metadata Source Values
-
-The `metadata_source` field indicates which provider last updated the metadata:
-
-| Value | Source |
-|-------|--------|
-| `"civitai_api"` | Civitai API |
-| `"civarchive"` | CivArchive API |
-| `"archive_db"` | Metadata Archive Database |
-| `null` | No external source (user-defined only) |
-
----
-
-## Auto-Update Behavior
-
-### Fields Updated During Scanning
-
-These fields are automatically synchronized with the filesystem:
-
-- `file_name` — Updated if actual filename differs
-- `file_path` — Normalized and updated if path changes
-- `preview_url` — Updated if preview file is moved/removed
-- `sha256` — Updated during hash calculation (when `hash_status="pending"`)
-- `hash_status` — Updated during hash calculation
-- `last_checked_at` — Timestamp of scan
-- `metadata_source` — Set based on metadata provider
-
-### Fields Set Once (Immutable After Import)
-
-These fields are set when the model is first imported/scanned and **never change** thereafter:
-
-- `modified` — Import timestamp (used for "Date Added" sorting)
-- `size` — File size at time of import/download
-
-### User-Editable Fields
-
-These fields can be edited by users at any time through the Lora Manager UI or by manually editing the metadata.json file:
-
-- `model_name` — Display name
-- `tags` — Model tags
-- `modelDescription` — Model description
-- `notes` — User notes
-- `favorite` — Favorite flag
-- `exclude` — Exclude from scanning (user can set `false`→`true`, currently no UI to revert)
-- `skip_metadata_refresh` — Skip during bulk refresh
-- `civitai.trainedWords` — Trigger words
-- `civitai.customImages` — Custom example images
-- `usage_tips` — Usage recommendations (LoRA only)
-
----
-
-
-## Field Reference by Behavior
-
-### Required Fields (Must Always Exist)
-
-- `file_name`
-- `model_name` (defaults to `file_name` if not provided)
-- `file_path`
-- `size`
-- `modified`
-- `sha256` (LoRA: always required; Checkpoint: may be empty when `hash_status="pending"`)
-
-### Optional Fields with Defaults
-
-| Field | Default |
-|-------|---------|
-| `base_model` | `"Unknown"` or `""` |
-| `preview_nsfw_level` | `0` |
-| `from_civitai` | `true` |
-| `civitai` | `{}` |
-| `tags` | `[]` |
-| `modelDescription` | `""` |
-| `notes` | `""` |
-| `civitai_deleted` | `false` |
-| `favorite` | `false` |
-| `exclude` | `false` |
-| `db_checked` | `false` |
-| `skip_metadata_refresh` | `false` |
-| `metadata_source` | `null` |
-| `last_checked_at` | `0` |
-| `hash_status` | `"completed"` |
-| `usage_tips` | `"{}"` (LoRA only) |
-| `model_type` | `"checkpoint"` or `"embedding"` (not present in LoRA models) |
-
----
-
-## Version History
-
-| Version | Date | Changes |
-|---------|------|---------|
-| 1.0 | 2026-03 | Initial schema documentation |
-
----
-
-## See Also
-
-- [JSON Schema Definition](../.specs/metadata.schema.json) — Formal JSON Schema for validation

docs/plan/model-modal-redesign.md

@@ -0,0 +1,449 @@
+# Model Modal UI/UX 重构计划
+
+> **Status**: Phase 1 Complete ✓  
+> **Created**: 2026-02-06  
+> **Target**: v2.x Release
+
+---
+
+## 1. 项目概述
+
+### 1.1 背景与问题
+
+当前 Model Modal 存在以下 UX 问题：
+
+1. **空间利用率低** - 固定 800px 宽度，大屏环境下大量留白
+2. **Tab 切换繁琐** - 4 个 Tab（Examples/Description/Versions/Recipes）隐藏了重要信息
+3. **Examples 浏览不便** - 需持续向下滚动，无快速导航
+4. **添加自定义示例困难** - 需滚动到底部，操作路径长
+
+### 1.2 设计目标
+
+- **空间效率**: 利用 header 以下、sidebar 右侧的全部可用空间
+- **浏览体验**: 类似 Midjourney 的沉浸式图片浏览
+- **信息架构**: 关键元数据固定可见，次要信息可折叠
+- **操作效率**: 直觉化的键盘导航，减少点击次数
+
+---
+
+## 2. 设计方案
+
+### 2.1 布局架构: Split-View Overlay
+
+```
+┌──────────────────────────────────────────────────────────────────────┐
+│  HEADER (保持现有)                                                    │
+├──────────┬───────────────────────────────────────────────────────────┤
+│          │  ┌───────────────────────────┬────────────────────────┐   │
+│ FOLDER   │  │                           │  MODEL HEADER          │   │
+│ SIDEBAR  │  │      EXAMPLES SHOWCASE    │  ├─ Name               │   │
+│ (可折叠)  │  │                           │  ├─ Creator + Actions  │   │
+│          │  │   ┌─────────────────┐     │  ├─ Tags               │   │
+│          │  │   │                 │     ├────────────────────────┤   │
+│          │  │   │   MAIN IMAGE    │     │  COMPACT METADATA      │   │
+│          │  │   │   (自适应高度)   │     │  ├─ Ver | Base | Size  │   │
+│          │  │   │                 │     │  ├─ Location           │   │
+│          │  │   └─────────────────┘     │  ├─ Usage Tips         │   │
+│          │  │                           │  ├─ Trigger Words      │   │
+│          │  │   [PARAMS PREVIEW]        │  ├─ Notes              │   │
+│          │  │   (Prompt + Copy)         ├────────────────────────┤   │
+│          │  │                           │  CONTENT TABS          │   │
+│          │  │   ┌─────────────────┐     │  [Desc][Versions][Rec] │   │
+│          │  │   │  THUMBNAIL RAIL │     │                        │   │
+│          │  │   │  [1][2][3][4][+]│     │  TAB CONTENT AREA      │   │
+│          │  │   └─────────────────┘     │  (Accordion / List)    │   │
+│          │  └───────────────────────────┴────────────────────────┘   │
+└──────────┴───────────────────────────────────────────────────────────┘
+```
+
+**尺寸规格**:
+- Sidebar 展开: Left 60% | Right 40%
+- Sidebar 折叠: Left 65% | Right 35%
+- 最小宽度: 1200px (低于此值触发移动端适配)
+
+### 2.2 左侧: Examples Showcase
+
+#### 2.2.1 组件结构
+
+| 组件 | 描述 | 优先级 |
+|------|------|--------|
+| Main Image | 自适应容器，保持原始比例，最大高度 70vh | P0 |
+| Params Panel | 底部滑出面板，显示 Prompt/Negative/Params | P0 |
+| Thumbnail Rail | 底部横向滚动条，支持点击跳转 | P0 |
+| Add Button | Rail 最右侧 "+" 按钮，打开上传区 | P0 |
+| Nav Arrows | 图片左右两侧悬停显示 | P1 |
+
+#### 2.2.2 图片悬停操作
+
+```
+┌─────────────────┐
+│ [👁] [📌] [🗑] │  ← 查看参数 | 设为预览 | 删除
+│                 │
+│     IMAGE       │
+│                 │
+└─────────────────┘
+```
+
+#### 2.2.3 键盘导航
+
+| 按键 | 功能 | 说明 |
+|------|------|------|
+| ← | 上一个 Example | 循环（首张时到最后一张） |
+| → | 下一个 Example | 循环（末张时到第一张） |
+| I | Toggle Params Panel | 显示/隐藏图片参数 |
+| C | Copy Prompt | 复制当前 Prompt 到剪贴板 |
+
+### 2.3 右侧: Metadata + Content
+
+#### 2.3.1 固定头部 (不可折叠)
+
+```
+┌────────────────────────┐
+│ MODEL NAME        [×]  │
+│ [👤 Creator] [🌐 Civ]  │
+│ [tag1] [tag2] [tag3]   │
+├────────────────────────┤
+│ Ver: v1.0  Size: 96MB  │
+│ Base: SDXL             │
+│ 📁 /path/to/file       │
+├────────────────────────┤
+│ USAGE TIPS        [✏️] │
+│ [strength: 0.8] [+]    │
+├────────────────────────┤
+│ TRIGGER WORDS     [✏️] │
+│ [word1] [word2]  [📋]  │
+├────────────────────────┤
+│ NOTES             [✏️] │
+│ "Add your notes..."    │
+└────────────────────────┘
+```
+
+#### 2.3.2 Tabs 设计
+
+保留横向 Tab 切换，但优化内容展示：
+
+| Tab | 内容 | 交互方式 |
+|-----|------|----------|
+| Description | About this version + Model Description | Accordion 折叠 |
+| Versions | 版本列表卡片 | 完整列表视图 |
+| Recipes | Recipe 卡片网格 | 网格布局 |
+
+**Accordion 行为**:
+- 手风琴模式：同时只能展开一个 section
+- 默认：About this version 展开，Description 折叠
+- 动画：300ms ease-out
+
+### 2.4 全局导航
+
+#### 2.4.1 Model 切换
+
+| 按键 | 功能 |
+|------|------|
+| ↑ | 上一个 Model |
+| ↓ | 下一个 Model |
+
+**切换动画**:
+1. 当前 Modal 淡出 (150ms)
+2. 加载新 Model 数据
+3. 新 Modal 淡入 (150ms)
+4. 保持当前 Tab 状态（不重置到默认）
+
+#### 2.4.2 首次使用提示
+
+Modal 首次打开时，顶部显示提示条：
+```
+┌─────────────────────────────────────────────────────────────┐
+│  💡 Tip: ↑↓ 切换模型 | ←→ 浏览示例 | I 查看参数 | ESC 关闭   │
+└─────────────────────────────────────────────────────────────┘
+```
+- 3 秒后自动淡出
+- 提供 "不再显示" 选项
+
+---
+
+## 3. 技术实现
+
+### 3.1 文件结构变更
+
+```
+static/
+├── js/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── index.js           # 主入口
+│           ├── ModelModal.js      # Modal 容器
+│           ├── ExampleShowcase.js # 左侧展示
+│           ├── ThumbnailRail.js   # 缩略图导航
+│           ├── MetadataPanel.js   # 右侧元数据
+│           ├── ContentTabs.js     # Tabs 容器
+│           └── accordions/        # Accordion 组件
+│               ├── DescriptionAccordion.js
+│               └── VersionsList.js
+├── css/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── modal-overlay.css
+│           ├── showcase.css
+│           ├── thumbnail-rail.css
+│           ├── metadata.css
+│           └── tabs.css
+```
+
+### 3.2 核心 CSS 架构
+
+```css
+/* modal-overlay.css */
+.model-overlay {
+  position: fixed;
+  top: var(--header-height);
+  left: var(--sidebar-width, 250px);
+  right: 0;
+  bottom: 0;
+  z-index: var(--z-modal);
+  
+  display: grid;
+  grid-template-columns: 1.2fr 0.8fr;
+  gap: 0;
+  
+  background: var(--bg-color);
+  animation: modalSlideIn 0.2s ease-out;
+}
+
+.model-overlay.sidebar-collapsed {
+  left: var(--sidebar-collapsed-width, 60px);
+  grid-template-columns: 1.3fr 0.7fr;
+}
+
+/* 移动端适配 */
+@media (max-width: 768px) {
+  .model-overlay {
+    left: 0;
+    grid-template-columns: 1fr;
+    grid-template-rows: auto 1fr;
+  }
+}
+```
+
+### 3.3 响应式断点
+
+| 断点 | 布局 | 说明 |
+|------|------|------|
+| > 1400px | Split 60/40 | 大屏优化 |
+| 1200-1400px | Split 50/50 | 标准桌面 |
+| 768-1200px | Split 50/50 | 小屏桌面/平板 |
+| < 768px | Stack | 移动端：Examples 在上，Metadata 在下 |
+
+---
+
+## 4. 实施阶段
+
+### Phase 1: 核心重构 (预计 2-3 周)
+
+**目标**: MVP 可用，基础功能完整
+
+**任务清单**:
+
+- [ ] 创建新的文件结构和基础组件
+- [ ] 实现 Split-View Overlay 布局
+  - [ ] CSS Grid 布局系统
+  - [ ] Sidebar 状态联动
+  - [ ] 响应式断点处理
+- [ ] 迁移左侧 Examples 区域
+  - [ ] Main Image 自适应容器
+  - [ ] Thumbnail Rail 组件
+  - [ ] Params Panel 滑出动画
+- [ ] 实现新的快捷键系统
+  - [ ] ↑↓ 切换 Model
+  - [ ] ←→ 切换 Example
+  - [ ] I/C/ESC 功能键
+- [ ] 移除旧 Modal 的 max-width 限制
+- [ ] 基础动画过渡
+
+**验收标准**:
+- [ ] 新布局在各种屏幕尺寸下正常显示
+- [ ] 键盘导航正常工作
+- [ ] 无阻塞性 Bug
+
+---
+
+### Phase 2: 体验优化 (预计 1-2 周)
+
+**目标**: 信息架构优化，交互细节完善
+
+**任务清单**:
+
+- [ ] Accordion 组件实现
+  - [ ] Description Tab 的折叠面板
+  - [ ] 手风琴交互逻辑
+  - [ ] 动画优化
+- [ ] 右侧 Metadata 区域固定化
+  - [ ] 滚动行为优化
+  - [ ] 编辑功能迁移
+- [ ] Example 添加流程优化
+  - [ ] Rail 上的 "+" 按钮
+  - [ ] Inline Upload Area
+  - [ ] 拖拽上传支持
+- [ ] Model 切换动画优化
+  - [ ] 淡入淡出效果
+  - [ ] 加载状态指示
+- [ ] 首次使用提示
+
+**验收标准**:
+- [ ] Accordion 交互流畅
+- [ ] 添加 Example 操作路径 < 2 步
+- [ ] Model 切换视觉反馈清晰
+
+---
+
+### Phase 3: 功能完整化 (预计 1-2 周)
+
+**目标**: 所有现有功能迁移完成
+
+**任务清单**:
+
+- [ ] Versions Tab 完整实现
+  - [ ] 版本列表卡片
+  - [ ] 下载/忽略/删除操作
+  - [ ] 更新状态 Badge
+- [ ] Recipes Tab 完整实现
+  - [ ] Recipe 卡片网格
+  - [ ] 复制/应用操作
+- [ ] Tab 状态保持
+  - [ ] 切换 Model 时保持当前 Tab
+  - [ ] Tab 内容滚动位置记忆
+- [ ] 所有编辑功能迁移
+  - [ ] Model Name 编辑
+  - [ ] Base Model 编辑
+  - [ ] File Name 编辑
+  - [ ] Tags 编辑
+  - [ ] Usage Tips 编辑
+  - [ ] Notes 编辑
+
+**验收标准**:
+- [ ] 所有现有功能可用
+- [ ] 单元测试覆盖率 > 80%
+
+---
+
+### Phase 4: 打磨与优化 (预计 1 周)
+
+**目标**: 性能优化，边缘 case 处理
+
+**任务清单**:
+
+- [ ] 移动端适配完善
+  - [ ] Stack 布局优化
+  - [ ] 触摸手势支持（滑动切换）
+- [ ] 性能优化
+  - [ ] 图片懒加载优化
+  - [ ] 虚拟滚动（大量 Examples 时）
+  - [ ] 减少重渲染
+- [ ] 无障碍支持
+  - [ ] ARIA 标签
+  - [ ] 键盘导航焦点管理
+  - [ ] 屏幕阅读器测试
+- [ ] 动画性能优化
+  - [ ] will-change 优化
+  - [ ] 减少 layout thrashing
+
+**验收标准**:
+- [ ] Lighthouse Performance > 90
+- [ ] 无障碍检查无严重问题
+
+---
+
+### Phase 5: 发布准备 (预计 3-5 天)
+
+**目标**: 稳定版本，文档完整
+
+**任务清单**:
+
+- [ ] Bug 修复
+- [ ] 用户测试
+- [ ] 更新文档
+  - [ ] README 更新
+  - [ ] 快捷键说明
+  - [ ] 截图/GIF 演示
+- [ ] 发布说明
+
+---
+
+## 5. 风险与应对
+
+| 风险 | 影响 | 应对策略 |
+|------|------|----------|
+| 用户不适应新布局 | 中 | 提供设置选项，允许切换回旧版（临时） |
+| 性能问题（大量 Examples） | 高 | Phase 4 重点优化，必要时虚拟滚动 |
+| 移动端体验不佳 | 中 | 单独设计移动端布局，非简单缩放 |
+| 与现有扩展冲突 | 低 | 充分的回归测试 |
+
+---
+
+## 6. 关联文件
+
+### 6.1 需修改的现有文件
+
+```
+static/js/components/shared/ModelModal.js      # 完全重构
+static/js/components/shared/showcase/          # 迁移至新目录
+static/css/components/lora-modal/              # 样式重写
+static/css/components/modal/_base.css          # Overlay 样式调整
+```
+
+### 6.2 参考资源
+
+- [Midjourney Explore](https://www.midjourney.com/explore) - 交互参考
+- [Pinterest Pin View](https://www.pinterest.com) - 布局参考
+- [AGENTS.md](/AGENTS.md) - 项目代码规范
+
+---
+
+## 7. Checklist
+
+### 7.1 启动前
+
+- [ ] 创建 feature branch: `feature/model-modal-redesign`
+- [ ] 设置开发环境
+- [ ] 准备测试数据集（多种 Model 类型）
+
+### 7.2 每个 Phase 完成时
+
+- [ ] 代码审查
+- [ ] 功能测试
+- [ ] 更新本文档状态
+
+### 7.3 发布前
+
+- [ ] 完整回归测试
+- [ ] 更新 CHANGELOG
+- [ ] 更新版本号
+
+---
+
+## 8. 附录
+
+### 8.1 命名规范
+
+| 类型 | 规范 | 示例 |
+|------|------|------|
+| 文件 | kebab-case | `thumbnail-rail.js` |
+| 组件 | PascalCase | `ThumbnailRail` |
+| CSS 类 | BEM | `.thumbnail-rail__item--active` |
+| 变量 | camelCase | `currentExampleIndex` |
+
+### 8.2 颜色规范
+
+使用现有 CSS 变量，不引入新颜色：
+
+```css
+--lora-accent: #4299e1;
+--lora-accent-l: 60%;
+--lora-accent-c: 0.2;
+--lora-accent-h: 250;
+--lora-surface: var(--card-bg);
+--lora-border: var(--border-color);
+```
+
+---
+
+*Last Updated: 2026-02-06*

docs/testing/backend-testing-improvement-plan.md

@@ -1,678 +0,0 @@
-# Backend Testing Improvement Plan
-
-**Status:** Phase 4 Complete ✅  
-**Created:** 2026-02-11  
-**Updated:** 2026-02-11  
-**Priority:** P0 - Critical
-
----
-
-## Executive Summary
-
-This document outlines a comprehensive plan to improve the quality, coverage, and maintainability of the LoRa Manager backend test suite. Recent critical bugs (_handle_download_task_done and get_status methods missing) were not caught by existing tests, highlighting significant gaps in the testing strategy.
-
-## Current State Assessment
-
-### Test Statistics
-- **Total Python Test Files:** 80+
-- **Total JavaScript Test Files:** 29
-- **Test Lines of Code:** ~15,000
-- **Current Pass Rate:** 100% (but missing critical edge cases)
-
-### Key Findings
-1. **Coverage Gaps:** Critical modules have no direct tests
-2. **Mocking Issues:** Over-mocking hides real bugs
-3. **Integration Deficit:** Missing end-to-end tests
-4. **Async Inconsistency:** Multiple patterns for async tests
-5. **Maintenance Burden:** Large, complex test files with duplication
-
----
-
-## Phase 2 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Integration Test Framework** ✅
-   - Created `tests/integration/` directory structure
-   - Added `tests/integration/conftest.py` with shared fixtures
-   - Added `tests/integration/__init__.py` for package organization
-
-2. **Download Flow Integration Tests** ✅
-   - Created `tests/integration/test_download_flow.py` with 7 tests
-   - Tests cover:
-     - Download with mocked network (2 tests)
-     - Progress broadcast verification (1 test)
-     - Error handling (1 test)
-     - Cancellation flow (1 test)
-     - Concurrent download management (1 test)
-     - Route endpoint validation (1 test)
-
-3. **Recipe Flow Integration Tests** ✅
-   - Created `tests/integration/test_recipe_flow.py` with 9 tests
-   - Tests cover:
-     - Recipe save and retrieve flow (1 test)
-     - Recipe update flow (1 test)
-     - Recipe delete flow (1 test)
-     - Recipe model extraction (1 test)
-     - Generation parameters handling (1 test)
-     - Concurrent recipe reads (1 test)
-     - Concurrent read/write operations (1 test)
-     - Recipe list endpoint (1 test)
-     - Recipe metadata parsing (1 test)
-
-4. **ModelLifecycleService Coverage** ✅
-   - Added 12 new tests to `tests/services/test_model_lifecycle_service.py`
-   - Tests cover:
-     - `exclude_model` functionality (3 tests)
-     - `bulk_delete_models` functionality (2 tests)
-     - Error path tests (5 tests)
-     - `_extract_model_id_from_payload` utility (3 tests)
-   - Total: 18 tests (up from 6)
-
-5. **PersistentRecipeCache Concurrent Access** ✅
-   - Added 5 new concurrent access tests to `tests/test_persistent_recipe_cache.py`
-   - Tests cover:
-     - Concurrent reads without corruption (1 test)
-     - Concurrent write and read operations (1 test)
-     - Concurrent updates to same recipe (1 test)
-     - Schema initialization thread safety (1 test)
-     - Concurrent save and remove operations (1 test)
-   - Total: 17 tests (up from 12)
-
-### Test Results
-- **Integration Tests:** 16/16 passing
-- **ModelLifecycleService Tests:** 18/18 passing  
-- **PersistentRecipeCache Tests:** 17/17 passing
-- **Total New Tests Added:** 28 tests
-
----
-
-## Phase 1 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **pytest-asyncio Integration** ✅
-   - Added `pytest-asyncio>=0.21.0` to `requirements-dev.txt`
-   - Updated `pytest.ini` with `asyncio_mode = auto` and `asyncio_default_fixture_loop_scope = function`
-   - Removed custom `pytest_pyfunc_call` handler from `tests/conftest.py`
-   - Added `@pytest.mark.asyncio` decorator to 21 async test functions in `tests/services/test_download_manager.py`
-
-2. **Error Path Tests** ✅
-   - Created `tests/services/test_downloader_error_paths.py` with 19 new tests
-   - Tests cover:
-     - DownloadStreamControl state management (6 tests)
-     - Downloader configuration and initialization (4 tests)
-     - DownloadProgress dataclass (1 test)
-     - Custom exceptions (2 tests)
-     - Authentication headers (3 tests)
-     - Session management (3 tests)
-
-3. **Test Results**
-   - All 45 tests pass (26 in test_download_manager.py + 19 in test_downloader_error_paths.py)
-   - No regressions introduced
-
-### Notes
-- Over-mocking fix in `test_download_manager.py` deferred to Phase 2 as it requires significant refactoring
-- Error path tests focus on unit-level testing of downloader components rather than complex integration scenarios
-
----
-
-## Phase 1: Critical Fixes (P0) - Week 1-2
-
-### 1.1 Fix Over-Mocking Issues
-
-**Problem:** Tests mock the methods they purport to test, hiding real bugs.
-
-**Affected Files:**
-- `tests/services/test_download_manager.py` - Mocks `_execute_download`
-- `tests/utils/test_example_images_download_manager_unit.py` - Mocks callbacks
-- `tests/routes/test_base_model_routes_smoke.py` - Uses fake service stubs
-
-**Actions:**
-1. Refactor `test_download_manager.py` to test actual download logic
-2. Replace method-level mocks with dependency injection
-3. Add integration tests that verify real behavior
-
-**Example Fix:**
-```python
-# BEFORE (Bad - mocks method under test)
-async def fake_execute_download(self, **kwargs):
-    return {"success": True}
-monkeypatch.setattr(DownloadManager, "_execute_download", fake_execute_download)
-
-# AFTER (Good - tests actual logic with injected dependencies)
-async def test_download_executes_with_real_logic(
-    tmp_path, mock_downloader, mock_websocket
-):
-    manager = DownloadManager(
-        downloader=mock_downloader,
-        ws_manager=mock_websocket
-    )
-    result = await manager._execute_download(urls=["http://test.com/file.safetensors"])
-    assert result.success is True
-    assert mock_downloader.download_calls == 1
-```
-
-### 1.2 Add Missing Error Path Tests
-
-**Problem:** Error handling code is not tested, leading to production failures.
-
-**Required Tests:**
-
-| Error Type | Module | Priority |
-|------------|--------|----------|
-| Network timeout | `downloader.py` | P0 |
-| Disk full | `download_manager.py` | P0 |
-| Permission denied | `example_images_download_manager.py` | P0 |
-| Session refresh failure | `downloader.py` | P1 |
-| Partial file cleanup | `download_manager.py` | P1 |
-
-**Implementation:**
-```python
-@pytest.mark.asyncio
-async def test_download_handles_network_timeout():
-    """Verify download retries on timeout and eventually fails gracefully."""
-    # Arrange
-    downloader = Downloader()
-    mock_session = AsyncMock()
-    mock_session.get.side_effect = asyncio.TimeoutError()
-    
-    # Act
-    success, message = await downloader.download_file(
-        url="http://test.com/file.safetensors",
-        target_path=tmp_path / "test.safetensors",
-        session=mock_session
-    )
-    
-    # Assert
-    assert success is False
-    assert "timeout" in message.lower()
-    assert mock_session.get.call_count == MAX_RETRIES
-```
-
-### 1.3 Standardize Async Test Patterns
-
-**Problem:** Inconsistent async test patterns across codebase.
-
-**Current State:**
-- Some use `@pytest.mark.asyncio`
-- Some rely on custom `pytest_pyfunc_call` in conftest.py
-- Some use bare async functions
-
-**Solution:**
-1. Add `pytest-asyncio` to requirements-dev.txt
-2. Update `pytest.ini`:
-   ```ini
-   [pytest]
-   asyncio_mode = auto
-   asyncio_default_fixture_loop_scope = function
-   ```
-3. Remove custom `pytest_pyfunc_call` handler from conftest.py
-4. Bulk update all async tests to use `@pytest.mark.asyncio`
-
-**Migration Script:**
-```bash
-# Find all async test functions missing decorator
-rg "^async def test_" tests/ --type py -A1 | grep -B1 "@pytest.mark" | grep "async def"
-
-# Add decorator (manual review required)
-```
-
----
-
-## Phase 2: Integration & Coverage (P1) - Week 3-4
-
-### 2.1 Add Critical Module Tests
-
-**Priority 1: `py/services/model_lifecycle_service.py`**
-```python
-# tests/services/test_model_lifecycle_service.py
-class TestModelLifecycleService:
-    async def test_create_model_registers_in_cache(self):
-        """Verify new model is registered in both cache and database."""
-        
-    async def test_delete_model_cleans_up_files_and_cache(self):
-        """Verify deletion removes files and updates all indexes."""
-        
-    async def test_update_model_metadata_propagates_changes(self):
-        """Verify metadata updates reach all subscribers."""
-```
-
-**Priority 2: `py/services/persistent_recipe_cache.py`**
-```python
-# tests/services/test_persistent_recipe_cache.py
-class TestPersistentRecipeCache:
-    def test_initialization_creates_schema(self):
-        """Verify SQLite schema is created on first use."""
-        
-    async def test_save_recipe_persists_to_sqlite(self):
-        """Verify recipe data is saved correctly."""
-        
-    async def test_concurrent_access_does_not_corrupt_database(self):
-        """Verify thread safety under concurrent writes."""
-```
-
-**Priority 3: Route Handler Tests**
-- `py/routes/handlers/preview_handlers.py`
-- `py/routes/handlers/misc_handlers.py`
-- `py/routes/handlers/model_handlers.py`
-
-### 2.2 Add End-to-End Integration Tests
-
-**Download Flow Integration Test:**
-```python
-# tests/integration/test_download_flow.py
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_complete_download_flow(tmp_path, test_server):
-    """
-    Integration test covering:
-    1. Route receives download request
-    2. DownloadCoordinator schedules it
-    3. DownloadManager executes actual download
-    4. Downloader makes HTTP request (to test server)
-    5. Progress is broadcast via WebSocket
-    6. File is saved and cache updated
-    """
-    # Setup test server with known file
-    test_file = tmp_path / "test_model.safetensors"
-    test_file.write_bytes(b"fake model data")
-    
-    # Start download
-    async with aiohttp.ClientSession() as session:
-        response = await session.post(
-            "http://localhost:8188/api/lm/download",
-            json={"urls": [f"http://localhost:{test_server.port}/test_model.safetensors"]}
-        )
-        assert response.status == 200
-        
-    # Verify file downloaded
-    downloaded = tmp_path / "downloads" / "test_model.safetensors"
-    assert downloaded.exists()
-    assert downloaded.read_bytes() == b"fake model data"
-    
-    # Verify WebSocket progress updates
-    assert len(ws_manager.broadcasts) > 0
-    assert any(b["status"] == "completed" for b in ws_manager.broadcasts)
-```
-
-**Recipe Flow Integration Test:**
-```python
-# tests/integration/test_recipe_flow.py
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_recipe_analysis_and_save_flow(tmp_path):
-    """
-    Integration test covering:
-    1. Import recipe from image
-    2. Parse metadata and extract models
-    3. Save to cache and database
-    4. Retrieve and display
-    """
-```
-
-### 2.3 Strengthen Assertions
-
-**Replace loose assertions:**
-```python
-# BEFORE
-assert "mismatch" in message.lower()
-
-# AFTER
-assert message == "File size mismatch. Expected: 1000 bytes, Got: 500 bytes"
-assert not target_path.exists()
-assert not Path(str(target_path) + ".part").exists()
-assert len(downloader.retry_history) == 3
-```
-
-**Add state verification:**
-```python
-# BEFORE
-assert result is True
-
-# AFTER
-assert result is True
-assert model["status"] == "downloaded"
-assert model["file_path"].exists()
-assert cache.get_by_hash(model["sha256"]) is not None
-assert len(ws_manager.payloads) >= 2  # Started + completed
-```
-
----
-
-## Phase 4 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Property-Based Tests (Hypothesis)** ✅
-   - Created `tests/utils/test_utils_hypothesis.py` with 19 property-based tests
-   - Tests cover:
-     - `sanitize_folder_name` idempotency and invalid character handling (4 tests)
-     - `_sanitize_library_name` idempotency and safe character filtering (2 tests)
-     - `normalize_path` idempotency and forward slash usage (2 tests)
-     - `fuzzy_match` edge cases and threshold behavior (3 tests)
-     - `determine_base_model` return type guarantees (2 tests)
-     - `get_preview_extension` return type validation (2 tests)
-     - `calculate_recipe_fingerprint` determinism and ordering (4 tests)
-   - Fixed Hypothesis plugin compatibility issue by creating a `MockModule` class in `conftest.py` that is hashable (unlike `types.SimpleNamespace`)
-
-2. **Snapshot Tests (Syrupy)** ✅
-   - Created `tests/routes/test_api_snapshots.py` with 7 snapshot tests
-   - Tests cover:
-     - SettingsHandler response formats (2 tests)
-     - NodeRegistryHandler response formats (2 tests)
-     - Utility function output verification (2 tests)
-     - ModelLibraryHandler empty response format (1 test)
-   - All snapshots generated and tests passing (7/7)
-
-3. **Performance Benchmarks** ✅
-   - Created `tests/performance/test_cache_performance.py` with 11 benchmark tests
-   - Tests cover:
-     - Hash index lookup performance (100, 1K, 10K models) - 3 tests
-     - Hash index add entry performance (100, 10K existing) - 2 tests
-     - Fuzzy matching performance (short text, long text, many words) - 3 tests
-     - Recipe fingerprint calculation (5, 50, 200 LoRAs) - 3 tests
-   - All benchmarks passing with performance metrics (11/11)
-
-4. **Package Dependencies** ✅
-   - Added `hypothesis>=6.0` to `requirements-dev.txt`
-   - Added `syrupy>=5.0` to `requirements-dev.txt`
-   - Added `pytest-benchmark>=5.0` to `requirements-dev.txt`
-
-### Test Results
-- **Property-Based Tests:** 19/19 passing
-- **Snapshot Tests:** 7/7 passing
-- **Performance Benchmarks:** 11/11 passing
-- **Total New Tests Added:** 37 tests
-- **Full Test Suite:** 947/947 passing
-
----
-
-## Phase 3 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Centralized Test Fixtures** ✅
-   - Added `mock_downloader` fixture to `tests/conftest.py`
-     - Configurable mock with `should_fail` and `return_value` attributes
-     - Records all download calls for verification
-   - Added `mock_websocket_manager` fixture to `tests/conftest.py`
-     - Recording WebSocket manager that captures all broadcast payloads
-     - Includes helper method `get_payloads_by_type()` for filtering
-   - Added `reset_singletons` autouse fixture to `tests/conftest.py`
-     - Resets DownloadManager, ServiceRegistry, ModelScanner, and SettingsManager
-     - Ensures test isolation and prevents singleton pollution
-
-2. **Split Large Test Files** ✅
-   - Split `tests/services/test_download_manager.py` (1422 lines) into:
-     - `test_download_manager_basic.py` - Core functionality (12 tests)
-     - `test_download_manager_error.py` - Error handling and execution (15 tests)
-     - `test_download_manager_concurrent.py` - Advanced scenarios (6 tests)
-   - Split `tests/utils/test_cache_paths.py` (530 lines) into:
-     - `test_cache_paths_resolution.py` - Path resolution and CacheType tests (11 tests)
-     - `test_cache_paths_validation.py` - Legacy path validation and cleanup (9 tests)
-     - `test_cache_paths_migration.py` - Migration scenarios and auto-cleanup (9 tests)
-
-3. **Complex Test Refactoring** ✅
-   - Reviewed `test_example_images_download_manager_unit.py`
-   - Existing async event-based patterns are appropriate for testing concurrent behavior
-   - No refactoring needed - tests follow consistent patterns and are maintainable
-
-### Test Results
-- **Download Manager Tests:** 33/33 passing across 3 files
-- **Cache Paths Tests:** 29/29 passing across 3 files
-- **Total Tests Maintained:** All existing tests preserved and organized
-
----
-
-## Phase 3: Architecture & Maintainability (P2) - Week 5-6
-
-### 3.1 Centralize Test Fixtures
-
-**Create `tests/conftest.py` improvements:**
-
-```python
-# tests/conftest.py additions
-
-@pytest.fixture
-def mock_downloader():
-    """Provide a configurable mock downloader."""
-    class MockDownloader:
-        def __init__(self):
-            self.download_calls = []
-            self.should_fail = False
-            
-        async def download_file(self, url, target_path, **kwargs):
-            self.download_calls.append({"url": url, "target_path": target_path})
-            if self.should_fail:
-                return False, "Download failed"
-            return True, str(target_path)
-    
-    return MockDownloader()
-
-@pytest.fixture
-def mock_websocket_manager():
-    """Provide a recording WebSocket manager."""
-    class RecordingWebSocketManager:
-        def __init__(self):
-            self.payloads = []
-            
-        async def broadcast(self, payload):
-            self.payloads.append(payload)
-            
-    return RecordingWebSocketManager()
-
-@pytest.fixture
-def mock_scanner():
-    """Provide a mock model scanner with configurable cache."""
-    # ... existing MockScanner but improved ...
-    
-@pytest.fixture(autouse=True)
-def reset_singletons():
-    """Reset all singletons before each test."""
-    # Centralized singleton reset
-    DownloadManager._instance = None
-    ServiceRegistry.clear_services()
-    ModelScanner._instances.clear()
-    yield
-    # Cleanup
-    DownloadManager._instance = None
-    ServiceRegistry.clear_services()
-    ModelScanner._instances.clear()
-```
-
-### 3.2 Split Large Test Files
-
-**Target Files:**
-- `tests/services/test_download_manager.py` (1000+ lines) → Split into:
-  - `test_download_manager_basic.py` - Core functionality
-  - `test_download_manager_error.py` - Error handling
-  - `test_download_manager_concurrent.py` - Concurrent operations
-
-- `tests/utils/test_cache_paths.py` (529 lines) → Split into:
-  - `test_cache_paths_resolution.py`
-  - `test_cache_paths_validation.py`
-  - `test_cache_paths_migration.py`
-
-### 3.3 Refactor Complex Tests
-
-**Example: Simplify test setup in `test_example_images_download_manager_unit.py`**
-
-**Current (Complex):**
-```python
-async def test_start_download_bootstraps_progress_and_task(
-    monkeypatch: pytest.MonkeyPatch, tmp_path
-):
-    # 40+ lines of setup
-    started = asyncio.Event()
-    release = asyncio.Event()
-    
-    async def fake_download(self, ...):
-        started.set()
-        await release.wait()
-        # ... more logic ...
-```
-
-**Improved (Using fixtures):**
-```python
-async def test_start_download_bootstraps_progress_and_task(
-    download_manager_with_fake_backend, release_event
-):
-    # Setup in fixtures, test is clean
-    manager = download_manager_with_fake_backend
-    result = await manager.start_download({"model_types": ["lora"]})
-    assert result["success"] is True
-    assert manager._is_downloading is True
-```
-
----
-
-## Phase 4: Advanced Testing (P3) - Week 7-8
-
-### 4.1 Add Property-Based Tests (Hypothesis)
-
-**Install:** `pip install hypothesis`
-
-**Example:**
-```python
-# tests/utils/test_hash_utils_hypothesis.py
-from hypothesis import given, strategies as st
-
-@given(st.text(min_size=1, max_size=100))
-def test_hash_normalization_idempotent(name):
-    """Hash normalization should be idempotent."""
-    normalized = normalize_hash(name)
-    assert normalize_hash(normalized) == normalized
-
-@given(st.lists(st.dictionaries(st.text(), st.text()), min_size=0, max_size=1000))
-def test_model_cache_handles_any_model_list(models):
-    """Cache should handle any list of models without crashing."""
-    cache = ModelCache()
-    cache.raw_data = models
-    # Should not raise
-    list(cache.iter_models())
-```
-
-### 4.2 Add Snapshot Tests (Syrupy)
-
-**Install:** `pip install syrupy`
-
-**Example:**
-```python
-# tests/routes/test_api_snapshots.py
-import pytest
-
-@pytest.mark.asyncio
-async def test_lora_list_response_format(snapshot, client):
-    """Verify API response format matches snapshot."""
-    response = await client.get("/api/lm/loras")
-    data = await response.json()
-    assert data == snapshot  # Syrupy handles this
-```
-
-### 4.3 Add Performance Benchmarks
-
-**Install:** `pip install pytest-benchmark`
-
-**Example:**
-```python
-# tests/performance/test_cache_performance.py
-import pytest
-
-def test_cache_lookup_performance(benchmark):
-    """Benchmark cache lookup with 10,000 models."""
-    cache = create_cache_with_n_models(10000)
-    
-    result = benchmark(lambda: cache.get_by_hash("abc123"))
-    # Benchmark automatically collects timing stats
-```
-
----
-
-## Implementation Checklist
-
-### Week 1-2: Critical Fixes
-- [x] Fix over-mocking in `test_download_manager.py` (Skipped - requires major refactoring, see Phase 2)
-- [x] Add network timeout tests (Added `test_downloader_error_paths.py` with 19 error path tests)
-- [x] Add disk full error tests (Covered in error path tests)
-- [x] Add permission denied tests (Covered in error path tests)
-- [x] Install and configure pytest-asyncio (Added to requirements-dev.txt and pytest.ini)
-- [x] Remove custom pytest_pyfunc_call handler (Removed from conftest.py)
-- [x] Add `@pytest.mark.asyncio` to all async tests (Added to 21 async test functions in test_download_manager.py)
-
-### Week 3-4: Integration & Coverage
-- [x] Create `test_model_lifecycle_service.py` tests (12 new tests added)
-- [x] Create `test_persistent_recipe_cache.py` tests (5 new concurrent access tests added)
-- [x] Create `tests/integration/` directory (created with conftest.py)
-- [x] Add download flow integration test (7 tests added)
-- [x] Add recipe flow integration test (9 tests added)
-- [x] Add route handler tests for preview_handlers.py (already exists in test_preview_routes.py)
-- [x] Strengthen assertions across integration tests (comprehensive assertions added)
-
-### Week 5-6: Architecture
-- [x] Add centralized fixtures to conftest.py
-- [x] Split `test_download_manager.py` into 3 files
-- [x] Split `test_cache_paths.py` into 3 files
-- [x] Refactor complex test setups (reviewed - no changes needed)
-- [x] Remove duplicate singleton reset fixtures (consolidated in conftest.py)
-
-### Week 7-8: Advanced Testing
-- [x] Install hypothesis (Added to requirements-dev.txt)
-- [x] Add 10 property-based tests (Created 19 tests in test_utils_hypothesis.py)
-- [x] Install syrupy (Added to requirements-dev.txt)
-- [x] Add 5 snapshot tests (Created 7 tests in test_api_snapshots.py)
-- [x] Install pytest-benchmark (Added to requirements-dev.txt)
-- [x] Add 3 performance benchmarks (Created 11 tests in test_cache_performance.py)
-
----
-
-## Success Metrics
-
-### Quantitative
-- **Code Coverage:** Increase from ~70% to >90%
-- **Test Count:** Increase from 400+ to 600+
-- **Assertion Strength:** Replace 50+ weak assertions
-- **Integration Test Ratio:** Increase from 5% to 20%
-
-### Qualitative
-- **Bug Escape Rate:** Reduce by 80%
-- **Test Maintenance Time:** Reduce by 50%
-- **Time to Write New Tests:** Reduce by 30%
-- **CI Pipeline Speed:** Maintain <5 minutes
-
----
-
-## Risk Mitigation
-
-| Risk | Mitigation |
-|------|------------|
-| Breaking existing tests | Run full test suite after each change |
-| Increased CI time | Optimize tests, parallelize execution |
-| Developer resistance | Provide training, pair programming |
-| Maintenance burden | Document patterns, provide templates |
-| Coverage gaps | Use coverage.py in CI, fail on <90% |
-
----
-
-## Related Documents
-
-- `docs/testing/frontend-testing-roadmap.md` - Frontend testing plan
-- `docs/AGENTS.md` - Development guidelines
-- `pytest.ini` - Test configuration
-- `tests/conftest.py` - Shared fixtures
-
----
-
-## Approval
-
-| Role | Name | Date | Signature |
-|------|------|------|-----------|
-| Tech Lead | | | |
-| QA Lead | | | |
-| Product Owner | | | |
-
----
-
-**Next Review Date:** 2026-02-25
-
-**Document Owner:** Backend Team

docs/ui-ux-optimization/progress-tracker.md

@@ -1,196 +0,0 @@
-# Settings Modal Optimization Progress Tracker
-
-## Project Overview
-**Goal**: Optimize Settings Modal UI/UX with left navigation sidebar
-**Started**: 2026-02-23
-**Current Phase**: P2 - Search Bar (Completed)
-
----
-
-## Phase 0: Left Navigation Sidebar (P0)
-
-### Status: Completed ✓
-
-### Completion Notes
-- All CSS changes implemented
-- HTML structure restructured successfully  
-- JavaScript navigation functionality added
-- Translation keys added and synchronized
-- Ready for testing and review
-
-### Tasks
-
-#### 1. CSS Changes
-- [x] Add two-column layout styles
-  - [x] `.settings-modal` flex layout
-  - [x] `.settings-nav` sidebar styles
-  - [x] `.settings-content` content area styles
-  - [x] `.settings-nav-item` navigation item styles
-  - [x] `.settings-nav-item.active` active state styles
-- [x] Adjust modal width to 950px
-- [x] Add smooth scroll behavior
-- [x] Add responsive styles for mobile
-- [x] Ensure dark theme compatibility
-
-#### 2. HTML Changes
-- [x] Restructure modal HTML
-  - [x] Wrap content in two-column container
-  - [x] Add navigation sidebar structure
-  - [x] Add navigation items for each section
-  - [x] Add ID anchors to each section
-- [x] Update section grouping if needed
-
-#### 3. JavaScript Changes
-- [x] Add navigation click handlers
-- [x] Implement smooth scroll to section
-- [x] Add scroll spy for active nav highlighting
-- [x] Handle nav item click events
-- [x] Update SettingsManager initialization
-
-#### 4. Translation Keys
-- [x] Add translation keys for navigation groups
-  - [x] `settings.nav.general`
-  - [x] `settings.nav.interface`
-  - [x] `settings.nav.download`
-  - [x] `settings.nav.advanced`
-
-#### 4. Testing
-- [x] Verify navigation clicks work
-- [x] Verify active highlighting works
-- [x] Verify smooth scrolling works
-- [ ] Test on mobile viewport (deferred to final QA)
-- [ ] Test dark/light theme (deferred to final QA)
-- [x] Verify all existing settings work
-- [x] Verify save/load functionality
-
-### Blockers
-None currently
-
-### Notes
-- Started implementation on 2026-02-23
-- Following existing design system and CSS variables
-
----
-
-## Phase 1: Section Collapse/Expand (P1)
-
-### Status: Completed ✓
-
-### Completion Notes
-- All sections now have collapse/expand functionality
-- Chevron icon rotates smoothly on toggle
-- State persistence via localStorage working correctly
-- CSS animations for smooth height transitions
-- Settings order reorganized to match sidebar navigation
-
-### Tasks
-- [x] Add collapse/expand toggle to section headers
-- [x] Add chevron icon with rotation animation
-- [x] Implement localStorage for state persistence
-- [x] Add CSS animations for smooth transitions
-- [x] Reorder settings sections to match sidebar navigation
-
----
-
-## Phase 2: Search Bar (P1)
-
-### Status: Completed ✓
-
-### Completion Notes
-- Search input added to settings modal header with icon and clear button
-- Real-time filtering with debounced input (150ms delay)
-- Highlight matching terms with accent color background
-- Handle empty search results with user-friendly message
-- Keyboard shortcuts: Escape to clear search
-- Sections with matches are automatically expanded
-- All translation keys added and synchronized across languages
-
-### Tasks
-- [x] Add search input to header area
-- [x] Implement real-time filtering
-- [x] Add highlight for matched terms
-- [x] Handle empty search results
-
----
-
-## Phase 3: Visual Hierarchy (P2)
-
-### Status: Planned
-
-### Tasks
-- [ ] Add accent border to section headers
-- [ ] Bold setting labels
-- [ ] Increase section spacing
-
----
-
-## Phase 4: Quick Actions (P3)
-
-### Status: Planned
-
-### Tasks
-- [ ] Add reset to defaults button
-- [ ] Add export config button
-- [ ] Add import config button
-- [ ] Implement corresponding functionality
-
----
-
-## Change Log
-
-### 2026-02-23 (P2)
-- Completed Phase 2: Search Bar
-- Added search input to settings modal header with search icon and clear button
-- Implemented real-time filtering with 150ms debounce for performance
-- Added visual highlighting for matched search terms using accent color
-- Implemented empty search results state with user-friendly message
-- Added keyboard shortcuts (Escape to clear search)
-- Sections with matching content are automatically expanded during search
-- Updated SettingsManager.js with search initialization and filtering logic
-- Added comprehensive CSS styles for search input, highlights, and responsive design
-- Added translation keys for search feature (placeholder, clear, no results)
-- Synchronized translations across all language files
-
-### 2026-02-23 (P1)
-- Completed Phase 1: Section Collapse/Expand
-- Added collapse/expand functionality to all settings sections
-- Implemented chevron icon with smooth rotation animation
-- Added localStorage persistence for collapse state
-- Reorganized settings sections to match sidebar navigation order
-- Updated SettingsManager.js with section collapse initialization
-- Added CSS styles for smooth transitions and animations
-
-### 2026-02-23 (P0)
-- Created project documentation
-- Started Phase 0 implementation
-- Analyzed existing code structure
-- Implemented two-column layout with left navigation sidebar
-- Added CSS styles for navigation and responsive design
-- Restructured HTML to support new layout
-- Added JavaScript navigation functionality with scroll spy
-- Added translation keys for navigation groups
-- Synchronized translations across all language files
-- Tested in browser - navigation working correctly
-
----
-
-## Testing Checklist
-
-### Functional Testing
-- [ ] All settings save correctly
-- [ ] All settings load correctly
-- [ ] Navigation scrolls to correct section
-- [ ] Active nav updates on scroll
-- [ ] Mobile responsive layout
-
-### Visual Testing
-- [ ] Design matches existing UI
-- [ ] Dark theme looks correct
-- [ ] Light theme looks correct
-- [ ] Animations are smooth
-- [ ] No layout shifts or jumps
-
-### Cross-browser Testing
-- [ ] Chrome/Chromium
-- [ ] Firefox
-- [ ] Safari (if available)

docs/ui-ux-optimization/settings-modal-optimization-proposal.md

@@ -1,331 +0,0 @@
-# Settings Modal UI/UX Optimization
-
-## Overview
-当前Settings Modal采用单列表长页面设计，随着设置项不断增加，已难以高效浏览和定位。本方案采用 **macOS Settings 模式**（左侧导航 + 右侧单Section独占显示），在保持原有设计语言的前提下，重构信息架构，大幅提升用户体验。
-
-## Goals
-1. **提升浏览效率**：用户能够快速定位和修改设置
-2. **保持设计一致性**：延续现有的颜色、间距、动画系统
-3. **简化交互模型**：移除冗余元素（SETTINGS label、折叠功能）
-4. **清晰的视觉层次**：Section级导航，右侧独占显示
-5. **向后兼容**：不影响现有功能逻辑
-
-## Design Principles
-- **macOS Settings模式**：点击左侧导航，右侧仅显示该Section内容
-- **贴近原有设计语言**：使用现有CSS变量和样式模式
-- **最小化风格改动**：在提升UX的同时保持视觉风格稳定
-- **简化优于复杂**：移除不必要的折叠/展开交互
-
----
-
-## New Design Architecture
-
-### Layout Structure
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Settings                                    [×]            │
-├──────────────┬──────────────────────────────────────────────┤
-│  NAVIGATION  │  CONTENT                                     │
-│              │                                              │
-│  General   → │  ┌─────────────────────────────────────────┐ │
-│  Interface   │  │ General                                 │ │
-│  Download    │  │ ═══════════════════════════════════════ │ │
-│  Advanced    │  │                                           │ │
-│              │  │ ┌─────────────────────────────────────┐   │ │
-│              │  │ │ Civitai API Key                     │   │ │
-│              │  │ │ [                         ] [?]     │   │ │
-│              │  │ └─────────────────────────────────────┘   │ │
-│              │  │                                           │ │
-│              │  │ ┌─────────────────────────────────────┐   │ │
-│              │  │ │ Settings Location                   │   │ │
-│              │  │ │ [/path/to/settings]     [Browse]    │   │ │
-│              │  │ └─────────────────────────────────────┘   │ │
-│              │  └─────────────────────────────────────────┘ │
-│              │                                              │
-│              │  [Cancel]                    [Save Changes]  │
-└──────────────┴──────────────────────────────────────────────┘
-```
-
-### Key Design Decisions
-
-#### 1. 移除冗余元素
-- ❌ 删除 sidebar 中的 "SETTINGS" label
-- ❌ **取消折叠/展开功能**（增加交互成本，无实际收益）
-- ❌ 不再在左侧导航显示具体设置项（减少认知负荷）
-
-#### 2. 导航简化
-- 左侧仅显示 **4个Section**（General / Interface / Download / Advanced）
-- 当前选中项用 accent 色 background highlight
-- 无需滚动监听，点击即切换
-
-#### 3. 右侧单Section独占
-- 点击左侧导航，右侧仅显示该Section的所有设置项
-- Section标题作为页面标题（大号字体 + accent色下划线）
-- 所有设置项平铺展示，无需折叠
-
-#### 4. 视觉层次
-```
-Section Header (20px, bold, accent underline)
-├── Setting Group (card container, subtle border)
-│   ├── Setting Label (14px, semibold)
-│   ├── Setting Description (12px, muted color)
-│   └── Setting Control (input/select/toggle)
-```
-
----
-
-## Optimization Phases
-
-### Phase 0: macOS Settings模式重构 (P0)
-**Status**: Ready for Development
-**Priority**: High
-
-#### Goals
-- 重构为两栏布局（左侧导航 + 右侧内容）
-- 实现Section级导航切换
-- 优化视觉层次和间距
-- 移除冗余元素
-
-#### Implementation Details
-
-##### Layout Specifications
-| Element | Specification |
-|---------|--------------|
-| Modal Width | 800px (比原700px稍宽) |
-| Modal Height | 600px (固定高度) |
-| Left Sidebar | 200px 固定宽度 |
-| Right Content | flex: 1，自动填充 |
-| Content Padding | --space-3 (24px) |
-
-##### Navigation Structure
-```
-General (通用)
-├── Language
-├── Civitai API Key
-└── Settings Location
-
-Interface (界面)
-├── Layout Settings
-├── Video Settings
-└── Content Filtering
-
-Download (下载)
-├── Folder Settings
-├── Download Path Templates
-├── Example Images
-└── Update Flags
-
-Advanced (高级)
-├── Priority Tags
-├── Auto-organize exclusions
-├── Metadata refresh skip paths
-├── Metadata Archive Database
-├── Proxy Settings
-└── Misc
-```
-
-##### CSS Style Guide
-
-**Section Header**
-```css
-.settings-section-header {
-  font-size: 20px;
-  font-weight: 600;
-  padding-bottom: var(--space-2);
-  border-bottom: 2px solid var(--lora-accent);
-  margin-bottom: var(--space-3);
-}
-```
-
-**Setting Group (Card)**
-```css
-.settings-group {
-  background: var(--card-bg);
-  border: 1px solid var(--lora-border);
-  border-radius: var(--border-radius-sm);
-  padding: var(--space-3);
-  margin-bottom: var(--space-3);
-}
-```
-
-**Setting Item**
-```css
-.setting-item {
-  margin-bottom: var(--space-3);
-}
-
-.setting-item:last-child {
-  margin-bottom: 0;
-}
-
-.setting-label {
-  font-size: 14px;
-  font-weight: 500;
-  margin-bottom: var(--space-1);
-}
-
-.setting-description {
-  font-size: 12px;
-  color: var(--text-muted);
-  margin-bottom: var(--space-2);
-}
-```
-
-**Sidebar Navigation**
-```css
-.settings-nav-item {
-  padding: var(--space-2) var(--space-3);
-  border-radius: var(--border-radius-xs);
-  cursor: pointer;
-  transition: background 0.2s ease;
-}
-
-.settings-nav-item:hover {
-  background: rgba(255, 255, 255, 0.05);
-}
-
-.settings-nav-item.active {
-  background: var(--lora-accent);
-  color: white;
-}
-```
-
-#### Files to Modify
-
-1. **static/css/components/modal/settings-modal.css**
-   - [ ] 新增两栏布局样式
-   - [ ] 新增侧边栏导航样式
-   - [ ] 新增Section标题样式
-   - [ ] 调整设置项卡片样式
-   - [ ] 移除折叠相关的CSS
-
-2. **templates/components/modals/settings_modal.html**
-   - [ ] 重构为两栏HTML结构
-   - [ ] 添加4个导航项
-   - [ ] 将Section改为独立内容区域
-   - [ ] 移除折叠按钮HTML
-
-3. **static/js/managers/SettingsManager.js**
-   - [ ] 添加导航点击切换逻辑
-   - [ ] 添加Section显示/隐藏控制
-   - [ ] 移除折叠/展开相关代码
-   - [ ] 默认显示第一个Section
-
----
-
-### Phase 1: 搜索功能 (P1)
-**Status**: Planned
-**Priority**: Medium
-
-#### Goals
-- 快速定位特定设置项
-- 支持关键词搜索设置标签和描述
-
-#### Implementation
-- 搜索框保持在顶部右侧
-- 实时过滤：显示匹配的Section和设置项
-- 高亮匹配的关键词
-- 无结果时显示友好提示
-
----
-
-### Phase 2: 操作按钮优化 (P2)
-**Status**: Planned
-**Priority**: Low
-
-#### Goals
-- 增强功能完整性
-- 提供批量操作能力
-
-#### Implementation
-- 底部固定操作栏（position: sticky）
-- [Cancel] 和 [Save Changes] 按钮
-- 可选：重置为默认、导出配置、导入配置
-
----
-
-## Migration Notes
-
-### Removed Features
-| Feature | Reason |
-|---------|--------|
-| Section折叠/展开 | 单Section独占显示后不再需要 |
-| 滚动监听高亮 | 改为点击切换，无需监听滚动 |
-| 长页面平滑滚动 | 内容不再超长，无需滚动 |
-| "SETTINGS" label | 冗余信息，移除以简化UI |
-
-### Preserved Features
-- 所有设置项功能和逻辑
-- 表单验证
-- 设置项描述和提示
-- 原有的CSS变量系统
-
----
-
-## Success Criteria
-
-### Phase 0
-- [ ] Modal显示为两栏布局
-- [ ] 左侧显示4个Section导航
-- [ ] 点击导航切换右侧显示的Section
-- [ ] 当前选中导航项高亮显示
-- [ ] Section标题有accent色下划线
-- [ ] 设置项以卡片形式分组展示
-- [ ] 移除所有折叠/展开功能
-- [ ] 移动端响应式正常（单栏堆叠）
-- [ ] 所有现有设置功能正常工作
-- [ ] 设计风格与原有UI一致
-
-### Phase 1
-- [ ] 搜索框可输入关键词
-- [ ] 实时过滤显示匹配项
-- [ ] 高亮匹配的关键词
-
-### Phase 2
-- [ ] 底部有固定操作按钮栏
-- [ ] Cancel和Save Changes按钮工作正常
-
----
-
-## Timeline
-
-| Phase | Estimated Time | Status |
-|-------|---------------|--------|
-| P0    | 3-4 hours     | Ready for Development |
-| P1    | 2-3 hours     | Planned |
-| P2    | 1-2 hours     | Planned |
-
----
-
-## Reference
-
-### Design Inspiration
-- **macOS System Settings**: 左侧导航 + 右侧单Section独占
-- **VS Code Settings**: 清晰的视觉层次和搜索体验
-- **Linear**: 简洁的两栏布局设计
-
-### CSS Variables Reference
-```css
-/* Colors */
---lora-accent: #007AFF;
---lora-border: rgba(255, 255, 255, 0.1);
---card-bg: rgba(255, 255, 255, 0.05);
---text-color: #ffffff;
---text-muted: rgba(255, 255, 255, 0.6);
-
-/* Spacing */
---space-1: 8px;
---space-2: 12px;
---space-3: 16px;
---space-4: 24px;
-
-/* Border Radius */
---border-radius-xs: 4px;
---border-radius-sm: 8px;
-```
-
----
-
-**Last Updated**: 2025-02-24
-**Author**: AI Assistant
-**Status**: Ready for Implementation

docs/ui-ux-optimization/settings-modal-progress.md

@@ -1,191 +0,0 @@
-# Settings Modal Optimization Progress
-
-**Project**: Settings Modal UI/UX Optimization  
-**Status**: Phase 0 - Ready for Development  
-**Last Updated**: 2025-02-24
-
----
-
-## Phase 0: macOS Settings模式重构
-
-### Overview
-重构Settings Modal为macOS Settings模式：左侧Section导航 + 右侧单Section独占显示。移除冗余元素，优化视觉层次。
-
-### Tasks
-
-#### 1. CSS Updates ✅
-**File**: `static/css/components/modal/settings-modal.css`
-
-- [x] **Layout Styles**
-  - [x] Modal固定尺寸 800x600px
-  - [x] 左侧 sidebar 固定宽度 200px
-  - [x] 右侧 content flex: 1 自动填充
-
-- [x] **Navigation Styles**
-  - [x] `.settings-nav` 容器样式
-  - [x] `.settings-nav-item` 基础样式（更大字体，更醒目的active状态）
-  - [x] `.settings-nav-item.active` 高亮样式（accent背景）
-  - [x] `.settings-nav-item:hover` 悬停效果
-  - [x] 隐藏 "SETTINGS" label
-  - [x] 隐藏 group titles
-
-- [x] **Content Area Styles**
-  - [x] `.settings-section` 默认隐藏（仅当前显示）
-  - [x] `.settings-section.active` 显示状态
-  - [x] `.settings-section-header` 标题样式（20px + accent下划线）
-  - [x] 添加 fadeIn 动画效果
-
-- [x] **Cleanup**
-  - [x] 移除折叠相关样式
-  - [x] 移除 `.settings-section-toggle` 按钮样式
-  - [x] 移除展开/折叠动画样式
-
-**Status**: ✅ Completed
-
----
-
-#### 2. HTML Structure Update ✅
-**File**: `templates/components/modals/settings_modal.html`
-
-- [x] **Navigation Items**
-  - [x] General (通用)
-  - [x] Interface (界面)
-  - [x] Download (下载)
-  - [x] Advanced (高级)
-  - [x] 移除 "SETTINGS" label
-  - [x] 移除 group titles
-
-- [x] **Content Sections**
-  - [x] 重组为4个Section (general/interface/download/advanced)
-  - [x] 每个section添加 `data-section` 属性
-  - [x] 添加Section标题（带accent下划线）
-  - [x] 移除所有折叠按钮（chevron图标）
-  - [x] 平铺显示所有设置项
-
-**Status**: ✅ Completed
-
----
-
-#### 3. JavaScript Logic Update ✅
-**File**: `static/js/managers/SettingsManager.js`
-
-- [x] **Navigation Logic**
-  - [x] `initializeNavigation()` 改为Section切换模式
-  - [x] 点击导航项显示对应Section
-  - [x] 更新导航高亮状态
-  - [x] 默认显示第一个Section
-
-- [x] **Remove Legacy Code**
-  - [x] 移除 `initializeSectionCollapse()` 方法
-  - [x] 移除滚动监听相关代码
-  - [x] 移除 `localStorage` 折叠状态存储
-
-- [x] **Search Function**
-  - [x] 更新搜索功能以适配新显示模式
-  - [x] 搜索时自动切换到匹配的Section
-  - [x] 高亮匹配的关键词
-
-**Status**: ✅ Completed
-
----
-
-### Testing Checklist
-
-#### Visual Testing
-- [ ] 两栏布局正确显示
-- [ ] 左侧导航4个Section正确显示
-- [ ] 点击导航切换右侧内容
-- [ ] 当前导航项高亮显示（accent背景）
-- [ ] Section标题有accent色下划线
-- [ ] 设置项以卡片形式分组
-- [ ] 无"SETTINGS" label
-- [ ] 无折叠/展开按钮
-
-#### Functional Testing
-- [ ] 所有设置项可正常编辑
-- [ ] 设置保存功能正常
-- [ ] 设置加载功能正常
-- [ ] 表单验证正常工作
-- [ ] 帮助提示（tooltip）正常显示
-
-#### Responsive Testing
-- [ ] 桌面端（>768px）两栏布局
-- [ ] 移动端（<768px）单栏堆叠
-- [ ] 移动端导航可正常切换
-
-#### Cross-Browser Testing
-- [ ] Chrome/Edge
-- [ ] Firefox
-- [ ] Safari（如适用）
-
----
-
-## Phase 1: 搜索功能
-
-### Tasks
-- [ ] 搜索框UI更新
-- [ ] 搜索逻辑实现
-- [ ] 实时过滤显示
-- [ ] 关键词高亮
-
-**Estimated Time**: 2-3 hours  
-**Status**: 📋 Planned
-
----
-
-## Phase 2: 操作按钮优化
-
-### Tasks
-- [ ] 底部操作栏样式
-- [ ] 固定定位（sticky）
-- [ ] Cancel/Save按钮功能
-- [ ] 可选：Reset/Export/Import
-
-**Estimated Time**: 1-2 hours  
-**Status**: 📋 Planned
-
----
-
-## Progress Summary
-
-| Phase | Progress | Status |
-|-------|----------|--------|
-| Phase 0 | 100% | ✅ Completed |
-| Phase 1 | 0% | 📋 Planned |
-| Phase 2 | 0% | 📋 Planned |
-
-**Overall Progress**: 100% (Phase 0)
-
----
-
-## Development Log
-
-### 2025-02-24
-- ✅ 创建优化提案文档（macOS Settings模式）
-- ✅ 创建进度追踪文档
-- ✅ Phase 0 开发完成
-  - ✅ CSS重构完成：新增macOS Settings样式，移除折叠相关样式
-  - ✅ HTML重构完成：重组为4个Section，移除所有折叠按钮
-  - ✅ JavaScript重构完成：实现Section切换逻辑，更新搜索功能
-
----
-
-## Notes
-
-### Design Decisions
-- 采用macOS Settings模式而非长页面滚动模式
-- 左侧仅显示4个Section，不显示具体设置项
-- 移除折叠/展开功能，简化交互
-- Section标题使用accent色下划线强调
-
-### Technical Notes
-- 优先使用现有CSS变量
-- 保持向后兼容，不破坏现有设置存储逻辑
-- 移动端响应式：小屏幕单栏堆叠
-
-### Blockers
-None
-
----
-
-**Next Action**: Start Phase 0 - CSS Updates

package-lock.json

@@ -114,6 +114,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -137,6 +138,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1611,6 +1613,7 @@
       "integrity": "sha512-MyL55p3Ut3cXbeBEG7Hcv0mVM8pp8PBNWxRqchZnSfAiES1v1mRnMeFfaHWIPULpwsYfvO+ZmMZz5tGCnjzDUQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssstyle": "^4.0.1",
         "data-urls": "^5.0.0",

py/lora_manager.py

@@ -5,22 +5,16 @@ import logging
 from .utils.logging_config import setup_logging
 
 # Check if we're in standalone mode
-standalone_mode = (
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-)
 
 # Only setup logging prefix if not in standalone mode
 if not standalone_mode:
     setup_logging()
 
-from server import PromptServer  # type: ignore
+from server import PromptServer # type: ignore
 
 from .config import config
-from .services.model_service_factory import (
+from .services.model_service_factory import ModelServiceFactory, register_default_model_types
-    ModelServiceFactory,
-    register_default_model_types,
-)
 from .routes.recipe_routes import RecipeRoutes
 from .routes.stats_routes import StatsRoutes
 from .routes.update_routes import UpdateRoutes
@@ -33,7 +27,6 @@ from .utils.example_images_migration import ExampleImagesMigration
 from .services.websocket_manager import ws_manager
 from .services.example_images_cleanup_service import ExampleImagesCleanupService
 from .middleware.csp_middleware import relax_csp_for_remote_media
-from .middleware.error_middleware import api_json_error
 
 logger = logging.getLogger(__name__)
 
@@ -68,20 +61,14 @@ class _SettingsProxy:
 
 settings = _SettingsProxy()
 
-
 class LoraManager:
     """Main entry point for LoRA Manager plugin"""
-
+    
     @classmethod
     def add_routes(cls):
         """Initialize and register all routes using the new refactored architecture"""
         app = PromptServer.instance.app
 
-        # Register JSON error middleware for /api/* routes as the outermost
-        # middleware so it catches errors from all other middlewares.
-        if api_json_error not in app.middlewares:
-            app.middlewares.insert(0, api_json_error)
-
         if relax_csp_for_remote_media not in app.middlewares:
             # Ensure CSP relaxer executes after ComfyUI's block_external_middleware so it can
             # see and extend the restrictive header instead of being overwritten by it.
@@ -89,8 +76,7 @@ class LoraManager:
                 (
                     idx
                     for idx, middleware in enumerate(app.middlewares)
-                    if getattr(middleware, "__name__", "")
+                    if getattr(middleware, "__name__", "") == "block_external_middleware"
-                    == "block_external_middleware"
                 ),
                 None,
             )
@@ -98,9 +84,7 @@ class LoraManager:
             if block_middleware_index is None:
                 app.middlewares.append(relax_csp_for_remote_media)
             else:
-                app.middlewares.insert(
+                app.middlewares.insert(block_middleware_index, relax_csp_for_remote_media)
-                    block_middleware_index, relax_csp_for_remote_media
-                )
 
         # Increase allowed header sizes so browsers with large localhost cookie
         # jars (multiple UIs on 127.0.0.1) don't trip aiohttp's 8KB default
@@ -121,7 +105,7 @@ class LoraManager:
         app._handler_args = updated_handler_args
 
         # Configure aiohttp access logger to be less verbose
-        logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
 
         # Add specific suppression for connection reset errors
         class ConnectionResetFilter(logging.Filter):
@@ -140,52 +124,46 @@ class LoraManager:
         asyncio_logger.addFilter(ConnectionResetFilter())
 
         # Add static route for example images if the path exists in settings
-        example_images_path = settings.get("example_images_path")
+        example_images_path = settings.get('example_images_path')
         logger.info(f"Example images path: {example_images_path}")
         if example_images_path and os.path.exists(example_images_path):
-            app.router.add_static("/example_images_static", example_images_path)
+            app.router.add_static('/example_images_static', example_images_path)
-            logger.info(
+            logger.info(f"Added static route for example images: /example_images_static -> {example_images_path}")
-                f"Added static route for example images: /example_images_static -> {example_images_path}"
-            )
 
         # Add static route for locales JSON files
         if os.path.exists(config.i18n_path):
-            app.router.add_static("/locales", config.i18n_path)
+            app.router.add_static('/locales', config.i18n_path)
-            logger.info(
+            logger.info(f"Added static route for locales: /locales -> {config.i18n_path}")
-                f"Added static route for locales: /locales -> {config.i18n_path}"
-            )
 
         # Add static route for plugin assets
-        app.router.add_static("/loras_static", config.static_path)
+        app.router.add_static('/loras_static', config.static_path)
-
+        
         # Register default model types with the factory
         register_default_model_types()
-
+        
         # Setup all model routes using the factory
         ModelServiceFactory.setup_all_routes(app)
-
+        
         # Setup non-model-specific routes
         stats_routes = StatsRoutes()
         stats_routes.setup_routes(app)
         RecipeRoutes.setup_routes(app)
-        UpdateRoutes.setup_routes(app)
+        UpdateRoutes.setup_routes(app)  
         MiscRoutes.setup_routes(app)
         ExampleImagesRoutes.setup_routes(app, ws_manager=ws_manager)
         PreviewRoutes.setup_routes(app)
-
+        
         # Setup WebSocket routes that are shared across all model types
-        app.router.add_get("/ws/fetch-progress", ws_manager.handle_connection)
+        app.router.add_get('/ws/fetch-progress', ws_manager.handle_connection)
-        app.router.add_get(
+        app.router.add_get('/ws/download-progress', ws_manager.handle_download_connection)
-            "/ws/download-progress", ws_manager.handle_download_connection
+        app.router.add_get('/ws/init-progress', ws_manager.handle_init_connection)
-        )
+        
-        app.router.add_get("/ws/init-progress", ws_manager.handle_init_connection)
+        # Schedule service initialization 
-
-        # Schedule service initialization
         app.on_startup.append(lambda app: cls._initialize_services())
-
+        
         # Add cleanup
         app.on_shutdown.append(cls._cleanup)
-
+        
     @classmethod
     async def _initialize_services(cls):
         """Initialize all services using the ServiceRegistry"""
@@ -196,206 +174,164 @@ class LoraManager:
             # Register DownloadManager with ServiceRegistry
             await ServiceRegistry.get_download_manager()
 
-            # Initialize DownloadQueueService for persistent queue/history
-            await ServiceRegistry.get_download_queue_service()
-
-            await ServiceRegistry.get_backup_service()
-
             from .services.metadata_service import initialize_metadata_providers
-
             await initialize_metadata_providers()
-
+            
             # Initialize WebSocket manager
             await ServiceRegistry.get_websocket_manager()
-
+            
             # Initialize scanners in background
             lora_scanner = await ServiceRegistry.get_lora_scanner()
             checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
             embedding_scanner = await ServiceRegistry.get_embedding_scanner()
-
+            
             # Initialize recipe scanner if needed
             recipe_scanner = await ServiceRegistry.get_recipe_scanner()
-
+            
             # Create low-priority initialization tasks
             init_tasks = [
-                asyncio.create_task(
+                asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init'),
-                    lora_scanner.initialize_in_background(), name="lora_cache_init"
+                asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init'),
-                ),
+                asyncio.create_task(embedding_scanner.initialize_in_background(), name='embedding_cache_init'),
-                asyncio.create_task(
+                asyncio.create_task(recipe_scanner.initialize_in_background(), name='recipe_cache_init')
-                    checkpoint_scanner.initialize_in_background(),
-                    name="checkpoint_cache_init",
-                ),
-                asyncio.create_task(
-                    embedding_scanner.initialize_in_background(),
-                    name="embedding_cache_init",
-                ),
-                asyncio.create_task(
-                    recipe_scanner.initialize_in_background(), name="recipe_cache_init"
-                ),
             ]
 
             await ExampleImagesMigration.check_and_run_migrations()
-
+            
             # Schedule post-initialization tasks to run after scanners complete
             asyncio.create_task(
-                cls._run_post_initialization_tasks(init_tasks), name="post_init_tasks"
+                cls._run_post_initialization_tasks(init_tasks), 
+                name='post_init_tasks'
             )
-
+            
-            logger.debug(
+            logger.debug("LoRA Manager: All services initialized and background tasks scheduled")
-                "LoRA Manager: All services initialized and background tasks scheduled"
+                
-            )
-
         except Exception as e:
-            logger.error(
+            logger.error(f"LoRA Manager: Error initializing services: {e}", exc_info=True)
-                f"LoRA Manager: Error initializing services: {e}", exc_info=True
+    
-            )
-
     @classmethod
     async def _run_post_initialization_tasks(cls, init_tasks):
         """Run post-initialization tasks after all scanners complete"""
         try:
-            logger.debug(
+            logger.debug("LoRA Manager: Waiting for scanner initialization to complete...")
-                "LoRA Manager: Waiting for scanner initialization to complete..."
+            
-            )
-
             # Wait for all scanner initialization tasks to complete
             await asyncio.gather(*init_tasks, return_exceptions=True)
 
-            logger.debug(
+            logger.debug("LoRA Manager: Scanner initialization completed, starting post-initialization tasks...")
-                "LoRA Manager: Scanner initialization completed, starting post-initialization tasks..."
+            
-            )
-
             # Run post-initialization tasks
             post_tasks = [
-                asyncio.create_task(
+                asyncio.create_task(cls._cleanup_backup_files(), name='cleanup_bak_files'),
-                    cls._cleanup_backup_files(), name="cleanup_bak_files"
-                ),
                 # Add more post-initialization tasks here as needed
                 # asyncio.create_task(cls._another_post_task(), name='another_task'),
             ]
-
+            
             # Run all post-initialization tasks
             results = await asyncio.gather(*post_tasks, return_exceptions=True)
-
+            
             # Log results
             for i, result in enumerate(results):
                 task_name = post_tasks[i].get_name()
                 if isinstance(result, Exception):
-                    logger.error(
+                    logger.error(f"Post-initialization task '{task_name}' failed: {result}")
-                        f"Post-initialization task '{task_name}' failed: {result}"
-                    )
                 else:
-                    logger.debug(
+                    logger.debug(f"Post-initialization task '{task_name}' completed successfully")
-                        f"Post-initialization task '{task_name}' completed successfully"
+                    
-                    )
-
             logger.debug("LoRA Manager: All post-initialization tasks completed")
-
+            
         except Exception as e:
-            logger.error(
+            logger.error(f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True)
-                f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True
+    
-            )
-
     @classmethod
     async def _cleanup_backup_files(cls):
         """Clean up .bak files in all model roots"""
         try:
             logger.debug("Starting cleanup of .bak files in model directories...")
-
+            
             # Collect all model roots
             all_roots = set()
             all_roots.update(config.loras_roots)
-            all_roots.update(config.base_models_roots or [])
+            all_roots.update(config.base_models_roots) 
-            all_roots.update(config.embeddings_roots or [])
+            all_roots.update(config.embeddings_roots)
-
+            
             total_deleted = 0
             total_size_freed = 0
-
+            
             for root_path in all_roots:
                 if not os.path.exists(root_path):
                     continue
-
+                    
                 try:
-                    (
+                    deleted_count, size_freed = await cls._cleanup_backup_files_in_directory(root_path)
-                        deleted_count,
-                        size_freed,
-                    ) = await cls._cleanup_backup_files_in_directory(root_path)
                     total_deleted += deleted_count
                     total_size_freed += size_freed
-
+                    
                     if deleted_count > 0:
-                        logger.debug(
+                        logger.debug(f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024*1024):.2f} MB)")
-                            f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024 * 1024):.2f} MB)"
+                        
-                        )
-
                 except Exception as e:
                     logger.error(f"Error cleaning up .bak files in {root_path}: {e}")
-
+                    
                 # Yield control periodically
                 await asyncio.sleep(0.01)
-
+            
             if total_deleted > 0:
-                logger.debug(
+                logger.debug(f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024*1024):.2f} MB total")
-                    f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024 * 1024):.2f} MB total"
-                )
             else:
                 logger.debug("Backup cleanup completed: no .bak files found")
 
         except Exception as e:
             logger.error(f"Error during backup file cleanup: {e}", exc_info=True)
-
+    
     @classmethod
     async def _cleanup_backup_files_in_directory(cls, directory_path: str):
         """Clean up .bak files in a specific directory recursively
-
+        
         Args:
             directory_path: Path to the directory to clean
-
+            
         Returns:
             Tuple[int, int]: (number of files deleted, total size freed in bytes)
         """
         deleted_count = 0
         size_freed = 0
         visited_paths = set()
-
+        
         def cleanup_recursive(path):
             nonlocal deleted_count, size_freed
-
+            
             try:
                 real_path = os.path.realpath(path)
                 if real_path in visited_paths:
                     return
                 visited_paths.add(real_path)
-
+                
                 with os.scandir(path) as it:
                     for entry in it:
                         try:
-                            if entry.is_file(
+                            if entry.is_file(follow_symlinks=True) and entry.name.endswith('.bak'):
-                                follow_symlinks=True
-                            ) and entry.name.endswith(".bak"):
                                 file_size = entry.stat().st_size
                                 os.remove(entry.path)
                                 deleted_count += 1
                                 size_freed += file_size
                                 logger.debug(f"Deleted .bak file: {entry.path}")
-
+                                
                             elif entry.is_dir(follow_symlinks=True):
                                 cleanup_recursive(entry.path)
-
+                                
                         except Exception as e:
-                            logger.warning(
+                            logger.warning(f"Could not delete .bak file {entry.path}: {e}")
-                                f"Could not delete .bak file {entry.path}: {e}"
+                            
-                            )
-
             except Exception as e:
                 logger.error(f"Error scanning directory {path} for .bak files: {e}")
-
+        
         # Run the recursive cleanup in a thread pool to avoid blocking
         loop = asyncio.get_event_loop()
         await loop.run_in_executor(None, cleanup_recursive, directory_path)
-
+        
         return deleted_count, size_freed
-
+    
     @classmethod
     async def _cleanup_example_images_folders(cls):
         """Invoke the example images cleanup service for manual execution."""
@@ -403,21 +339,21 @@ class LoraManager:
             service = ExampleImagesCleanupService()
             result = await service.cleanup_example_image_folders()
 
-            if result.get("success"):
+            if result.get('success'):
                 logger.debug(
                     "Manual example images cleanup completed: moved=%s",
-                    result.get("moved_total"),
+                    result.get('moved_total'),
                 )
-            elif result.get("partial_success"):
+            elif result.get('partial_success'):
                 logger.warning(
                     "Manual example images cleanup partially succeeded: moved=%s failures=%s",
-                    result.get("moved_total"),
+                    result.get('moved_total'),
-                    result.get("move_failures"),
+                    result.get('move_failures'),
                 )
             else:
                 logger.debug(
                     "Manual example images cleanup skipped or failed: %s",
-                    result.get("error", "no changes"),
+                    result.get('error', 'no changes'),
                 )
 
             return result
@@ -425,9 +361,9 @@ class LoraManager:
         except Exception as e:  # pragma: no cover - defensive guard
             logger.error(f"Error during example images cleanup: {e}", exc_info=True)
             return {
-                "success": False,
+                'success': False,
-                "error": str(e),
+                'error': str(e),
-                "error_code": "unexpected_error",
+                'error_code': 'unexpected_error',
             }
 
     @classmethod
@@ -435,15 +371,6 @@ class LoraManager:
         """Cleanup resources using ServiceRegistry"""
         try:
             logger.info("LoRA Manager: Cleaning up services")
-
+                
-            # Cancel any in-flight scanner initialization tasks so thread-pool
-            # workers (e.g. _initialize_cache_sync) can break out of their loops
-            # when the server shuts down (e.g. Ctrl+C on WSL).
-            for name in ("lora_scanner", "checkpoint_scanner", "embedding_scanner"):
-                scanner = ServiceRegistry.get_service_sync(name)
-                if scanner is not None and hasattr(scanner, "cancel_task"):
-                    scanner.cancel_task()
-                    logger.debug("LoRA Manager: Cancelled %s", name)
-
         except Exception as e:
             logger.error(f"Error during cleanup: {e}", exc_info=True)

py/metadata_collector/__init__.py

@@ -4,10 +4,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 # Check if running in standalone mode
-standalone_mode = (
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-)
 
 if not standalone_mode:
     from .metadata_hook import MetadataHook
@@ -16,13 +13,13 @@ if not standalone_mode:
     def init():
         # Install hooks to collect metadata during execution
         MetadataHook.install()
-
+        
         # Initialize registry
         registry = MetadataRegistry()
-
+        
         logger.info("ComfyUI Metadata Collector initialized")
-
+        
-    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
+    def get_metadata(prompt_id=None):
         """Helper function to get metadata from the registry"""
         registry = MetadataRegistry()
         return registry.get_metadata(prompt_id)
@@ -30,7 +27,7 @@ else:
     # Standalone mode - provide dummy implementations
     def init():
         logger.info("ComfyUI Metadata Collector disabled in standalone mode")
-
+        
-    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
+    def get_metadata(prompt_id=None):
         """Dummy implementation for standalone mode"""
         return {}

py/metadata_collector/constants.py

@@ -5,10 +5,9 @@ MODELS = "models"
 PROMPTS = "prompts"
 SAMPLING = "sampling"
 LORAS = "loras"
-EMBEDDINGS = "embeddings"
 SIZE = "size"
 IMAGES = "images"
 IS_SAMPLER = "is_sampler"  # New constant to mark sampler nodes
 
 # Complete list of categories to track
-METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, EMBEDDINGS, SIZE, IMAGES]
+METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]

py/metadata_collector/metadata_hook.py

@@ -148,13 +148,10 @@ class MetadataHook:
         """Install hooks for asynchronous execution model"""
         # Store the original _async_map_node_over_list function
         original_map_node_over_list = getattr(execution, map_node_func_name)
-
+        
-        # Wrapped async function - signature must exactly match _async_map_node_over_list
+        # Wrapped async function, compatible with both stable and nightly
-        async def async_map_node_over_list_with_metadata(
+        async def async_map_node_over_list_with_metadata(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None, *args, **kwargs):
-            prompt_id, unique_id, obj, input_data_all, func,
+            hidden_inputs = kwargs.get('hidden_inputs', None)
-            allow_interrupt=False, execution_block_cb=None,
-            pre_execute_cb=None, v3_data=None
-        ):
             # Only collect metadata when calling the main function of nodes
             if func == obj.FUNCTION and hasattr(obj, '__class__'):
                 try:
@@ -166,13 +163,13 @@ class MetadataHook:
                             registry.record_node_execution(node_id, class_type, input_data_all, None)
                 except Exception as e:
                     logger.error(f"Error collecting metadata (pre-execution): {str(e)}")
-
+            
-            # Call original function with exact parameters
+            # Call original function with all args/kwargs
             results = await original_map_node_over_list(
                 prompt_id, unique_id, obj, input_data_all, func,
-                allow_interrupt, execution_block_cb, pre_execute_cb, v3_data=v3_data
+                allow_interrupt, execution_block_cb, pre_execute_cb, *args, **kwargs
             )
-
+            
             if func == obj.FUNCTION and hasattr(obj, '__class__'):
                 try:
                     registry = MetadataRegistry()
@@ -183,28 +180,28 @@ class MetadataHook:
                             registry.update_node_execution(node_id, class_type, results)
                 except Exception as e:
                     logger.error(f"Error collecting metadata (post-execution): {str(e)}")
-
+            
             return results
-
+        
         # Also hook the execute function to track the current prompt_id
         original_execute = execution.execute
-
+        
         async def async_execute_with_prompt_tracking(*args, **kwargs):
             if len(args) >= 7:  # Check if we have enough arguments
                 server, prompt, caches, node_id, extra_data, executed, prompt_id = args[:7]
                 registry = MetadataRegistry()
-
+                
                 # Start collection if this is a new prompt
                 if not registry.current_prompt_id or registry.current_prompt_id != prompt_id:
                     registry.start_collection(prompt_id)
-
+                    
                 # Store the dynprompt reference for node lookups
                 if hasattr(prompt, 'original_prompt'):
                     registry.set_current_prompt(prompt)
-
+            
             # Execute the original function
             return await original_execute(*args, **kwargs)
-
+            
         # Replace the functions with async versions
         setattr(execution, map_node_func_name, async_map_node_over_list_with_metadata)
         execution.execute = async_execute_with_prompt_tracking

py/metadata_collector/metadata_processor.py

@@ -352,101 +352,50 @@ class MetadataProcessor:
         
         # Check if we have stored conditioning objects for this sampler
         if sampler_id in metadata.get(PROMPTS, {}) and (
-            "pos_conditioning" in metadata[PROMPTS][sampler_id] or
+            "pos_conditioning" in metadata[PROMPTS][sampler_id] or 
-            "neg_conditioning" in metadata[PROMPTS][sampler_id]
+            "neg_conditioning" in metadata[PROMPTS][sampler_id]):
-        ):
+            
             pos_conditioning = metadata[PROMPTS][sampler_id].get("pos_conditioning")
             neg_conditioning = metadata[PROMPTS][sampler_id].get("neg_conditioning")
-
+            
-            def extend_unique(target, values):
+            # Helper function to recursively find prompt text for a conditioning object
-                for value in values:
+            def find_prompt_text_for_conditioning(conditioning_obj, is_positive=True):
-                    if value and value not in target:
-                        target.append(value)
-
-            # Helper function to recursively find prompt texts for a conditioning object.
-            # Transform nodes can map one output conditioning to multiple source conditionings.
-            def find_prompt_texts_for_conditioning(
-                conditioning_obj, is_positive=True, visited=None
-            ):
                 if conditioning_obj is None:
-                    return []
+                    return ""
-
+                    
-                if visited is None:
-                    visited = set()
-
-                conditioning_id = id(conditioning_obj)
-                if conditioning_id in visited:
-                    return []
-                visited.add(conditioning_id)
-
-                prompt_texts = []
-
                 # Try to match conditioning objects with those stored by extractors
                 for prompt_node_id, prompt_data in metadata[PROMPTS].items():
-                    if not isinstance(prompt_data, dict):
+                    # For nodes with single conditioning output
-                        continue
+                    if "conditioning" in prompt_data:
-
+                        if id(prompt_data["conditioning"]) == id(conditioning_obj):
-                    # For CLIP text nodes with a single conditioning output.
+                            return prompt_data.get("text", "")
-                    if id(prompt_data.get("conditioning")) == conditioning_id:
+                    
-                        text = prompt_data.get("text", "")
+                    # For nodes with separate pos_conditioning and neg_conditioning outputs (like TSC_EfficientLoader)
-                        if text:
+                    if is_positive and "positive_encoded" in prompt_data:
-                            extend_unique(prompt_texts, [text])
+                        if id(prompt_data["positive_encoded"]) == id(conditioning_obj):
-
+                            if "positive_text" in prompt_data:
-                    # Generic provenance for passthrough/transform/combine nodes.
+                                return prompt_data["positive_text"]
-                    for source in prompt_data.get("conditioning_sources", []):
+                            else:
-                        if id(source.get("output")) != conditioning_id:
+                                orig_conditioning = prompt_data.get("orig_pos_cond", None)
-                            continue
+                                if orig_conditioning is not None:
-                        for input_conditioning in source.get("inputs", []):
+                                    # Recursively find the prompt text for the original conditioning
-                            extend_unique(
+                                    return find_prompt_text_for_conditioning(orig_conditioning, is_positive=True)
-                                prompt_texts,
+                    
-                                find_prompt_texts_for_conditioning(
+                    if not is_positive and "negative_encoded" in prompt_data:
-                                    input_conditioning, is_positive, visited
+                        if id(prompt_data["negative_encoded"]) == id(conditioning_obj):
-                                ),
+                            if "negative_text" in prompt_data:
-                            )
+                                return prompt_data["negative_text"]
-
+                            else:
-                    # For nodes with separate pos_conditioning and neg_conditioning outputs
+                                orig_conditioning = prompt_data.get("orig_neg_cond", None)
-                    # like TSC_EfficientLoader and existing ControlNet-style metadata.
+                                if orig_conditioning is not None:
-                    if (
+                                    # Recursively find the prompt text for the original conditioning
-                        is_positive
+                                    return find_prompt_text_for_conditioning(orig_conditioning, is_positive=False)
-                        and id(prompt_data.get("positive_encoded")) == conditioning_id
+                
-                    ):
+                return ""
-                        if prompt_data.get("positive_text"):
+            
-                            extend_unique(prompt_texts, [prompt_data["positive_text"]])
-                        else:
-                            extend_unique(
-                                prompt_texts,
-                                find_prompt_texts_for_conditioning(
-                                    prompt_data.get("orig_pos_cond"),
-                                    is_positive=True,
-                                    visited=visited,
-                                ),
-                            )
-
-                    if (
-                        not is_positive
-                        and id(prompt_data.get("negative_encoded")) == conditioning_id
-                    ):
-                        if prompt_data.get("negative_text"):
-                            extend_unique(prompt_texts, [prompt_data["negative_text"]])
-                        else:
-                            extend_unique(
-                                prompt_texts,
-                                find_prompt_texts_for_conditioning(
-                                    prompt_data.get("orig_neg_cond"),
-                                    is_positive=False,
-                                    visited=visited,
-                                ),
-                            )
-
-                return prompt_texts
-
             # Find prompt texts using the helper function
-            result["prompt"] = ", ".join(
+            result["prompt"] = find_prompt_text_for_conditioning(pos_conditioning, is_positive=True)
-                find_prompt_texts_for_conditioning(pos_conditioning, is_positive=True)
+            result["negative_prompt"] = find_prompt_text_for_conditioning(neg_conditioning, is_positive=False)
-            )
-            result["negative_prompt"] = ", ".join(
-                find_prompt_texts_for_conditioning(neg_conditioning, is_positive=False)
-            )
             
         return result
     
@@ -560,14 +509,8 @@ class MetadataProcessor:
         
         params["loras"] = " ".join(lora_parts)
         
-        # Extract clip_skip from any SAMPLING node that provides it
+        # Set default clip_skip value
-        for sampler_info in metadata.get(SAMPLING, {}).values():
+        params["clip_skip"] = "1"  # Common default
-            clip_skip = sampler_info.get("parameters", {}).get("clip_skip")
-            if clip_skip is not None:
-                params["clip_skip"] = clip_skip
-                break
-        if params["clip_skip"] is None:
-            params["clip_skip"] = "1"
         
         return params
     
@@ -652,15 +595,6 @@ class MetadataProcessor:
                     if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
                         params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
                 else:
-                    # Generic guider nodes often expose separate positive/negative inputs.
+                    positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
-                    positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "positive", max_depth=10)
-                    if not positive_node_id:
-                        positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
                     if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
                         params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
-
-                    negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "negative", max_depth=10)
-                    if not negative_node_id:
-                        negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
-                    if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
-                        params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")

py/metadata_collector/metadata_registry.py

@@ -1,54 +1,50 @@
 import time
-from nodes import NODE_CLASS_MAPPINGS  # type: ignore
+from nodes import NODE_CLASS_MAPPINGS
 from .node_extractors import NODE_EXTRACTORS, GenericNodeExtractor
 from .constants import METADATA_CATEGORIES, IMAGES
 
-
 class MetadataRegistry:
     """A singleton registry to store and retrieve workflow metadata"""
-
     _instance = None
-
+    
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             cls._instance._reset()
         return cls._instance
-
+    
     def _reset(self):
         self.current_prompt_id = None
         self.current_prompt = None
         self.metadata = {}
         self.prompt_metadata = {}
         self.executed_nodes = set()
-
+        
         # Node-level cache for metadata
         self.node_cache = {}
-
+        
         # Limit the number of stored prompts
         self.max_prompt_history = 3
-
+        
         # Categories we want to track and retrieve from cache
         self.metadata_categories = METADATA_CATEGORIES
-
+    
     def _clean_old_prompts(self):
         """Clean up old prompt metadata, keeping only recent ones"""
         if len(self.prompt_metadata) <= self.max_prompt_history:
             return
-
+            
         # Sort all prompt_ids by timestamp
         sorted_prompts = sorted(
             self.prompt_metadata.keys(),
-            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0),
+            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0)
         )
-
+        
         # Remove oldest records
-        prompts_to_remove = sorted_prompts[
+        prompts_to_remove = sorted_prompts[:len(sorted_prompts) - self.max_prompt_history]
-            : len(sorted_prompts) - self.max_prompt_history
-        ]
         for pid in prompts_to_remove:
             del self.prompt_metadata[pid]
-
+    
     def start_collection(self, prompt_id):
         """Begin metadata collection for a new prompt"""
         self.current_prompt_id = prompt_id
@@ -57,96 +53,90 @@ class MetadataRegistry:
             category: {} for category in METADATA_CATEGORIES
         }
         # Add additional metadata fields
-        self.prompt_metadata[prompt_id].update(
+        self.prompt_metadata[prompt_id].update({
-            {
+            "execution_order": [],
-                "execution_order": [],
+            "current_prompt": None,  # Will store the prompt object
-                "current_prompt": None,  # Will store the prompt object
+            "timestamp": time.time()
-                "timestamp": time.time(),
+        })
-            }
+        
-        )
-
         # Clean up old prompt data
         self._clean_old_prompts()
-
+    
     def set_current_prompt(self, prompt):
         """Set the current prompt object reference"""
         self.current_prompt = prompt
         if self.current_prompt_id and self.current_prompt_id in self.prompt_metadata:
             # Store the prompt in the metadata for later relationship tracing
             self.prompt_metadata[self.current_prompt_id]["current_prompt"] = prompt
-
+        
     def get_metadata(self, prompt_id=None):
         """Get collected metadata for a prompt"""
         key = prompt_id if prompt_id is not None else self.current_prompt_id
         if key not in self.prompt_metadata:
             return {}
-
+            
         metadata = self.prompt_metadata[key]
-
+        
         # If we have a current prompt object, check for non-executed nodes
         prompt_obj = metadata.get("current_prompt")
         if prompt_obj and hasattr(prompt_obj, "original_prompt"):
             original_prompt = prompt_obj.original_prompt
-
+            
             # Fill in missing metadata from cache for nodes that weren't executed
             self._fill_missing_metadata(key, original_prompt)
-
+            
         return self.prompt_metadata.get(key, {})
-
+    
     def _fill_missing_metadata(self, prompt_id, original_prompt):
         """Fill missing metadata from cache for non-executed nodes"""
         if not original_prompt:
             return
-
+            
         executed_nodes = self.executed_nodes
         metadata = self.prompt_metadata[prompt_id]
-
+        
         # Iterate through nodes in the original prompt
         for node_id, node_data in original_prompt.items():
             # Skip if already executed in this run
             if node_id in executed_nodes:
                 continue
-
+                
             # Get the node type from the prompt (this is the key in NODE_CLASS_MAPPINGS)
             prompt_class_type = node_data.get("class_type")
             if not prompt_class_type:
                 continue
-
+                
             # Convert to actual class name (which is what we use in our cache)
             class_type = prompt_class_type
             if prompt_class_type in NODE_CLASS_MAPPINGS:
                 class_obj = NODE_CLASS_MAPPINGS[prompt_class_type]
                 class_type = class_obj.__name__
-
+            
             # Create cache key using the actual class name
             cache_key = f"{node_id}:{class_type}"
-
+            
             # Check if this node type is relevant for metadata collection
             if class_type in NODE_EXTRACTORS:
                 # Check if we have cached metadata for this node
                 if cache_key in self.node_cache:
                     cached_data = self.node_cache[cache_key]
-
+                    
                     # Apply cached metadata to the current metadata
                     for category in self.metadata_categories:
                         if category in cached_data and node_id in cached_data[category]:
                             if node_id not in metadata[category]:
-                                metadata[category][node_id] = cached_data[category][
+                                metadata[category][node_id] = cached_data[category][node_id]
-                                    node_id
+    
-                                ]
-
     def record_node_execution(self, node_id, class_type, inputs, outputs):
         """Record information about a node's execution"""
         if not self.current_prompt_id:
             return
-
+            
         # Add to execution order and mark as executed
         if node_id not in self.executed_nodes:
             self.executed_nodes.add(node_id)
-            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(
+            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(node_id)
-                node_id
+        
-            )
-
         # Process inputs to simplify working with them
         processed_inputs = {}
         for input_name, input_values in inputs.items():
@@ -155,61 +145,63 @@ class MetadataRegistry:
                 processed_inputs[input_name] = input_values[0]
             else:
                 processed_inputs[input_name] = input_values
-
+            
         # Extract node-specific metadata
         extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
         extractor.extract(
-            node_id,
+            node_id, 
-            processed_inputs,
+            processed_inputs, 
-            outputs,
+            outputs, 
-            self.prompt_metadata[self.current_prompt_id],
+            self.prompt_metadata[self.current_prompt_id]
         )
-
+        
         # Cache this node's metadata
         self._cache_node_metadata(node_id, class_type)
-
+    
     def update_node_execution(self, node_id, class_type, outputs):
         """Update node metadata with output information"""
         if not self.current_prompt_id:
             return
-
+        
         # Process outputs to make them more usable
         processed_outputs = outputs
-
+            
         # Use the same extractor to update with outputs
         extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
-        if hasattr(extractor, "update"):
+        if hasattr(extractor, 'update'):
             extractor.update(
-                node_id, processed_outputs, self.prompt_metadata[self.current_prompt_id]
+                node_id, 
+                processed_outputs, 
+                self.prompt_metadata[self.current_prompt_id]
             )
-
+            
         # Update the cached metadata for this node
         self._cache_node_metadata(node_id, class_type)
-
+            
     def _cache_node_metadata(self, node_id, class_type):
         """Cache the metadata for a specific node"""
         if not self.current_prompt_id or not node_id or not class_type:
             return
-
+            
         # Create a cache key combining node_id and class_type
         cache_key = f"{node_id}:{class_type}"
-
+        
         # Create a shallow copy of the node's metadata
         node_metadata = {}
         current_metadata = self.prompt_metadata[self.current_prompt_id]
-
+        
         for category in self.metadata_categories:
             if category in current_metadata and node_id in current_metadata[category]:
                 if category not in node_metadata:
                     node_metadata[category] = {}
                 node_metadata[category][node_id] = current_metadata[category][node_id]
-
+        
         # Save new metadata or clear stale cache entries when metadata is empty
         if any(node_metadata.values()):
             self.node_cache[cache_key] = node_metadata
         else:
             self.node_cache.pop(cache_key, None)
-
+    
     def clear_unused_cache(self):
         """Clean up node_cache entries that are no longer in use"""
         # Collect all node_ids currently in prompt_metadata
@@ -218,18 +210,18 @@ class MetadataRegistry:
             for category in self.metadata_categories:
                 if category in prompt_data:
                     active_node_ids.update(prompt_data[category].keys())
-
+        
         # Find cache keys that are no longer needed
         keys_to_remove = []
         for cache_key in self.node_cache:
-            node_id = cache_key.split(":")[0]
+            node_id = cache_key.split(':')[0]
             if node_id not in active_node_ids:
                 keys_to_remove.append(cache_key)
-
+        
         # Remove cache entries that are no longer needed
         for key in keys_to_remove:
             del self.node_cache[key]
-
+    
     def clear_metadata(self, prompt_id=None):
         """Clear metadata for a specific prompt or reset all data"""
         if prompt_id is not None:
@@ -240,25 +232,25 @@ class MetadataRegistry:
         else:
             # Reset all data
             self._reset()
-
+    
     def get_first_decoded_image(self, prompt_id=None):
         """Get the first decoded image result"""
         key = prompt_id if prompt_id is not None else self.current_prompt_id
         if key not in self.prompt_metadata:
             return None
-
+            
         metadata = self.prompt_metadata[key]
         if IMAGES in metadata and "first_decode" in metadata[IMAGES]:
             image_data = metadata[IMAGES]["first_decode"]["image"]
-
+            
             # If it's an image batch or tuple, handle various formats
             if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
                 # Return first element of list/tuple
                 return image_data[0]
-
+            
             # If it's a tensor, return as is for processing in the route handler
             return image_data
-
+        
         # If no image is found in the current metadata, try to find it in the cache
         # This handles the case where VAEDecode was cached by ComfyUI and not executed
         prompt_obj = metadata.get("current_prompt")
@@ -278,11 +270,8 @@ class MetadataRegistry:
                             if IMAGES in cached_data and node_id in cached_data[IMAGES]:
                                 image_data = cached_data[IMAGES][node_id]["image"]
                                 # Handle different image formats
-                                if (
+                                if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
-                                    isinstance(image_data, (list, tuple))
-                                    and len(image_data) > 0
-                                ):
                                     return image_data[0]
                                 return image_data
-
+        
         return None

py/metadata_collector/node_extractors.py

@@ -1,6 +1,4 @@
-import json
 import os
-import re
 
 from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES, IS_SAMPLER
 
@@ -144,118 +142,6 @@ class TSCCheckpointLoaderExtractor(NodeMetadataExtractor):
                 metadata[PROMPTS][node_id]["positive_encoded"] = positive_conditioning
                 metadata[PROMPTS][node_id]["negative_encoded"] = negative_conditioning
 
-
-class EasyComfyLoaderExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        if "ckpt_name" in inputs:
-            _store_checkpoint_metadata(metadata, node_id, inputs["ckpt_name"])
-
-        # Only extract from optional_lora_stack — skip the single lora_name to
-        # avoid double-counting LoRAs that come through the LORA_STACK path.
-        active_loras = []
-        optional_lora_stack = inputs.get("optional_lora_stack")
-        if optional_lora_stack is not None and isinstance(optional_lora_stack, (list, tuple)):
-            for item in optional_lora_stack:
-                if isinstance(item, (list, tuple)) and len(item) >= 2:
-                    lora_path = item[0]
-                    model_strength = item[1]
-                    lora_name = os.path.splitext(os.path.basename(lora_path))[0]
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": model_strength
-                    })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            if node_id not in metadata[PROMPTS]:
-                metadata[PROMPTS][node_id] = {"node_id": node_id}
-            metadata[PROMPTS][node_id]["positive_text"] = positive_text
-            metadata[PROMPTS][node_id]["negative_text"] = negative_text
-
-        if "clip_skip" in inputs:
-            clip_skip = inputs["clip_skip"]
-            if node_id not in metadata[SAMPLING]:
-                metadata[SAMPLING][node_id] = {"parameters": {}, "node_id": node_id}
-            metadata[SAMPLING][node_id]["parameters"]["clip_skip"] = clip_skip
-
-        width = inputs.get("empty_latent_width")
-        height = inputs.get("empty_latent_height")
-        if width is not None and height is not None:
-            if SIZE not in metadata:
-                metadata[SIZE] = {}
-            metadata[SIZE][node_id] = {
-                "width": int(width),
-                "height": int(height),
-                "node_id": node_id
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        # outputs: [(pipe_dict, model, vae), ...]
-        if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-            return
-        first_output = outputs[0]
-        if not isinstance(first_output, tuple) or len(first_output) < 1:
-            return
-        pipe = first_output[0]
-        if not isinstance(pipe, dict):
-            return
-
-        positive_conditioning = pipe.get("positive")
-        negative_conditioning = pipe.get("negative")
-
-        if positive_conditioning is not None or negative_conditioning is not None:
-            if node_id not in metadata[PROMPTS]:
-                metadata[PROMPTS][node_id] = {"node_id": node_id}
-            if positive_conditioning is not None:
-                metadata[PROMPTS][node_id]["positive_encoded"] = positive_conditioning
-            if negative_conditioning is not None:
-                metadata[PROMPTS][node_id]["negative_encoded"] = negative_conditioning
-
-
-class EasyPreSamplingExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        sampling_params = {}
-        for key in ("steps", "cfg", "sampler_name", "scheduler", "denoise", "seed"):
-            if key in inputs:
-                sampling_params[key] = inputs[key]
-
-        metadata[SAMPLING][node_id] = {
-            "parameters": sampling_params,
-            "node_id": node_id,
-            IS_SAMPLER: True
-        }
-
-
-class EasySeedExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs or "seed" not in inputs:
-            return
-
-        metadata[SAMPLING][node_id] = {
-            "parameters": {"seed": inputs["seed"]},
-            "node_id": node_id,
-            IS_SAMPLER: False
-        }
-
-
 class CLIPTextEncodeExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -275,251 +161,6 @@ class CLIPTextEncodeExtractor(NodeMetadataExtractor):
                 conditioning = outputs[0][0]
                 metadata[PROMPTS][node_id]["conditioning"] = conditioning
 
-
-class MyOriginalWaifuTextExtractor(NodeMetadataExtractor):
-    """Extractor for ComfyUI-MyOriginalWaifu TextProvider nodes."""
-
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            metadata[PROMPTS][node_id] = {
-                "positive_text": positive_text,
-                "negative_text": negative_text,
-                "node_id": node_id,
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 2:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["positive_text"] = output_tuple[0]
-        prompt_metadata["negative_text"] = output_tuple[1]
-
-
-class MyOriginalWaifuClipExtractor(NodeMetadataExtractor):
-    """Extractor for ComfyUI-MyOriginalWaifu ClipProvider nodes."""
-
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            metadata[PROMPTS][node_id] = {
-                "positive_text": positive_text,
-                "negative_text": negative_text,
-                "node_id": node_id,
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 2:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["positive_encoded"] = output_tuple[0]
-        prompt_metadata["negative_encoded"] = output_tuple[1]
-
-
-def _ensure_prompt_metadata(metadata, node_id):
-    if node_id not in metadata[PROMPTS]:
-        metadata[PROMPTS][node_id] = {"node_id": node_id}
-    return metadata[PROMPTS][node_id]
-
-
-def _first_output_tuple(outputs):
-    if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-        return None
-    first_output = outputs[0]
-    if isinstance(first_output, tuple):
-        return first_output
-    return None
-
-
-def _record_conditioning_source(
-    metadata, node_id, output_conditioning, input_conditionings
-):
-    if output_conditioning is None:
-        return
-
-    sources = [
-        conditioning for conditioning in input_conditionings if conditioning is not None
-    ]
-    if not sources:
-        return
-
-    prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-    prompt_metadata.setdefault("conditioning_sources", []).append(
-        {
-            "output": output_conditioning,
-            "inputs": sources,
-        }
-    )
-
-
-def _get_variable_name(inputs):
-    for key in ("key", "name", "variable_name", "tag", "text"):
-        value = inputs.get(key)
-        if isinstance(value, str) and value:
-            return value
-    return None
-
-
-def _get_node_variable_name(metadata, node_id, inputs):
-    variable_name = _get_variable_name(inputs)
-    if variable_name:
-        return variable_name
-
-    prompt = metadata.get("current_prompt")
-    original_prompt = getattr(prompt, "original_prompt", None)
-    if not original_prompt or node_id not in original_prompt:
-        return None
-
-    node_data = original_prompt[node_id]
-    variable_name = _get_variable_name(node_data.get("inputs", {}))
-    if variable_name:
-        return variable_name
-
-    widgets_values = node_data.get("widgets_values", [])
-    if widgets_values and isinstance(widgets_values[0], str):
-        return widgets_values[0]
-
-    return None
-
-
-class ControlNetApplyAdvancedExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        if inputs.get("positive") is not None:
-            prompt_metadata["orig_pos_cond"] = inputs["positive"]
-        if inputs.get("negative") is not None:
-            prompt_metadata["orig_neg_cond"] = inputs["negative"]
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        positive_input = prompt_metadata.get("orig_pos_cond")
-        negative_input = prompt_metadata.get("orig_neg_cond")
-
-        if len(output_tuple) >= 1:
-            prompt_metadata["positive_encoded"] = output_tuple[0]
-            _record_conditioning_source(
-                metadata, node_id, output_tuple[0], [positive_input]
-            )
-        if len(output_tuple) >= 2:
-            prompt_metadata["negative_encoded"] = output_tuple[1]
-            _record_conditioning_source(
-                metadata, node_id, output_tuple[1], [negative_input]
-            )
-
-
-class ConditioningCombineExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        input_conditionings = []
-        for input_name in inputs:
-            if (
-                input_name.startswith("conditioning")
-                and inputs[input_name] is not None
-            ):
-                input_conditionings.append(inputs[input_name])
-
-        if input_conditionings:
-            prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-            prompt_metadata["orig_conditionings"] = input_conditionings
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 1:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        output_conditioning = output_tuple[0]
-        prompt_metadata["conditioning"] = output_conditioning
-        _record_conditioning_source(
-            metadata,
-            node_id,
-            output_conditioning,
-            prompt_metadata.get("orig_conditionings", []),
-        )
-
-
-class SetNodeExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        variable_name = _get_node_variable_name(metadata, node_id, inputs)
-        conditioning = inputs.get("CONDITIONING")
-        if conditioning is None:
-            conditioning = inputs.get("conditioning")
-        if conditioning is None:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["conditioning"] = conditioning
-        if variable_name:
-            prompt_metadata["variable_name"] = variable_name
-            metadata[PROMPTS].setdefault("__conditioning_variables__", {})[
-                variable_name
-            ] = conditioning
-
-
-class GetNodeExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        variable_name = _get_node_variable_name(metadata, node_id, inputs or {})
-        if variable_name:
-            prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-            prompt_metadata["variable_name"] = variable_name
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 1:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        output_conditioning = output_tuple[0]
-        prompt_metadata["conditioning"] = output_conditioning
-
-        variable_name = prompt_metadata.get("variable_name")
-        if not variable_name:
-            return
-
-        input_conditioning = metadata[PROMPTS].get("__conditioning_variables__", {}).get(
-            variable_name
-        )
-        _record_conditioning_source(
-            metadata, node_id, output_conditioning, [input_conditioning]
-        )
-
 # Base Sampler Extractor to reduce code redundancy
 class BaseSamplerExtractor(NodeMetadataExtractor):
     """Base extractor for sampler nodes with common functionality"""
@@ -786,75 +427,6 @@ class ImageSizeExtractor(NodeMetadataExtractor):
             "node_id": node_id
         }
 
-class RgthreePowerLoraLoaderExtractor(NodeMetadataExtractor):
-    """Extract LoRA metadata from rgthree Power Lora Loader.
-
-    The node passes LoRAs as dynamic kwargs: LORA_1, LORA_2, ... each containing
-    {'on': bool, 'lora': filename, 'strength': float, 'strengthTwo': float}.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        active_loras = []
-        for key, value in inputs.items():
-            if not key.upper().startswith('LORA_'):
-                continue
-            if not isinstance(value, dict):
-                continue
-            if not value.get('on') or not value.get('lora'):
-                continue
-            lora_name = os.path.splitext(os.path.basename(value['lora']))[0]
-            active_loras.append({
-                "name": lora_name,
-                "strength": round(float(value.get('strength', 1.0)), 2)
-            })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-
-class TensorRTLoaderExtractor(NodeMetadataExtractor):
-    """Extract checkpoint metadata from TensorRT Loader.
-
-    extract() parses the engine filename from 'unet_name' as a best-effort
-    fallback (strips profile suffix after '_$' and counter suffix).
-
-    update() checks if the output MODEL has attachments["source_model"]
-    set by the node (NubeBuster fork) and overrides with the real name.
-    Vanilla TRT doesn't set this — the filename parse stands.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs or "unet_name" not in inputs:
-            return
-        unet_name = inputs.get("unet_name")
-        # Strip path and extension, then drop the $_profile suffix
-        model_name = os.path.splitext(os.path.basename(unet_name))[0]
-        if "_$" in model_name:
-            model_name = model_name[:model_name.index("_$")]
-        # Strip counter suffix (e.g. _00001_) left by ComfyUI's save path
-        model_name = re.sub(r'_\d+_?$', '', model_name)
-        _store_checkpoint_metadata(metadata, node_id, model_name)
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-            return
-        first_output = outputs[0]
-        if not isinstance(first_output, tuple) or len(first_output) < 1:
-            return
-        model = first_output[0]
-        # NubeBuster fork sets attachments["source_model"] on the ModelPatcher
-        source_model = getattr(model, 'attachments', {}).get("source_model")
-        if source_model:
-            _store_checkpoint_metadata(metadata, node_id, source_model)
-
-
 class LoraLoaderManagerExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -901,55 +473,6 @@ class LoraLoaderManagerExtractor(NodeMetadataExtractor):
                 "node_id": node_id
             }
 
-class LoraTextLoaderManagerExtractor(NodeMetadataExtractor):
-    """Extract LoRA metadata from LoraTextLoaderLM (LoRA Text Loader).
-
-    The node accepts a `lora_syntax` STRING containing <lora:name:strength> tags
-    (same format as the ComfyUI prompt), plus an optional `lora_stack`.
-    This extractor parses the syntax string using the same regex as the node.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        active_loras = []
-
-        # Process lora_stack if available (optional input)
-        if "lora_stack" in inputs:
-            lora_stack = inputs.get("lora_stack", [])
-            for item in lora_stack:
-                # lora_stack entries are (path, model_strength, clip_strength) tuples
-                if isinstance(item, (list, tuple)) and len(item) >= 2:
-                    lora_path = item[0]
-                    model_strength = item[1]
-                    lora_name = os.path.splitext(os.path.basename(lora_path))[0]
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": round(float(model_strength), 2)
-                    })
-
-        # Process lora_syntax string input
-        if "lora_syntax" in inputs:
-            lora_syntax = inputs.get("lora_syntax", "")
-            if lora_syntax and isinstance(lora_syntax, str):
-                pattern = r"<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>"
-                matches = re.findall(pattern, lora_syntax, re.IGNORECASE)
-                for match in matches:
-                    lora_name = match[0]
-                    model_strength = float(match[1])
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": round(model_strength, 2)
-                    })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-
 class FluxGuidanceExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -1054,6 +577,8 @@ class SamplerCustomAdvancedExtractor(BaseSamplerExtractor):
         # Extract latent dimensions
         BaseSamplerExtractor.extract_latent_dimensions(node_id, inputs, metadata)
 
+import json
+
 class CLIPTextEncodeFluxExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -1174,12 +699,9 @@ NODE_EXTRACTORS = {
     "KSamplerSelect": KSamplerSelectExtractor,  # Add KSamplerSelect
     "BasicScheduler": BasicSchedulerExtractor,  # Add BasicScheduler
     "AlignYourStepsScheduler": BasicSchedulerExtractor,  # Add AlignYourStepsScheduler
-    # ComfyUI-Easy-Use pre-sampling / seed
-    "samplerSettings": EasyPreSamplingExtractor,  # easy preSampling
-    "easySeed": EasySeedExtractor,  # easy seed
     # Loaders
     "CheckpointLoaderSimple": CheckpointLoaderExtractor,
-    "comfyLoader": EasyComfyLoaderExtractor,  # ComfyUI-Easy-Use easy comfyLoader
+    "comfyLoader": CheckpointLoaderExtractor,  # easy comfyLoader
     "CheckpointLoaderSimpleWithImages": CheckpointLoaderExtractor,  # CheckpointLoader|pysssss
     "TSC_EfficientLoader": TSCCheckpointLoaderExtractor,  # Efficient Nodes
     "NunchakuFluxDiTLoader": NunchakuFluxDiTLoaderExtractor,  # ComfyUI-Nunchaku
@@ -1189,18 +711,12 @@ NODE_EXTRACTORS = {
     "GGUFLoaderKJ": KJNodesModelLoaderExtractor,  # KJNodes
     "DiffusionModelLoaderKJ": KJNodesModelLoaderExtractor,  # KJNodes
     "CheckpointLoaderKJ": CheckpointLoaderExtractor,  # KJNodes
-    "CheckpointLoaderLM": CheckpointLoaderExtractor,  # LoRA Manager
     "UNETLoader": UNETLoaderExtractor,          # Updated to use dedicated extractor
     "UnetLoaderGGUF": UNETLoaderExtractor,  # Updated to use dedicated extractor
-    "UNETLoaderLM": UNETLoaderExtractor,  # LoRA Manager
     "LoraLoader": LoraLoaderExtractor,
     "LoraLoaderLM": LoraLoaderManagerExtractor,
-    "LoraTextLoaderLM": LoraTextLoaderManagerExtractor,
-    "RgthreePowerLoraLoader": RgthreePowerLoraLoaderExtractor,
-    "TensorRTLoader": TensorRTLoaderExtractor,
     # Conditioning
     "CLIPTextEncode": CLIPTextEncodeExtractor,
-    "CLIPTextEncodeAttentionBias": CLIPTextEncodeExtractor,  # From https://github.com/silveroxides/ComfyUI_PromptAttention
     "PromptLM": CLIPTextEncodeExtractor,
     "CLIPTextEncodeFlux": CLIPTextEncodeFluxExtractor,  # Add CLIPTextEncodeFlux
     "WAS_Text_to_Conditioning": CLIPTextEncodeExtractor,
@@ -1208,12 +724,6 @@ NODE_EXTRACTORS = {
     "smZ_CLIPTextEncode": CLIPTextEncodeExtractor,  # From https://github.com/shiimizu/ComfyUI_smZNodes
     "CR_ApplyControlNetStack": CR_ApplyControlNetStackExtractor,  # Add CR_ApplyControlNetStack
     "PCTextEncode": CLIPTextEncodeExtractor,  # From https://github.com/asagi4/comfyui-prompt-control
-    "TextProvider": MyOriginalWaifuTextExtractor,  # ComfyUI-MyOriginalWaifu
-    "ClipProvider": MyOriginalWaifuClipExtractor,  # ComfyUI-MyOriginalWaifu
-    "ControlNetApplyAdvanced": ControlNetApplyAdvancedExtractor,
-    "ConditioningCombine": ConditioningCombineExtractor,
-    "SetNode": SetNodeExtractor,
-    "GetNode": GetNodeExtractor,
     # Latent
     "EmptyLatentImage": ImageSizeExtractor,
     # Flux

py/middleware/cache_middleware.py

@@ -16,8 +16,6 @@ IMG_EXTENSIONS = (
     ".tif",
     ".tiff",
     ".webp",
-    ".avif",
-    ".jxl",
     ".mp4"
 )
 

py/middleware/csp_middleware.py

@@ -4,21 +4,15 @@ from typing import Awaitable, Callable, Dict, List
 
 from aiohttp import web
 
-# Use wildcard for CivitAI to support their CDN subdomains (e.g., image-b2.civitai.com)
-# Security note: This is acceptable because:
-# 1. CSP img-src only controls image/video loading, not script execution
-# 2. All *.civitai.com subdomains are controlled by Civitai
-# 3. Explicit domain list would require constant updates as Civitai adds CDN nodes
 REMOTE_MEDIA_SOURCES = (
-    "https://*.civitai.com",
+    "https://image.civitai.com",
     "https://img.genur.art",
 )
 
 
 @web.middleware
 async def relax_csp_for_remote_media(
-    request: web.Request,
+    request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
-    handler: Callable[[web.Request], Awaitable[web.StreamResponse]],
 ) -> web.StreamResponse:
     """Allow LoRA Manager media previews to load from trusted remote domains.
 
@@ -49,9 +43,7 @@ async def relax_csp_for_remote_media(
             directive_order.append(name)
         directives[name] = values
 
-    def merge_sources(
+    def merge_sources(name: str, sources: List[str], defaults: List[str] | None = None) -> None:
-        name: str, sources: List[str], defaults: List[str] | None = None
-    ) -> None:
         existing = directives.get(name, list(defaults or []))
 
         for source in sources:

py/middleware/error_middleware.py

@@ -1,71 +0,0 @@
-"""JSON error middleware for API routes.
-
-Ensures all responses to /api/* requests return valid JSON that the
-browser-extension frontend can JSON.parse() without crashing, even when
-the route does not exist (404) or the handler raises an exception (500).
-
-Extension consumers call response.json() unconditionally — an HTML error
-page causes ``SyntaxError: unexpected end of data`` that leaks into the
-popup UI as a toast notification.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Awaitable, Callable
-
-from aiohttp import web
-
-logger = logging.getLogger(__name__)
-
-
-@web.middleware
-async def api_json_error(
-    request: web.Request,
-    handler: Callable[[web.Request], Awaitable[web.Response]],
-) -> web.Response:
-    """Return JSON ``{"success": false, "error": "..."}`` for API errors.
-
-    Only intercepts paths starting with ``/api/`` — all other routes
-    (frontend pages, static files, WebSocket upgrades) pass through
-    unchanged.
-    """
-    if not request.path.startswith("/api/"):
-        return await handler(request)
-
-    try:
-        response = await handler(request)
-        return response
-    except web.HTTPException as exc:
-        # Let redirects (301, 302, 307, 308) propagate — they are not errors.
-        if exc.status < 400:
-            raise
-
-        logger.warning(
-            "API %s %s returned HTTP %d: %s",
-            request.method,
-            request.path,
-            exc.status,
-            exc.reason,
-        )
-
-        return web.json_response(
-            {"success": False, "error": f"{exc.status}: {exc.reason}"},
-            status=exc.status,
-        )
-    except Exception as exc:
-        logger.error(
-            "API %s %s raised unhandled exception: %s",
-            request.method,
-            request.path,
-            exc,
-            exc_info=True,
-        )
-
-        return web.json_response(
-            {
-                "success": False,
-                "error": f"500: Internal Server Error ({type(exc).__name__})",
-            },
-            status=500,
-        )

py/nodes/checkpoint_loader.py

@@ -1,118 +0,0 @@
-import logging
-from typing import List, Tuple
-import comfy.sd # type: ignore
-import folder_paths # type: ignore
-from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
-
-logger = logging.getLogger(__name__)
-
-
-class CheckpointLoaderLM:
-    """Checkpoint Loader with support for extra folder paths
-
-    Loads checkpoints from both standard ComfyUI folders and LoRA Manager's
-    extra folder paths, providing a unified interface for checkpoint loading.
-    """
-
-    NAME = "Checkpoint Loader (LoraManager)"
-    CATEGORY = "Lora Manager/loaders"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        # Get list of checkpoint names from scanner (includes extra folder paths)
-        checkpoint_names = s._get_checkpoint_names()
-        return {
-            "required": {
-                "ckpt_name": (
-                    checkpoint_names,
-                    {"tooltip": "The name of the checkpoint (model) to load."},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL", "CLIP", "VAE")
-    RETURN_NAMES = ("MODEL", "CLIP", "VAE")
-    OUTPUT_TOOLTIPS = (
-        "The model used for denoising latents.",
-        "The CLIP model used for encoding text prompts.",
-        "The VAE model used for encoding and decoding images to and from latent space.",
-    )
-    FUNCTION = "load_checkpoint"
-
-    @classmethod
-    def _get_checkpoint_names(cls) -> List[str]:
-        """Get list of checkpoint names from scanner cache in ComfyUI format (relative path with extension)"""
-        try:
-            from ..services.service_registry import ServiceRegistry
-            import asyncio
-
-            async def _get_names():
-                scanner = await ServiceRegistry.get_checkpoint_scanner()
-                cache = await scanner.get_cached_data()
-
-                # Get all model roots for calculating relative paths
-                model_roots = scanner.get_model_roots()
-
-                # Filter only checkpoint type (not diffusion_model) and format names
-                names = []
-                for item in cache.raw_data:
-                    if item.get("sub_type") == "checkpoint":
-                        file_path = item.get("file_path", "")
-                        if file_path:
-                            # Format using relative path with OS-native separator
-                            formatted_name = _format_model_name_for_comfyui(
-                                file_path, model_roots
-                            )
-                            if formatted_name:
-                                names.append(formatted_name)
-
-                return sorted(names)
-
-            try:
-                loop = asyncio.get_running_loop()
-                import concurrent.futures
-
-                def run_in_thread():
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    try:
-                        return new_loop.run_until_complete(_get_names())
-                    finally:
-                        new_loop.close()
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(run_in_thread)
-                    return future.result()
-            except RuntimeError:
-                return asyncio.run(_get_names())
-        except Exception as e:
-            logger.error(f"Error getting checkpoint names: {e}")
-            return []
-
-    def load_checkpoint(self, ckpt_name: str) -> Tuple:
-        """Load a checkpoint by name, supporting extra folder paths
-
-        Args:
-            ckpt_name: The name of the checkpoint to load (relative path with extension)
-
-        Returns:
-            Tuple of (MODEL, CLIP, VAE)
-        """
-        # Get absolute path from cache using ComfyUI-style name
-        ckpt_path, metadata = get_checkpoint_info_absolute(ckpt_name)
-
-        if metadata is None:
-            raise FileNotFoundError(
-                f"Checkpoint '{ckpt_name}' not found in LoRA Manager cache. "
-                "Make sure the checkpoint is indexed and try again."
-            )
-
-        # Load regular checkpoint using ComfyUI's API
-        logger.info(f"Loading checkpoint from: {ckpt_path}")
-        out = comfy.sd.load_checkpoint_guess_config(
-            ckpt_path,
-            output_vae=True,
-            output_clip=True,
-            embedding_directory=folder_paths.get_folder_paths("embeddings"),
-        )
-        return out[:3]

py/nodes/gguf_import_helper.py

@@ -1,161 +0,0 @@
-"""
-Helper module to safely import ComfyUI-GGUF modules.
-
-This module provides a robust way to import ComfyUI-GGUF functionality
-regardless of how ComfyUI loaded it.
-"""
-
-import sys
-import os
-import importlib.util
-import logging
-from typing import Optional, Tuple, Any
-
-logger = logging.getLogger(__name__)
-
-
-def _get_gguf_path() -> str:
-    """Get the path to ComfyUI-GGUF based on this file's location.
-
-    Since ComfyUI-Lora-Manager and ComfyUI-GGUF are both in custom_nodes/,
-    we can derive the GGUF path from our own location.
-    """
-    # This file is at: custom_nodes/ComfyUI-Lora-Manager/py/nodes/gguf_import_helper.py
-    # ComfyUI-GGUF is at: custom_nodes/ComfyUI-GGUF
-    current_file = os.path.abspath(__file__)
-    # Go up 4 levels: nodes -> py -> ComfyUI-Lora-Manager -> custom_nodes
-    custom_nodes_dir = os.path.dirname(
-        os.path.dirname(os.path.dirname(os.path.dirname(current_file)))
-    )
-    return os.path.join(custom_nodes_dir, "ComfyUI-GGUF")
-
-
-def _find_gguf_module() -> Optional[Any]:
-    """Find ComfyUI-GGUF module in sys.modules.
-
-    ComfyUI registers modules using the full path with dots replaced by _x_.
-    """
-    gguf_path = _get_gguf_path()
-    sys_module_name = gguf_path.replace(".", "_x_")
-
-    logger.debug(f"[GGUF Import] Looking for module '{sys_module_name}' in sys.modules")
-    if sys_module_name in sys.modules:
-        logger.info(f"[GGUF Import] Found module: '{sys_module_name}'")
-        return sys.modules[sys_module_name]
-
-    logger.debug(f"[GGUF Import] Module not found: '{sys_module_name}'")
-    return None
-
-
-def _load_gguf_modules_directly() -> Optional[Any]:
-    """Load ComfyUI-GGUF modules directly from file paths."""
-    gguf_path = _get_gguf_path()
-
-    logger.info(f"[GGUF Import] Direct Load: Attempting to load from '{gguf_path}'")
-
-    if not os.path.exists(gguf_path):
-        logger.warning(f"[GGUF Import] Path does not exist: {gguf_path}")
-        return None
-
-    try:
-        namespace = "ComfyUI_GGUF_Dynamic"
-        init_path = os.path.join(gguf_path, "__init__.py")
-
-        if not os.path.exists(init_path):
-            logger.warning(f"[GGUF Import] __init__.py not found at '{init_path}'")
-            return None
-
-        logger.debug(f"[GGUF Import] Loading from '{init_path}'")
-        spec = importlib.util.spec_from_file_location(namespace, init_path)
-        if not spec or not spec.loader:
-            logger.error(f"[GGUF Import] Failed to create spec for '{init_path}'")
-            return None
-
-        package = importlib.util.module_from_spec(spec)
-        package.__path__ = [gguf_path]
-        sys.modules[namespace] = package
-        spec.loader.exec_module(package)
-        logger.debug(f"[GGUF Import] Loaded main package '{namespace}'")
-
-        # Load submodules
-        loaded = []
-        for submod_name in ["loader", "ops", "nodes"]:
-            submod_path = os.path.join(gguf_path, f"{submod_name}.py")
-            if os.path.exists(submod_path):
-                submod_spec = importlib.util.spec_from_file_location(
-                    f"{namespace}.{submod_name}", submod_path
-                )
-                if submod_spec and submod_spec.loader:
-                    submod = importlib.util.module_from_spec(submod_spec)
-                    submod.__package__ = namespace
-                    sys.modules[f"{namespace}.{submod_name}"] = submod
-                    submod_spec.loader.exec_module(submod)
-                    setattr(package, submod_name, submod)
-                    loaded.append(submod_name)
-                    logger.debug(f"[GGUF Import] Loaded submodule '{submod_name}'")
-
-        logger.info(f"[GGUF Import] Direct Load success: {loaded}")
-        return package
-
-    except Exception as e:
-        logger.error(f"[GGUF Import] Direct Load failed: {e}", exc_info=True)
-        return None
-
-
-def get_gguf_modules() -> Tuple[Any, Any, Any]:
-    """Get ComfyUI-GGUF modules (loader, ops, nodes).
-
-    Returns:
-        Tuple of (loader_module, ops_module, nodes_module)
-
-    Raises:
-        RuntimeError: If ComfyUI-GGUF cannot be found or loaded.
-    """
-    logger.debug("[GGUF Import] Starting module search...")
-
-    # Try to find already loaded module first
-    gguf_module = _find_gguf_module()
-
-    if gguf_module is None:
-        logger.info("[GGUF Import] Not found in sys.modules, trying direct load...")
-        gguf_module = _load_gguf_modules_directly()
-
-    if gguf_module is None:
-        raise RuntimeError(
-            "ComfyUI-GGUF is not installed. "
-            "Please install from https://github.com/city96/ComfyUI-GGUF"
-        )
-
-    # Extract submodules
-    loader = getattr(gguf_module, "loader", None)
-    ops = getattr(gguf_module, "ops", None)
-    nodes = getattr(gguf_module, "nodes", None)
-
-    if loader is None or ops is None or nodes is None:
-        missing = [
-            name
-            for name, mod in [("loader", loader), ("ops", ops), ("nodes", nodes)]
-            if mod is None
-        ]
-        raise RuntimeError(f"ComfyUI-GGUF missing submodules: {missing}")
-
-    logger.debug("[GGUF Import] All modules loaded successfully")
-    return loader, ops, nodes
-
-
-def get_gguf_sd_loader():
-    """Get the gguf_sd_loader function from ComfyUI-GGUF."""
-    loader, _, _ = get_gguf_modules()
-    return getattr(loader, "gguf_sd_loader")
-
-
-def get_ggml_ops():
-    """Get the GGMLOps class from ComfyUI-GGUF."""
-    _, ops, _ = get_gguf_modules()
-    return getattr(ops, "GGMLOps")
-
-
-def get_gguf_model_patcher():
-    """Get the GGUFModelPatcher class from ComfyUI-GGUF."""
-    _, _, nodes = get_gguf_modules()
-    return getattr(nodes, "GGUFModelPatcher")

py/nodes/lora_cycler.py

@@ -8,7 +8,6 @@ and tracks the cycle progress which persists across workflow save/load.
 
 import logging
 import os
-
 from ..utils.utils import get_lora_info
 
 logger = logging.getLogger(__name__)
@@ -55,14 +54,8 @@ class LoraCyclerLM:
         current_index = cycler_config.get("current_index", 1)  # 1-based
         model_strength = float(cycler_config.get("model_strength", 1.0))
         clip_strength = float(cycler_config.get("clip_strength", 1.0))
-        use_same_clip_strength = cycler_config.get("use_same_clip_strength", True)
-        use_preset_strength = cycler_config.get("use_preset_strength", False)
-        preset_strength_scale = float(cycler_config.get("preset_strength_scale", 1.0))
         sort_by = "filename"
 
-        # Include "no lora" option
-        include_no_lora = cycler_config.get("include_no_lora", False)
-
         # Dual-index mechanism for batch queue synchronization
         execution_index = cycler_config.get("execution_index")  # Can be None
         # next_index_from_config = cycler_config.get("next_index")  # Not used on backend
@@ -78,10 +71,7 @@ class LoraCyclerLM:
 
         total_count = len(lora_list)
 
-        # Calculate effective total count (includes no lora option if enabled)
+        if total_count == 0:
-        effective_total_count = total_count + 1 if include_no_lora else total_count
-
-        if total_count == 0 and not include_no_lora:
             logger.warning("[LoraCyclerLM] No LoRAs available in pool")
             return {
                 "result": ([],),
@@ -103,99 +93,42 @@ class LoraCyclerLM:
         else:
             actual_index = current_index
 
-        # Clamp index to valid range (1-based, includes no lora if enabled)
+        # Clamp index to valid range (1-based)
-        clamped_index = max(1, min(actual_index, effective_total_count))
+        clamped_index = max(1, min(actual_index, total_count))
 
-        # Check if current index is the "no lora" option (last position when include_no_lora is True)
+        # Get LoRA at current index (convert to 0-based for list access)
-        is_no_lora = include_no_lora and clamped_index == effective_total_count
+        current_lora = lora_list[clamped_index - 1]
 
-        if is_no_lora:
+        # Build LORA_STACK with single LoRA
-            # "No LoRA" option - return empty stack
+        lora_path, _ = get_lora_info(current_lora["file_name"])
+        if not lora_path:
+            logger.warning(
+                f"[LoraCyclerLM] Could not find path for LoRA: {current_lora['file_name']}"
+            )
             lora_stack = []
-            current_lora_name = "No LoRA"
-            current_lora_filename = "No LoRA"
         else:
-            # Get LoRA at current index (convert to 0-based for list access)
+            # Normalize path separators
-            current_lora = lora_list[clamped_index - 1]
+            lora_path = lora_path.replace("/", os.sep)
-            current_lora_name = current_lora["file_name"]
+            lora_stack = [(lora_path, model_strength, clip_strength)]
-            current_lora_filename = current_lora["file_name"]
-
-            # Build LORA_STACK with single LoRA
-            if current_lora["file_name"] == "None":
-                lora_path = None
-            else:
-                lora_path, _ = get_lora_info(current_lora["file_name"])
-
-            if not lora_path:
-                if current_lora["file_name"] != "None":
-                    logger.warning(
-                        f"[LoraCyclerLM] Could not find path for LoRA: {current_lora['file_name']}"
-                    )
-                lora_stack = []
-            else:
-                # Normalize path separators
-                lora_path = lora_path.replace("/", os.sep)
-
-                if use_preset_strength:
-                    lora_metadata = await lora_service.get_lora_metadata_by_filename(
-                        current_lora["file_name"]
-                    )
-                    if lora_metadata:
-                        recommended_strength = (
-                            lora_service.get_recommended_strength_from_lora_data(
-                                lora_metadata
-                            )
-                        )
-                        if recommended_strength is not None:
-                            model_strength = round(
-                                recommended_strength * preset_strength_scale, 2
-                            )
-
-                        if use_same_clip_strength:
-                            clip_strength = model_strength
-                        else:
-                            recommended_clip_strength = (
-                                lora_service.get_recommended_clip_strength_from_lora_data(
-                                    lora_metadata
-                                )
-                            )
-                            if recommended_clip_strength is not None:
-                                clip_strength = round(
-                                    recommended_clip_strength * preset_strength_scale, 2
-                                )
-                    elif use_same_clip_strength:
-                        clip_strength = model_strength
-                elif use_same_clip_strength:
-                    clip_strength = model_strength
-
-                lora_stack = [(lora_path, model_strength, clip_strength)]
 
         # Calculate next index (wrap to 1 if at end)
         next_index = clamped_index + 1
-        if next_index > effective_total_count:
+        if next_index > total_count:
             next_index = 1
 
         # Get next LoRA for UI display (what will be used next generation)
-        is_next_no_lora = include_no_lora and next_index == effective_total_count
+        next_lora = lora_list[next_index - 1]
-        if is_next_no_lora:
+        next_display_name = next_lora["file_name"]
-            next_display_name = "No LoRA"
-            next_lora_filename = "No LoRA"
-        else:
-            next_lora = lora_list[next_index - 1]
-            next_display_name = next_lora["file_name"]
-            next_lora_filename = next_lora["file_name"]
 
         return {
             "result": (lora_stack,),
             "ui": {
                 "current_index": [clamped_index],
                 "next_index": [next_index],
-                "total_count": [
+                "total_count": [total_count],
-                    total_count
+                "current_lora_name": [current_lora["file_name"]],
-                ],  # Return actual LoRA count, not effective_total_count
+                "current_lora_filename": [current_lora["file_name"]],
-                "current_lora_name": [current_lora_name],
-                "current_lora_filename": [current_lora_filename],
                 "next_lora_name": [next_display_name],
-                "next_lora_filename": [next_lora_filename],
+                "next_lora_filename": [next_lora["file_name"]],
             },
         }

py/nodes/lora_loader.py

@@ -1,139 +1,21 @@
-import importlib
 import logging
 import re
-
+from nodes import LoraLoader
-import comfy.sd  # type: ignore
+from ..utils.utils import get_lora_info
-import comfy.utils  # type: ignore
+from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list, nunchaku_load_lora
-
-from ..utils.utils import get_lora_info_absolute
-from .utils import (
-    FlexibleOptionalInputType,
-    any_type,
-    apply_lora_syntax_format,
-    detect_nunchaku_model_kind,
-    extract_lora_name,
-    get_loras_list,
-    nunchaku_load_lora,
-)
 
 logger = logging.getLogger(__name__)
 
-
-def _get_nunchaku_load_qwen_loras():
-    try:
-        module = importlib.import_module(".nunchaku_qwen", __package__)
-    except ImportError as exc:
-        raise RuntimeError(
-            "Qwen-Image LoRA loading requires the ComfyUI runtime with its torch dependency available."
-        ) from exc
-    return module.nunchaku_load_qwen_loras
-
-
-def _collect_stack_entries(lora_stack):
-    entries = []
-    if not lora_stack:
-        return entries
-
-    for lora_path, model_strength, clip_strength in lora_stack:
-        lora_name = extract_lora_name(lora_path)
-        absolute_lora_path, trigger_words = get_lora_info_absolute(lora_name)
-        entries.append({
-            "name": lora_name,
-            "absolute_path": absolute_lora_path,
-            "input_path": lora_path,
-            "model_strength": float(model_strength),
-            "clip_strength": float(clip_strength),
-            "trigger_words": trigger_words,
-        })
-    return entries
-
-
-def _collect_widget_entries(kwargs):
-    entries = []
-    for lora in get_loras_list(kwargs):
-        if not lora.get("active", False):
-            continue
-        lora_name = apply_lora_syntax_format(lora["name"])
-        model_strength = float(lora["strength"])
-        clip_strength = float(lora.get("clipStrength", model_strength))
-        lora_path, trigger_words = get_lora_info_absolute(lora_name)
-        entries.append({
-            "name": lora_name,
-            "absolute_path": lora_path,
-            "input_path": lora_path,
-            "model_strength": model_strength,
-            "clip_strength": clip_strength,
-            "trigger_words": trigger_words,
-        })
-    return entries
-
-
-def _format_loaded_loras(loaded_loras):
-    formatted_loras = []
-    for item in loaded_loras:
-        if item["include_clip_strength"]:
-            formatted_loras.append(
-                f"<lora:{item['name']}:{item['model_strength']}:{item['clip_strength']}>"
-            )
-        else:
-            formatted_loras.append(f"<lora:{item['name']}:{item['model_strength']}>")
-    return " ".join(formatted_loras)
-
-
-def _apply_entries(model, clip, lora_entries, nunchaku_model_kind):
-    loaded_loras = []
-    all_trigger_words = []
-
-    if nunchaku_model_kind == "qwen_image":
-        nunchaku_load_qwen_loras = _get_nunchaku_load_qwen_loras()
-        qwen_lora_configs = []
-        for entry in lora_entries:
-            qwen_lora_configs.append((entry["absolute_path"], entry["model_strength"]))
-            loaded_loras.append({
-                "name": entry["name"],
-                "model_strength": entry["model_strength"],
-                "clip_strength": entry["model_strength"],
-                "include_clip_strength": False,
-            })
-            all_trigger_words.extend(entry["trigger_words"])
-        if qwen_lora_configs:
-            model = nunchaku_load_qwen_loras(model, qwen_lora_configs)
-        return model, clip, loaded_loras, all_trigger_words
-
-    for entry in lora_entries:
-        if nunchaku_model_kind == "flux":
-            model = nunchaku_load_lora(model, entry["input_path"], entry["model_strength"])
-        else:
-            lora = comfy.utils.load_torch_file(entry["absolute_path"], safe_load=True)
-            model, clip = comfy.sd.load_lora_for_models(
-                model,
-                clip,
-                lora,
-                entry["model_strength"],
-                entry["clip_strength"],
-            )
-
-        include_clip_strength = nunchaku_model_kind is None and abs(entry["model_strength"] - entry["clip_strength"]) > 0.001
-        loaded_loras.append({
-            "name": entry["name"],
-            "model_strength": entry["model_strength"],
-            "clip_strength": entry["clip_strength"],
-            "include_clip_strength": include_clip_strength,
-        })
-        all_trigger_words.extend(entry["trigger_words"])
-
-    return model, clip, loaded_loras, all_trigger_words
-
-
 class LoraLoaderLM:
     NAME = "Lora Loader (LoraManager)"
     CATEGORY = "Lora Manager/loaders"
-
+    
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
                 "model": ("MODEL",),
+                # "clip": ("CLIP",),
                 "text": ("AUTOCOMPLETE_TEXT_LORAS", {
                     "placeholder": "Search LoRAs to add...",
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
@@ -145,30 +27,111 @@ class LoraLoaderLM:
     RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING")
     RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
     FUNCTION = "load_loras"
-
+    
     def load_loras(self, model, text, **kwargs):
         """Loads multiple LoRAs based on the kwargs input and lora_stack."""
-        del text
+        loaded_loras = []
-        clip = kwargs.get("clip", None)
+        all_trigger_words = []
-        lora_entries = _collect_stack_entries(kwargs.get("lora_stack", None))
+        
-        lora_entries.extend(_collect_widget_entries(kwargs))
+        clip = kwargs.get('clip', None)
-
+        lora_stack = kwargs.get('lora_stack', None)
-        nunchaku_model_kind = detect_nunchaku_model_kind(model)
+        
-        if nunchaku_model_kind == "flux":
+        # Check if model is a Nunchaku Flux model - simplified approach
-            logger.info("Detected Nunchaku Flux model")
+        is_nunchaku_model = False
-        elif nunchaku_model_kind == "qwen_image":
+        
-            logger.info("Detected Nunchaku Qwen-Image model")
+        try:
-
+            model_wrapper = model.model.diffusion_model
-        model, clip, loaded_loras, all_trigger_words = _apply_entries(model, clip, lora_entries, nunchaku_model_kind)
+            # Check if model is a Nunchaku Flux model using only class name
+            if model_wrapper.__class__.__name__ == "ComfyFluxWrapper":
+                is_nunchaku_model = True
+                logger.info("Detected Nunchaku Flux model")
+        except (AttributeError, TypeError):
+            # Not a model with the expected structure
+            pass
+        
+        # First process lora_stack if available
+        if lora_stack:
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Apply the LoRA using the appropriate loader
+                if is_nunchaku_model:
+                    # Use our custom function for Flux models
+                    model = nunchaku_load_lora(model, lora_path, model_strength)
+                    # clip remains unchanged for Nunchaku models
+                else:
+                    # Use default loader for standard models
+                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                
+                # Extract lora name for trigger words lookup
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = get_lora_info(lora_name)
+                
+                all_trigger_words.extend(trigger_words)
+                # Add clip strength to output if different from model strength (except for Nunchaku models)
+                if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
+        
+        # Then process loras from kwargs with support for both old and new formats
+        loras_list = get_loras_list(kwargs)
+        for lora in loras_list:
+            if not lora.get('active', False):
+                continue
+                
+            lora_name = lora['name']
+            model_strength = float(lora['strength'])
+            # Get clip strength - use model strength as default if not specified
+            clip_strength = float(lora.get('clipStrength', model_strength))
+            
+            # Get lora path and trigger words
+            lora_path, trigger_words = get_lora_info(lora_name)
+            
+            # Apply the LoRA using the appropriate loader
+            if is_nunchaku_model:
+                # For Nunchaku models, use our custom function
+                model = nunchaku_load_lora(model, lora_path, model_strength)
+                # clip remains unchanged
+            else:
+                # Use default loader for standard models
+                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength and not a Nunchaku model
+            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
+            
+            # Add trigger words to collection
+            all_trigger_words.extend(trigger_words)
+        
+        # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-        formatted_loras_text = _format_loaded_loras(loaded_loras)
+        
-        return (model, clip, trigger_words_text, formatted_loras_text)
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0]
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
 
+        return (model, clip, trigger_words_text, formatted_loras_text)
 
 class LoraTextLoaderLM:
     NAME = "LoRA Text Loader (LoraManager)"
     CATEGORY = "Lora Manager/loaders"
-
+    
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -176,55 +139,128 @@ class LoraTextLoaderLM:
                 "model": ("MODEL",),
                 "lora_syntax": ("STRING", {
                     "forceInput": True,
-                    "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
+                    "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation"
                 }),
             },
             "optional": {
                 "clip": ("CLIP",),
                 "lora_stack": ("LORA_STACK",),
-            },
+            }
         }
 
     RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING")
     RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
     FUNCTION = "load_loras_from_text"
-
+    
     def parse_lora_syntax(self, text):
         """Parse LoRA syntax from text input."""
-        pattern = r"<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>"
+        # Pattern to match <lora:name:strength> or <lora:name:model_strength:clip_strength>
+        pattern = r'<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>'
         matches = re.findall(pattern, text, re.IGNORECASE)
-
+        
         loras = []
         for match in matches:
+            lora_name = match[0]
             model_strength = float(match[1])
+            clip_strength = float(match[2]) if match[2] else model_strength
+            
             loras.append({
-                "name": match[0],
+                'name': lora_name,
-                "model_strength": model_strength,
+                'model_strength': model_strength,
-                "clip_strength": float(match[2]) if match[2] else model_strength,
+                'clip_strength': clip_strength
             })
+        
         return loras
-
+    
     def load_loras_from_text(self, model, lora_syntax, clip=None, lora_stack=None):
         """Load LoRAs based on text syntax input."""
-        lora_entries = _collect_stack_entries(lora_stack)
+        loaded_loras = []
-        for lora in self.parse_lora_syntax(lora_syntax):
+        all_trigger_words = []
-            lora_path, trigger_words = get_lora_info_absolute(lora["name"])
+        
-            lora_entries.append({
+        # Check if model is a Nunchaku Flux model - simplified approach
-                "name": lora["name"],
+        is_nunchaku_model = False
-                "absolute_path": lora_path,
+        
-                "input_path": lora_path,
+        try:
-                "model_strength": lora["model_strength"],
+            model_wrapper = model.model.diffusion_model
-                "clip_strength": lora["clip_strength"],
+            # Check if model is a Nunchaku Flux model using only class name
-                "trigger_words": trigger_words,
+            if model_wrapper.__class__.__name__ == "ComfyFluxWrapper":
-            })
+                is_nunchaku_model = True
-
+                logger.info("Detected Nunchaku Flux model")
-        nunchaku_model_kind = detect_nunchaku_model_kind(model)
+        except (AttributeError, TypeError):
-        if nunchaku_model_kind == "flux":
+            # Not a model with the expected structure
-            logger.info("Detected Nunchaku Flux model")
+            pass
-        elif nunchaku_model_kind == "qwen_image":
+        
-            logger.info("Detected Nunchaku Qwen-Image model")
+        # First process lora_stack if available
-
+        if lora_stack:
-        model, clip, loaded_loras, all_trigger_words = _apply_entries(model, clip, lora_entries, nunchaku_model_kind)
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Apply the LoRA using the appropriate loader
+                if is_nunchaku_model:
+                    # Use our custom function for Flux models
+                    model = nunchaku_load_lora(model, lora_path, model_strength)
+                    # clip remains unchanged for Nunchaku models
+                else:
+                    # Use default loader for standard models
+                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                
+                # Extract lora name for trigger words lookup
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = get_lora_info(lora_name)
+                
+                all_trigger_words.extend(trigger_words)
+                # Add clip strength to output if different from model strength (except for Nunchaku models)
+                if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
+        
+        # Parse and process LoRAs from text syntax
+        parsed_loras = self.parse_lora_syntax(lora_syntax)
+        for lora in parsed_loras:
+            lora_name = lora['name']
+            model_strength = lora['model_strength']
+            clip_strength = lora['clip_strength']
+            
+            # Get lora path and trigger words
+            lora_path, trigger_words = get_lora_info(lora_name)
+            
+            # Apply the LoRA using the appropriate loader
+            if is_nunchaku_model:
+                # For Nunchaku models, use our custom function
+                model = nunchaku_load_lora(model, lora_path, model_strength)
+                # clip remains unchanged
+            else:
+                # Use default loader for standard models
+                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength and not a Nunchaku model
+            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
+            
+            # Add trigger words to collection
+            all_trigger_words.extend(trigger_words)
+        
+        # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-        formatted_loras_text = _format_loaded_loras(loaded_loras)
+
-        return (model, clip, trigger_words_text, formatted_loras_text)
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0].strip()
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
+
+        return (model, clip, trigger_words_text, formatted_loras_text)

py/nodes/lora_pool.py

@@ -82,7 +82,6 @@ class LoraPoolLM:
                 "folders": {"include": [], "exclude": []},
                 "favoritesOnly": False,
                 "license": {"noCreditRequired": False, "allowSelling": False},
-                "namePatterns": {"include": [], "exclude": [], "useRegex": False},
             },
             "preview": {"matchCount": 0, "lastUpdated": 0},
         }

py/nodes/lora_randomizer.py

@@ -7,8 +7,10 @@ and tracks the last used combination for reuse.
 """
 
 import logging
+import random
 import os
 from ..utils.utils import get_lora_info
+from .utils import extract_lora_name
 
 logger = logging.getLogger(__name__)
 

py/nodes/lora_stack_combiner.py

@@ -1,26 +0,0 @@
-class LoraStackCombinerLM:
-    NAME = "Lora Stack Combiner (LoraManager)"
-    CATEGORY = "Lora Manager/stackers"
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "lora_stack_a": ("LORA_STACK",),
-                "lora_stack_b": ("LORA_STACK",),
-            },
-        }
-
-    RETURN_TYPES = ("LORA_STACK",)
-    RETURN_NAMES = ("LORA_STACK",)
-    FUNCTION = "combine_stacks"
-
-    def combine_stacks(self, lora_stack_a, lora_stack_b):
-        combined_stack = []
-
-        if lora_stack_a:
-            combined_stack.extend(lora_stack_a)
-        if lora_stack_b:
-            combined_stack.extend(lora_stack_b)
-
-        return (combined_stack,)

py/nodes/lora_stacker.py

@@ -1,6 +1,6 @@
 import os
 from ..utils.utils import get_lora_info
-from .utils import FlexibleOptionalInputType, any_type, apply_lora_syntax_format, extract_lora_name, get_loras_list
+from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list
 
 import logging
 
@@ -48,7 +48,7 @@ class LoraStackerLM:
             if not lora.get('active', False):
                 continue
                 
-            lora_name = apply_lora_syntax_format(lora['name'])
+            lora_name = lora['name']
             model_strength = float(lora['strength'])
             # Get clip strength - use model strength as default if not specified
             clip_strength = float(lora.get('clipStrength', model_strength))

py/nodes/nunchaku_qwen.py

@@ -1,570 +0,0 @@
-from __future__ import annotations
-
-"""Qwen-Image LoRA support for Nunchaku models.
-
-Portions of the LoRA mapping/application logic in this file are adapted from
-ComfyUI-QwenImageLoraLoader by GitHub user ussoewwin:
-https://github.com/ussoewwin/ComfyUI-QwenImageLoraLoader
-
-The upstream project is licensed under Apache License 2.0.
-"""
-
-import copy
-import logging
-import os
-import re
-from collections import defaultdict
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-
-import comfy.utils  # type: ignore
-import folder_paths  # type: ignore
-import torch
-import torch.nn as nn
-from safetensors import safe_open
-
-from nunchaku.lora.flux.nunchaku_converter import (
-    pack_lowrank_weight,
-    unpack_lowrank_weight,
-)
-
-logger = logging.getLogger(__name__)
-
-KEY_MAPPING = [
-    (re.compile(r"^(layers)[._](\d+)[._]attention[._]to[._]([qkv])$"), r"\1.\2.attention.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(layers)[._](\d+)[._]feed_forward[._](w1|w3)$"), r"\1.\2.feed_forward.net.0.proj", "glu", lambda m: m.group(3)),
-    (re.compile(r"^(layers)[._](\d+)[._]feed_forward[._]w2$"), r"\1.\2.feed_forward.net.2", "regular", None),
-    (re.compile(r"^(layers)[._](\d+)[._](.*)$"), r"\1.\2.\3", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]to[._]([qkv])$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._](q|k|v)[._]proj$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]add[._](q|k|v)[._]proj$"), r"\1.\2.attn.add_qkv_proj", "add_qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]out[._]proj[._]context$"), r"\1.\2.attn.to_add_out", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]out[._]proj$"), r"\1.\2.attn.to_out.0", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]to[._]out$"), r"\1.\2.attn.to_out.0", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]attn[._]to[._]([qkv])$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]attn[._]to[._]out$"), r"\1.\2.attn.to_out", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff[._]net[._]0(?:[._]proj)?$"), r"\1.\2.mlp_fc1", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff[._]net[._]2$"), r"\1.\2.mlp_fc2", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff_context[._]net[._]0(?:[._]proj)?$"), r"\1.\2.mlp_context_fc1", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff_context[._]net[._]2$"), r"\1.\2.mlp_context_fc2", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mlp)[._](net)[._](0)[._](proj)$"), r"\1.\2.\3.\4.\5.\6", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mlp)[._](net)[._](2)$"), r"\1.\2.\3.\4.\5", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mlp)[._](net)[._](0)[._](proj)$"), r"\1.\2.\3.\4.\5.\6", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mlp)[._](net)[._](2)$"), r"\1.\2.\3.\4.\5", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mod)[._](1)$"), r"\1.\2.\3.\4", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mod)[._](1)$"), r"\1.\2.\3.\4", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]proj[._]out$"), r"\1.\2.proj_out", "single_proj_out", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]proj[._]mlp$"), r"\1.\2.mlp_fc1", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]norm[._]linear$"), r"\1.\2.norm.linear", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]norm1[._]linear$"), r"\1.\2.norm1.linear", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]norm1_context[._]linear$"), r"\1.\2.norm1_context.linear", "regular", None),
-    (re.compile(r"^(img_in)$"), r"\1", "regular", None),
-    (re.compile(r"^(txt_in)$"), r"\1", "regular", None),
-    (re.compile(r"^(proj_out)$"), r"\1", "regular", None),
-    (re.compile(r"^(norm_out)[._](linear)$"), r"\1.\2", "regular", None),
-    (re.compile(r"^(time_text_embed)[._](timestep_embedder)[._](linear_1)$"), r"\1.\2.\3", "regular", None),
-    (re.compile(r"^(time_text_embed)[._](timestep_embedder)[._](linear_2)$"), r"\1.\2.\3", "regular", None),
-]
-
-_RE_LORA_SUFFIX = re.compile(r"\.(?P<tag>lora(?:[._](?:A|B|down|up)))(?:\.[^.]+)*\.weight$")
-_RE_ALPHA_SUFFIX = re.compile(r"\.(?:alpha|lora_alpha)(?:\.[^.]+)*$")
-
-
-def _rename_layer_underscore_layer_name(old_name: str) -> str:
-    rules = [
-        (r"_(\d+)_attn_to_out_(\d+)", r".\1.attn.to_out.\2"),
-        (r"_(\d+)_img_mlp_net_(\d+)_proj", r".\1.img_mlp.net.\2.proj"),
-        (r"_(\d+)_txt_mlp_net_(\d+)_proj", r".\1.txt_mlp.net.\2.proj"),
-        (r"_(\d+)_img_mlp_net_(\d+)", r".\1.img_mlp.net.\2"),
-        (r"_(\d+)_txt_mlp_net_(\d+)", r".\1.txt_mlp.net.\2"),
-        (r"_(\d+)_img_mod_(\d+)", r".\1.img_mod.\2"),
-        (r"_(\d+)_txt_mod_(\d+)", r".\1.txt_mod.\2"),
-        (r"_(\d+)_attn_", r".\1.attn."),
-    ]
-    new_name = old_name
-    for pattern, replacement in rules:
-        new_name = re.sub(pattern, replacement, new_name)
-    return new_name
-
-
-def _is_indexable_module(module):
-    return isinstance(module, (nn.ModuleList, nn.Sequential, list, tuple))
-
-
-def _get_module_by_name(model: nn.Module, name: str) -> Optional[nn.Module]:
-    if not name:
-        return model
-    module = model
-    for part in name.split("."):
-        if not part:
-            continue
-        if hasattr(module, part):
-            module = getattr(module, part)
-        elif part.isdigit() and _is_indexable_module(module):
-            try:
-                module = module[int(part)]
-            except (IndexError, TypeError):
-                return None
-        else:
-            return None
-    return module
-
-
-def _resolve_module_name(model: nn.Module, name: str) -> Tuple[str, Optional[nn.Module]]:
-    module = _get_module_by_name(model, name)
-    if module is not None:
-        return name, module
-
-    replacements = [
-        (".attn.to_out.0", ".attn.to_out"),
-        (".attention.to_qkv", ".attention.qkv"),
-        (".attention.to_out.0", ".attention.out"),
-        (".feed_forward.net.0.proj", ".feed_forward.w13"),
-        (".feed_forward.net.2", ".feed_forward.w2"),
-        (".ff.net.0.proj", ".mlp_fc1"),
-        (".ff.net.2", ".mlp_fc2"),
-        (".ff_context.net.0.proj", ".mlp_context_fc1"),
-        (".ff_context.net.2", ".mlp_context_fc2"),
-    ]
-    for src, dst in replacements:
-        if src in name:
-            alt = name.replace(src, dst)
-            module = _get_module_by_name(model, alt)
-            if module is not None:
-                return alt, module
-    return name, None
-
-
-def _classify_and_map_key(key: str) -> Optional[Tuple[str, str, Optional[str], str]]:
-    normalized = key
-    if normalized.startswith("transformer."):
-        normalized = normalized[len("transformer."):]
-    if normalized.startswith("diffusion_model."):
-        normalized = normalized[len("diffusion_model."):]
-    if normalized.startswith("lora_unet_"):
-        normalized = _rename_layer_underscore_layer_name(normalized[len("lora_unet_"):])
-
-    match = _RE_LORA_SUFFIX.search(normalized)
-    if match:
-        tag = match.group("tag")
-        base = normalized[:match.start()]
-        ab = "A" if ("lora_A" in tag or tag.endswith(".A") or "down" in tag) else "B"
-    else:
-        match = _RE_ALPHA_SUFFIX.search(normalized)
-        if not match:
-            return None
-        base = normalized[:match.start()]
-        ab = "alpha"
-
-    for pattern, template, group, comp_fn in KEY_MAPPING:
-        key_match = pattern.match(base)
-        if key_match:
-            return group, key_match.expand(template), comp_fn(key_match) if comp_fn else None, ab
-    return None
-
-
-def _detect_lora_format(lora_state_dict: Dict[str, torch.Tensor]) -> bool:
-    standard_patterns = (
-        ".lora_up.",
-        ".lora_down.",
-        ".lora_A.",
-        ".lora_B.",
-        ".lora.up.",
-        ".lora.down.",
-        ".lora.A.",
-        ".lora.B.",
-    )
-    return any(pattern in key for key in lora_state_dict for pattern in standard_patterns)
-
-
-def _load_lora_state_dict(path_or_dict: Union[str, Path, Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
-    if isinstance(path_or_dict, dict):
-        return path_or_dict
-    path = Path(path_or_dict)
-    if path.suffix == ".safetensors":
-        state_dict: Dict[str, torch.Tensor] = {}
-        with safe_open(path, framework="pt", device="cpu") as handle:
-            for key in handle.keys():
-                state_dict[key] = handle.get_tensor(key)
-        return state_dict
-    return comfy.utils.load_torch_file(str(path), safe_load=True)
-
-
-def _fuse_glu_lora(glu_weights: Dict[str, torch.Tensor]) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]:
-    if "w1_A" not in glu_weights or "w3_A" not in glu_weights:
-        return None, None, None
-    a_w1, b_w1 = glu_weights["w1_A"], glu_weights["w1_B"]
-    a_w3, b_w3 = glu_weights["w3_A"], glu_weights["w3_B"]
-    if a_w1.shape[1] != a_w3.shape[1]:
-        return None, None, None
-    a_fused = torch.cat([a_w1, a_w3], dim=0)
-    out1, out3 = b_w1.shape[0], b_w3.shape[0]
-    rank1, rank3 = b_w1.shape[1], b_w3.shape[1]
-    b_fused = torch.zeros(out1 + out3, rank1 + rank3, dtype=b_w1.dtype, device=b_w1.device)
-    b_fused[:out1, :rank1] = b_w1
-    b_fused[out1:, rank1:] = b_w3
-    return a_fused, b_fused, glu_weights.get("w1_alpha")
-
-
-def _fuse_qkv_lora(qkv_weights: Dict[str, torch.Tensor], model: Optional[nn.Module] = None, base_key: Optional[str] = None) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]:
-    required_keys = ["Q_A", "Q_B", "K_A", "K_B", "V_A", "V_B"]
-    if not all(key in qkv_weights for key in required_keys):
-        return None, None, None
-    a_q, a_k, a_v = qkv_weights["Q_A"], qkv_weights["K_A"], qkv_weights["V_A"]
-    b_q, b_k, b_v = qkv_weights["Q_B"], qkv_weights["K_B"], qkv_weights["V_B"]
-    if not (a_q.shape == a_k.shape == a_v.shape):
-        return None, None, None
-    if not (b_q.shape[1] == b_k.shape[1] == b_v.shape[1]):
-        return None, None, None
-
-    out_features = None
-    if model is not None and base_key is not None:
-        _, module = _resolve_module_name(model, base_key)
-        out_features = getattr(module, "out_features", None) if module is not None else None
-
-    alpha_fused = None
-    alpha_q = qkv_weights.get("Q_alpha")
-    alpha_k = qkv_weights.get("K_alpha")
-    alpha_v = qkv_weights.get("V_alpha")
-    if alpha_q is not None and alpha_k is not None and alpha_v is not None and alpha_q.item() == alpha_k.item() == alpha_v.item():
-        alpha_fused = alpha_q
-
-    a_fused = torch.cat([a_q, a_k, a_v], dim=0)
-    rank = b_q.shape[1]
-    out_q, out_k, out_v = b_q.shape[0], b_k.shape[0], b_v.shape[0]
-    total_out = out_features if out_features is not None else out_q + out_k + out_v
-    b_fused = torch.zeros(total_out, 3 * rank, dtype=b_q.dtype, device=b_q.device)
-    b_fused[:out_q, :rank] = b_q
-    b_fused[out_q:out_q + out_k, rank:2 * rank] = b_k
-    b_fused[out_q + out_k:out_q + out_k + out_v, 2 * rank:] = b_v
-    return a_fused, b_fused, alpha_fused
-
-
-def _handle_proj_out_split(lora_dict: Dict[str, Dict[str, torch.Tensor]], base_key: str, model: nn.Module) -> Tuple[Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]], List[str]]:
-    result: Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]] = {}
-    consumed: List[str] = []
-    match = re.search(r"single_transformer_blocks\.(\d+)", base_key)
-    if not match or base_key not in lora_dict:
-        return result, consumed
-    block_idx = match.group(1)
-    block = _get_module_by_name(model, f"single_transformer_blocks.{block_idx}")
-    if block is None:
-        return result, consumed
-    a_full = lora_dict[base_key].get("A")
-    b_full = lora_dict[base_key].get("B")
-    alpha = lora_dict[base_key].get("alpha")
-    attn_to_out = getattr(getattr(block, "attn", None), "to_out", None)
-    mlp_fc2 = getattr(block, "mlp_fc2", None)
-    if a_full is None or b_full is None or attn_to_out is None or mlp_fc2 is None:
-        return result, consumed
-    attn_in = getattr(attn_to_out, "in_features", None)
-    mlp_in = getattr(mlp_fc2, "in_features", None)
-    if attn_in is None or mlp_in is None or a_full.shape[1] != attn_in + mlp_in:
-        return result, consumed
-    result[f"single_transformer_blocks.{block_idx}.attn.to_out"] = (a_full[:, :attn_in], b_full.clone(), alpha)
-    result[f"single_transformer_blocks.{block_idx}.mlp_fc2"] = (a_full[:, attn_in:], b_full.clone(), alpha)
-    consumed.append(base_key)
-    return result, consumed
-
-
-def _apply_lora_to_module(module: nn.Module, a_tensor: torch.Tensor, b_tensor: torch.Tensor, module_name: str, model: nn.Module) -> None:
-    if not hasattr(module, "in_features") or not hasattr(module, "out_features"):
-        raise ValueError(f"{module_name}: unsupported module without in/out features")
-    if a_tensor.shape[1] != module.in_features or b_tensor.shape[0] != module.out_features:
-        raise ValueError(f"{module_name}: LoRA shape mismatch")
-
-    if module.__class__.__name__ == "AWQW4A16Linear" and hasattr(module, "qweight"):
-        if not hasattr(module, "_lora_original_forward"):
-            module._lora_original_forward = module.forward
-        if not hasattr(module, "_nunchaku_lora_bundle"):
-            module._nunchaku_lora_bundle = []
-        module._nunchaku_lora_bundle.append((a_tensor, b_tensor))
-
-        def _awq_lora_forward(x, *args, **kwargs):
-            out = module._lora_original_forward(x, *args, **kwargs)
-            x_flat = x.reshape(-1, module.in_features)
-            for local_a, local_b in module._nunchaku_lora_bundle:
-                local_a = local_a.to(device=out.device, dtype=out.dtype)
-                local_b = local_b.to(device=out.device, dtype=out.dtype)
-                lora_term = (x_flat @ local_a.transpose(0, 1)) @ local_b.transpose(0, 1)
-                try:
-                    out = out + lora_term.reshape(out.shape)
-                except Exception:
-                    pass
-            return out
-
-        module.forward = _awq_lora_forward
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        model._lora_slots[module_name] = {"type": "awq_w4a16"}
-        return
-
-    if hasattr(module, "proj_down") and hasattr(module, "proj_up"):
-        proj_down = unpack_lowrank_weight(module.proj_down.data, down=True)
-        proj_up = unpack_lowrank_weight(module.proj_up.data, down=False)
-        base_rank = proj_down.shape[0] if proj_down.shape[1] == module.in_features else proj_down.shape[1]
-        if proj_down.shape[1] == module.in_features:
-            updated_down = torch.cat([proj_down, a_tensor], dim=0)
-            axis_down = 0
-        else:
-            updated_down = torch.cat([proj_down, a_tensor.T], dim=1)
-            axis_down = 1
-        updated_up = torch.cat([proj_up, b_tensor], dim=1)
-        module.proj_down.data = pack_lowrank_weight(updated_down, down=True)
-        module.proj_up.data = pack_lowrank_weight(updated_up, down=False)
-        module.rank = base_rank + a_tensor.shape[0]
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        model._lora_slots[module_name] = {
-            "type": "nunchaku",
-            "base_rank": base_rank,
-            "axis_down": axis_down,
-        }
-        return
-
-    if isinstance(module, nn.Linear):
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        if module_name not in model._lora_slots:
-            model._lora_slots[module_name] = {
-                "type": "linear",
-                "original_weight": module.weight.detach().cpu().clone(),
-            }
-        module.weight.data.add_((b_tensor @ a_tensor).to(dtype=module.weight.dtype, device=module.weight.device))
-        return
-
-    raise ValueError(f"{module_name}: unsupported module type {type(module)}")
-
-
-def reset_lora_v2(model: nn.Module) -> None:
-    slots = getattr(model, "_lora_slots", None)
-    if not slots:
-        return
-    for name, info in list(slots.items()):
-        module = _get_module_by_name(model, name)
-        if module is None:
-            continue
-        module_type = info.get("type", "nunchaku")
-        if module_type == "nunchaku":
-            base_rank = info["base_rank"]
-            proj_down = unpack_lowrank_weight(module.proj_down.data, down=True)
-            proj_up = unpack_lowrank_weight(module.proj_up.data, down=False)
-            if info.get("axis_down", 0) == 0:
-                proj_down = proj_down[:base_rank, :].clone()
-            else:
-                proj_down = proj_down[:, :base_rank].clone()
-            proj_up = proj_up[:, :base_rank].clone()
-            module.proj_down.data = pack_lowrank_weight(proj_down, down=True)
-            module.proj_up.data = pack_lowrank_weight(proj_up, down=False)
-            module.rank = base_rank
-        elif module_type == "linear" and "original_weight" in info:
-            module.weight.data.copy_(info["original_weight"].to(device=module.weight.device, dtype=module.weight.dtype))
-        elif module_type == "awq_w4a16":
-            if hasattr(module, "_lora_original_forward"):
-                module.forward = module._lora_original_forward
-            for attr in ("_lora_original_forward", "_nunchaku_lora_bundle"):
-                if hasattr(module, attr):
-                    delattr(module, attr)
-    model._lora_slots = {}
-
-
-def compose_loras_v2(model: nn.Module, lora_configs: List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]], apply_awq_mod: bool = True) -> bool:
-    del apply_awq_mod  # retained for interface compatibility
-    reset_lora_v2(model)
-    aggregated_weights: Dict[str, List[Dict[str, object]]] = defaultdict(list)
-    saw_supported_format = False
-    unresolved_targets = 0
-
-    for index, (path_or_dict, strength) in enumerate(lora_configs):
-        if abs(strength) < 1e-5:
-            continue
-        lora_name = str(path_or_dict) if not isinstance(path_or_dict, dict) else f"lora_{index}"
-        lora_state_dict = _load_lora_state_dict(path_or_dict)
-        if not lora_state_dict or not _detect_lora_format(lora_state_dict):
-            logger.warning("Skipping unsupported Qwen LoRA: %s", lora_name)
-            continue
-        saw_supported_format = True
-
-        grouped_weights: Dict[str, Dict[str, torch.Tensor]] = defaultdict(dict)
-        for key, value in lora_state_dict.items():
-            parsed = _classify_and_map_key(key)
-            if parsed is None:
-                continue
-            group, base_key, component, ab = parsed
-            if component and ab:
-                grouped_weights[base_key][f"{component}_{ab}"] = value
-            else:
-                grouped_weights[base_key][ab] = value
-
-        processed_groups: Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]] = {}
-        handled: set[str] = set()
-        for base_key, weights in grouped_weights.items():
-            if base_key in handled:
-                continue
-            a_tensor = b_tensor = alpha = None
-            if "qkv" in base_key or "add_qkv_proj" in base_key:
-                a_tensor, b_tensor, alpha = _fuse_qkv_lora(weights, model=model, base_key=base_key)
-            elif "w1_A" in weights or "w3_A" in weights:
-                a_tensor, b_tensor, alpha = _fuse_glu_lora(weights)
-            elif ".proj_out" in base_key and "single_transformer_blocks" in base_key:
-                split_map, consumed = _handle_proj_out_split(grouped_weights, base_key, model)
-                processed_groups.update(split_map)
-                handled.update(consumed)
-                continue
-            else:
-                a_tensor, b_tensor, alpha = weights.get("A"), weights.get("B"), weights.get("alpha")
-            if a_tensor is not None and b_tensor is not None:
-                processed_groups[base_key] = (a_tensor, b_tensor, alpha)
-
-        for module_name, (a_tensor, b_tensor, alpha) in processed_groups.items():
-            aggregated_weights[module_name].append({
-                "A": a_tensor,
-                "B": b_tensor,
-                "alpha": alpha,
-                "strength": strength,
-            })
-
-    for module_name, weight_list in aggregated_weights.items():
-        resolved_name, module = _resolve_module_name(model, module_name)
-        if module is None:
-            logger.warning("Skipping unresolved Qwen LoRA target: %s", module_name)
-            unresolved_targets += 1
-            continue
-        all_a = []
-        all_b_scaled = []
-        for item in weight_list:
-            a_tensor = item["A"]
-            b_tensor = item["B"]
-            alpha = item["alpha"]
-            strength = float(item["strength"])
-            rank = a_tensor.shape[0]
-            scale = strength * ((alpha / rank) if alpha is not None else 1.0)
-            if module.__class__.__name__ == "AWQW4A16Linear" and hasattr(module, "qweight"):
-                target_dtype = torch.float16
-                target_device = module.qweight.device
-            elif hasattr(module, "proj_down"):
-                target_dtype = module.proj_down.dtype
-                target_device = module.proj_down.device
-            elif hasattr(module, "weight"):
-                target_dtype = module.weight.dtype
-                target_device = module.weight.device
-            else:
-                target_dtype = torch.float16
-                target_device = "cuda" if torch.cuda.is_available() else "cpu"
-            all_a.append(a_tensor.to(dtype=target_dtype, device=target_device))
-            all_b_scaled.append((b_tensor * scale).to(dtype=target_dtype, device=target_device))
-        if not all_a:
-            continue
-        _apply_lora_to_module(module, torch.cat(all_a, dim=0), torch.cat(all_b_scaled, dim=1), resolved_name, model)
-
-    slot_count = len(getattr(model, "_lora_slots", {}) or {})
-    logger.info(
-        "Qwen LoRA composition finished: requested=%d supported=%s applied_targets=%d unresolved=%d",
-        len(lora_configs),
-        saw_supported_format,
-        slot_count,
-        unresolved_targets,
-    )
-    return saw_supported_format
-
-
-class ComfyQwenImageWrapperLM(nn.Module):
-    def __init__(self, model: nn.Module, config=None, apply_awq_mod: bool = True):
-        super().__init__()
-        self.model = model
-        self.config = {} if config is None else config
-        self.dtype = next(model.parameters()).dtype
-        self.loras: List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]] = []
-        self._applied_loras: Optional[List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]]] = None
-        self.apply_awq_mod = apply_awq_mod
-
-    def __getattr__(self, name):
-        try:
-            inner = object.__getattribute__(self, "_modules").get("model")
-        except (AttributeError, KeyError):
-            inner = None
-        if inner is None:
-            raise AttributeError(f"{type(self).__name__!s} has no attribute {name}")
-        if name == "model":
-            return inner
-        return getattr(inner, name)
-
-    def process_img(self, *args, **kwargs):
-        return self.model.process_img(*args, **kwargs)
-
-    def _ensure_composed(self):
-        if self._applied_loras != self.loras or (not self.loras and getattr(self.model, "_lora_slots", None)):
-            is_supported_format = compose_loras_v2(self.model, self.loras, apply_awq_mod=self.apply_awq_mod)
-            self._applied_loras = self.loras.copy()
-            has_slots = bool(getattr(self.model, "_lora_slots", None))
-            if self.loras and is_supported_format and not has_slots:
-                logger.warning("Qwen LoRA compose produced 0 target modules. Resetting and retrying once.")
-                reset_lora_v2(self.model)
-                compose_loras_v2(self.model, self.loras, apply_awq_mod=self.apply_awq_mod)
-                has_slots = bool(getattr(self.model, "_lora_slots", None))
-                logger.info("Qwen LoRA retry result: applied_targets=%d", len(getattr(self.model, "_lora_slots", {}) or {}))
-
-            offload_manager = getattr(self.model, "offload_manager", None)
-            if offload_manager is not None:
-                offload_settings = {
-                    "num_blocks_on_gpu": getattr(offload_manager, "num_blocks_on_gpu", 1),
-                    "use_pin_memory": getattr(offload_manager, "use_pin_memory", False),
-                }
-                logger.info(
-                    "Rebuilding Qwen offload manager after LoRA compose: num_blocks_on_gpu=%s use_pin_memory=%s",
-                    offload_settings["num_blocks_on_gpu"],
-                    offload_settings["use_pin_memory"],
-                )
-                self.model.set_offload(False)
-                self.model.set_offload(True, **offload_settings)
-
-    def forward(self, *args, **kwargs):
-        self._ensure_composed()
-        return self.model(*args, **kwargs)
-
-
-def _get_qwen_wrapper_and_transformer(model):
-    model_wrapper = model.model.diffusion_model
-    if hasattr(model_wrapper, "model") and hasattr(model_wrapper, "loras"):
-        transformer = model_wrapper.model
-        if transformer.__class__.__name__.endswith("NunchakuQwenImageTransformer2DModel"):
-            return model_wrapper, transformer
-    if model_wrapper.__class__.__name__.endswith("NunchakuQwenImageTransformer2DModel"):
-        wrapped_model = ComfyQwenImageWrapperLM(model_wrapper, getattr(model_wrapper, "config", {}))
-        model.model.diffusion_model = wrapped_model
-        return wrapped_model, wrapped_model.model
-    raise TypeError(f"This LoRA loader only works with Nunchaku Qwen Image models, but got {type(model_wrapper).__name__}.")
-
-
-def nunchaku_load_qwen_loras(model, lora_configs: List[Tuple[str, float]], apply_awq_mod: bool = True):
-    model_wrapper, transformer = _get_qwen_wrapper_and_transformer(model)
-    model_wrapper.apply_awq_mod = apply_awq_mod
-
-    saved_config = None
-    if hasattr(model, "model") and hasattr(model.model, "model_config"):
-        saved_config = model.model.model_config
-        model.model.model_config = None
-
-    model_wrapper.model = None
-    try:
-        ret_model = copy.deepcopy(model)
-    finally:
-        if saved_config is not None:
-            model.model.model_config = saved_config
-        model_wrapper.model = transformer
-
-    ret_model_wrapper = ret_model.model.diffusion_model
-    if saved_config is not None:
-        ret_model.model.model_config = saved_config
-    ret_model_wrapper.model = transformer
-    ret_model_wrapper.apply_awq_mod = apply_awq_mod
-    ret_model_wrapper.loras = list(getattr(model_wrapper, "loras", []))
-
-    for lora_name, lora_strength in lora_configs:
-        lora_path = lora_name if os.path.isfile(lora_name) else folder_paths.get_full_path("loras", lora_name)
-        if not lora_path or not os.path.isfile(lora_path):
-            logger.warning("Skipping Qwen LoRA '%s' because it could not be found", lora_name)
-            continue
-        ret_model_wrapper.loras.append((lora_path, lora_strength))
-
-    return ret_model

py/nodes/prompt.py

@@ -1,39 +1,4 @@
-from __future__ import annotations
+from typing import Any, Optional
-
-from typing import Any
-import inspect
-
-from ..services.wildcard_service import (
-    contains_dynamic_syntax,
-    get_wildcard_service,
-    is_trigger_words_input,
-)
-
-
-class _PromptOptionalInputs:
-    """Lookup that preserves explicit optional inputs and dynamic trigger slots."""
-
-    def __init__(self, explicit_inputs: dict[str, tuple[str, dict[str, Any]]]) -> None:
-        self._explicit_inputs = explicit_inputs
-
-    def __contains__(self, item: object) -> bool:
-        if not isinstance(item, str):
-            return False
-        return item in self._explicit_inputs or is_trigger_words_input(item)
-
-    def __getitem__(self, key: str) -> tuple[str, dict[str, Any]]:
-        if key in self._explicit_inputs:
-            return self._explicit_inputs[key]
-        if is_trigger_words_input(key):
-            return (
-                "STRING",
-                {
-                    "forceInput": True,
-                    "tooltip": "Trigger words to prepend. Connect to add more inputs.",
-                },
-            )
-        raise KeyError(key)
-
 
 class PromptLM:
     """Encodes text (and optional trigger words) into CLIP conditioning."""
@@ -42,91 +7,52 @@ class PromptLM:
     CATEGORY = "Lora Manager/conditioning"
     DESCRIPTION = (
         "Encodes a text prompt using a CLIP model into an embedding that can be used "
-        "to guide the diffusion model towards generating specific images. "
+        "to guide the diffusion model towards generating specific images."
-        "Supports dynamic trigger words inputs and runtime wildcard expansion."
     )
 
     @classmethod
     def INPUT_TYPES(cls):
-        optional_inputs: dict[str, tuple[str, dict[str, Any]]] = {
-            "seed": (
-                "INT",
-                {
-                    "forceInput": True,
-                    "tooltip": "Optional seed for wildcard generation. Leave unconnected for non-deterministic wildcard expansion.",
-                },
-            ),
-            "trigger_words1": (
-                "STRING",
-                {
-                    "forceInput": True,
-                    "tooltip": "Trigger words to prepend. Connect to add more inputs.",
-                },
-            ),
-        }
-
-        stack = inspect.stack()
-        if len(stack) > 2 and stack[2].function == "get_input_info":
-            optional_inputs = _PromptOptionalInputs(optional_inputs)  # type: ignore[assignment]
-
         return {
             "required": {
                 "text": (
                     "AUTOCOMPLETE_TEXT_PROMPT,STRING",
                     {
                         "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
-                        "placeholder": "Enter prompt... /character, /artist, /wildcard for quick search",
+                        "placeholder": "Enter prompt... /char, /artist for quick tag search",
-                        "tooltip": "The text to be encoded. Wildcard references inserted with /wildcard are expanded at runtime.",
+                        "tooltip": "The text to be encoded.",
                     },
                 ),
                 "clip": (
-                    "CLIP",
+                    'CLIP',
                     {"tooltip": "The CLIP model used for encoding the text."},
                 ),
             },
-            "optional": optional_inputs,
+            "optional": {
+                "trigger_words": (
+                    'STRING',
+                    {
+                        "forceInput": True,
+                        "tooltip": (
+                            "Optional trigger words to prepend to the text before "
+                            "encoding."
+                        )
+                    },
+                )
+            },
         }
 
-    RETURN_TYPES = ("CONDITIONING", "STRING")
+    RETURN_TYPES = ('CONDITIONING', 'STRING',)
-    RETURN_NAMES = ("CONDITIONING", "PROMPT")
+    RETURN_NAMES = ('CONDITIONING', 'PROMPT',)
     OUTPUT_TOOLTIPS = (
         "A conditioning containing the embedded text used to guide the diffusion model.",
     )
     FUNCTION = "encode"
 
-    @classmethod
+    def encode(self, text: str, clip: Any, trigger_words: Optional[str] = None):
-    def IS_CHANGED(
+        prompt = text
-        cls,
-        text: str,
-        clip: Any | None = None,
-        seed: int | None = None,
-        **kwargs: Any,
-    ):
-        del clip, kwargs
-        if contains_dynamic_syntax(text) and seed is None:
-            return float("NaN")
-        return False
-
-    def encode(
-        self,
-        text: str,
-        clip: Any,
-        seed: int | None = None,
-        **kwargs: Any,
-    ):
-        expanded_text = get_wildcard_service().expand_text(text, seed=seed)
-
-        trigger_words = []
-        for key, value in kwargs.items():
-            if is_trigger_words_input(key) and value:
-                trigger_words.append(value)
-
         if trigger_words:
-            prompt = ", ".join(trigger_words + [expanded_text])
+            prompt = ", ".join([trigger_words, text])
-        else:
-            prompt = expanded_text
 
         from nodes import CLIPTextEncode  # type: ignore
-
         conditioning = CLIPTextEncode().encode(clip, prompt)[0]
-        return (conditioning, prompt)
+        return (conditioning, prompt,)

py/nodes/save_image.py

@@ -1,24 +1,17 @@
 import json
 import os
 import re
-import time
-import uuid
-from typing import Any, Dict, Optional
 import numpy as np
-import folder_paths  # type: ignore
+import folder_paths # type: ignore
 from ..services.service_registry import ServiceRegistry
 from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
-from ..utils.constants import CARD_PREVIEW_WIDTH
-from ..utils.exif_utils import ExifUtils
-from ..utils.utils import calculate_recipe_fingerprint, sanitize_folder_name
 from PIL import Image, PngImagePlugin
 import piexif
 import logging
 
 logger = logging.getLogger(__name__)
 
-
 class SaveImageLM:
     NAME = "Save Image (LoraManager)"
     CATEGORY = "Lora Manager/utils"
@@ -30,74 +23,42 @@ class SaveImageLM:
         self.prefix_append = ""
         self.compress_level = 4
         self.counter = 0
-
+    
     # Add pattern format regex for filename substitution
     pattern_format = re.compile(r"(%[^%]+%)")
-
+    
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
                 "images": ("IMAGE",),
-                "filename_prefix": (
+                "filename_prefix": ("STRING", {
-                    "STRING",
+                    "default": "ComfyUI", 
-                    {
+                    "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc."
-                        "default": "ComfyUI",
+                }),
-                        "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc.",
+                "file_format": (["png", "jpeg", "webp"], {
-                    },
+                    "tooltip": "Image format to save as. PNG preserves quality, JPEG is smaller, WebP balances size and quality."
-                ),
+                }),
-                "file_format": (
-                    ["png", "jpeg", "webp"],
-                    {
-                        "tooltip": "Image format to save as. PNG preserves quality, JPEG is smaller, WebP balances size and quality."
-                    },
-                ),
             },
             "optional": {
-                "lossless_webp": (
+                "lossless_webp": ("BOOLEAN", {
-                    "BOOLEAN",
+                    "default": False,
-                    {
+                    "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss."
-                        "default": False,
+                }),
-                        "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss.",
+                "quality": ("INT", {
-                    },
+                    "default": 100, 
-                ),
+                    "min": 1, 
-                "quality": (
+                    "max": 100,
-                    "INT",
+                    "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files."
-                    {
+                }),
-                        "default": 100,
+                "embed_workflow": ("BOOLEAN", {
-                        "min": 1,
+                    "default": False,
-                        "max": 100,
+                    "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats."
-                        "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files.",
+                }),
-                    },
+                "add_counter_to_filename": ("BOOLEAN", {
-                ),
+                    "default": True,
-                "embed_workflow": (
+                    "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images."
-                    "BOOLEAN",
+                }),
-                    {
-                        "default": False,
-                        "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats.",
-                    },
-                ),
-                "save_with_metadata": (
-                    "BOOLEAN",
-                    {
-                        "default": True,
-                        "tooltip": "When enabled, embeds generation parameters into the saved image metadata. Disable to skip writing generation metadata.",
-                    },
-                ),
-                "add_counter_to_filename": (
-                    "BOOLEAN",
-                    {
-                        "default": True,
-                        "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images.",
-                    },
-                ),
-                "save_as_recipe": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                        "tooltip": "Also saves each generated image as a LoRA Manager recipe.",
-                    },
-                ),
             },
             "hidden": {
                 "id": "UNIQUE_ID",
@@ -114,59 +75,57 @@ class SaveImageLM:
     def get_lora_hash(self, lora_name):
         """Get the lora hash from cache"""
         scanner = ServiceRegistry.get_service_sync("lora_scanner")
-
+        
         # Use the new direct filename lookup method
-        if scanner is not None:
+        hash_value = scanner.get_hash_by_filename(lora_name)
-            hash_value = scanner.get_hash_by_filename(lora_name)
+        if hash_value:
-            if hash_value:
+            return hash_value
-                return hash_value
+            
-
         return None
 
     def get_checkpoint_hash(self, checkpoint_path):
         """Get the checkpoint hash from cache"""
         scanner = ServiceRegistry.get_service_sync("checkpoint_scanner")
-
+        
         if not checkpoint_path:
             return None
-
+            
         # Extract basename without extension
         checkpoint_name = os.path.basename(checkpoint_path)
         checkpoint_name = os.path.splitext(checkpoint_name)[0]
-
+        
         # Try direct filename lookup first
-        if scanner is not None:
+        hash_value = scanner.get_hash_by_filename(checkpoint_name)
-            hash_value = scanner.get_hash_by_filename(checkpoint_name)
+        if hash_value:
-            if hash_value:
+            return hash_value
-                return hash_value
+                
-
         return None
 
     def format_metadata(self, metadata_dict):
         """Format metadata in the requested format similar to userComment example"""
         if not metadata_dict:
             return ""
-
+        
         # Helper function to only add parameter if value is not None
         def add_param_if_not_none(param_list, label, value):
             if value is not None:
                 param_list.append(f"{label}: {value}")
-
+        
         # Extract the prompt and negative prompt
-        prompt = metadata_dict.get("prompt", "")
+        prompt = metadata_dict.get('prompt', '')
-        negative_prompt = metadata_dict.get("negative_prompt", "")
+        negative_prompt = metadata_dict.get('negative_prompt', '')
-
+        
         # Extract loras from the prompt if present
-        loras_text = metadata_dict.get("loras", "")
+        loras_text = metadata_dict.get('loras', '')
         lora_hashes = {}
-
+        
         # If loras are found, add them on a new line after the prompt
         if loras_text:
             prompt_with_loras = f"{prompt}\n{loras_text}"
-
+            
             # Extract lora names from the format <lora:name:strength>
-            lora_matches = re.findall(r"<lora:([^:]+):([^>]+)>", loras_text)
+            lora_matches = re.findall(r'<lora:([^:]+):([^>]+)>', loras_text)
-
+            
             # Get hash for each lora
             for lora_name, strength in lora_matches:
                 hash_value = self.get_lora_hash(lora_name)
@@ -174,114 +133,112 @@ class SaveImageLM:
                     lora_hashes[lora_name] = hash_value
         else:
             prompt_with_loras = prompt
-
+        
         # Format the first part (prompt and loras)
         metadata_parts = [prompt_with_loras]
-
+        
         # Add negative prompt
         if negative_prompt:
             metadata_parts.append(f"Negative prompt: {negative_prompt}")
-
+        
         # Format the second part (generation parameters)
         params = []
-
+        
         # Add standard parameters in the correct order
-        if "steps" in metadata_dict:
+        if 'steps' in metadata_dict:
-            add_param_if_not_none(params, "Steps", metadata_dict.get("steps"))
+            add_param_if_not_none(params, "Steps", metadata_dict.get('steps'))
-
+        
         # Combine sampler and scheduler information
         sampler_name = None
         scheduler_name = None
-
+        
-        if "sampler" in metadata_dict:
+        if 'sampler' in metadata_dict:
-            sampler = metadata_dict.get("sampler")
+            sampler = metadata_dict.get('sampler')
             # Convert ComfyUI sampler names to user-friendly names
             sampler_mapping = {
-                "euler": "Euler",
+                'euler': 'Euler',
-                "euler_ancestral": "Euler a",
+                'euler_ancestral': 'Euler a',
-                "dpm_2": "DPM2",
+                'dpm_2': 'DPM2',
-                "dpm_2_ancestral": "DPM2 a",
+                'dpm_2_ancestral': 'DPM2 a',
-                "heun": "Heun",
+                'heun': 'Heun',
-                "dpm_fast": "DPM fast",
+                'dpm_fast': 'DPM fast',
-                "dpm_adaptive": "DPM adaptive",
+                'dpm_adaptive': 'DPM adaptive',
-                "lms": "LMS",
+                'lms': 'LMS',
-                "dpmpp_2s_ancestral": "DPM++ 2S a",
+                'dpmpp_2s_ancestral': 'DPM++ 2S a',
-                "dpmpp_sde": "DPM++ SDE",
+                'dpmpp_sde': 'DPM++ SDE',
-                "dpmpp_sde_gpu": "DPM++ SDE",
+                'dpmpp_sde_gpu': 'DPM++ SDE',
-                "dpmpp_2m": "DPM++ 2M",
+                'dpmpp_2m': 'DPM++ 2M',
-                "dpmpp_2m_sde": "DPM++ 2M SDE",
+                'dpmpp_2m_sde': 'DPM++ 2M SDE',
-                "dpmpp_2m_sde_gpu": "DPM++ 2M SDE",
+                'dpmpp_2m_sde_gpu': 'DPM++ 2M SDE',
-                "ddim": "DDIM",
+                'ddim': 'DDIM'
             }
             sampler_name = sampler_mapping.get(sampler, sampler)
-
+        
-        if "scheduler" in metadata_dict:
+        if 'scheduler' in metadata_dict:
-            scheduler = metadata_dict.get("scheduler")
+            scheduler = metadata_dict.get('scheduler')
             scheduler_mapping = {
-                "normal": "Simple",
+                'normal': 'Simple',
-                "karras": "Karras",
+                'karras': 'Karras',
-                "exponential": "Exponential",
+                'exponential': 'Exponential',
-                "sgm_uniform": "SGM Uniform",
+                'sgm_uniform': 'SGM Uniform',
-                "sgm_quadratic": "SGM Quadratic",
+                'sgm_quadratic': 'SGM Quadratic'
             }
             scheduler_name = scheduler_mapping.get(scheduler, scheduler)
-
+        
         # Add combined sampler and scheduler information
         if sampler_name:
             if scheduler_name:
                 params.append(f"Sampler: {sampler_name} {scheduler_name}")
             else:
                 params.append(f"Sampler: {sampler_name}")
-
+        
         # CFG scale (Use guidance if available, otherwise fall back to cfg_scale or cfg)
-        if "guidance" in metadata_dict:
+        if 'guidance' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("guidance"))
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('guidance'))
-        elif "cfg_scale" in metadata_dict:
+        elif 'cfg_scale' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg_scale"))
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg_scale'))
-        elif "cfg" in metadata_dict:
+        elif 'cfg' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg"))
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg'))
-
+        
         # Seed
-        if "seed" in metadata_dict:
+        if 'seed' in metadata_dict:
-            add_param_if_not_none(params, "Seed", metadata_dict.get("seed"))
+            add_param_if_not_none(params, "Seed", metadata_dict.get('seed'))
-
+        
         # Size
-        if "size" in metadata_dict:
+        if 'size' in metadata_dict:
-            add_param_if_not_none(params, "Size", metadata_dict.get("size"))
+            add_param_if_not_none(params, "Size", metadata_dict.get('size'))
-
+        
         # Model info
-        if "checkpoint" in metadata_dict:
+        if 'checkpoint' in metadata_dict:
             # Ensure checkpoint is a string before processing
-            checkpoint = metadata_dict.get("checkpoint")
+            checkpoint = metadata_dict.get('checkpoint')
             if checkpoint is not None:
                 # Get model hash
                 model_hash = self.get_checkpoint_hash(checkpoint)
-
+                
                 # Extract basename without path
                 checkpoint_name = os.path.basename(checkpoint)
                 # Remove extension if present
                 checkpoint_name = os.path.splitext(checkpoint_name)[0]
-
+                
                 # Add model hash if available
                 if model_hash:
-                    params.append(
+                    params.append(f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}")
-                        f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}"
-                    )
                 else:
                     params.append(f"Model: {checkpoint_name}")
-
+        
         # Add LoRA hashes if available
         if lora_hashes:
             lora_hash_parts = []
             for lora_name, hash_value in lora_hashes.items():
                 lora_hash_parts.append(f"{lora_name}: {hash_value[:10]}")
-
+            
             if lora_hash_parts:
-                params.append(f'Lora hashes: "{", ".join(lora_hash_parts)}"')
+                params.append(f"Lora hashes: \"{', '.join(lora_hash_parts)}\"")
-
+        
         # Combine all parameters with commas
         metadata_parts.append(", ".join(params))
-
+        
         # Join all parts with a new line
         return "\n".join(metadata_parts)
 
@@ -291,43 +248,36 @@ class SaveImageLM:
         """Format filename with metadata values"""
         if not metadata_dict:
             return filename
-
+            
         result = re.findall(self.pattern_format, filename)
         for segment in result:
             parts = segment.replace("%", "").split(":")
             key = parts[0]
-
+            
-            if key == "seed" and "seed" in metadata_dict:
+            if key == "seed" and 'seed' in metadata_dict:
-                seed_value = metadata_dict.get("seed")
+                filename = filename.replace(segment, str(metadata_dict.get('seed', '')))
-                if seed_value is not None:
+            elif key == "width" and 'size' in metadata_dict:
-                    filename = filename.replace(segment, str(seed_value))
+                size = metadata_dict.get('size', 'x')
-                else:
+                w = size.split('x')[0] if isinstance(size, str) else size[0]
-                    # Fallback if seed was not captured by metadata collector
-                    filename = filename.replace(segment, "0")
-            elif key == "width" and "size" in metadata_dict:
-                size = metadata_dict.get("size", "x")
-                w = size.split("x")[0] if isinstance(size, str) else size[0]
                 filename = filename.replace(segment, str(w))
-            elif key == "height" and "size" in metadata_dict:
+            elif key == "height" and 'size' in metadata_dict:
-                size = metadata_dict.get("size", "x")
+                size = metadata_dict.get('size', 'x')
-                h = size.split("x")[1] if isinstance(size, str) else size[1]
+                h = size.split('x')[1] if isinstance(size, str) else size[1]
                 filename = filename.replace(segment, str(h))
-            elif key == "pprompt" and "prompt" in metadata_dict:
+            elif key == "pprompt" and 'prompt' in metadata_dict:
-                prompt = metadata_dict.get("prompt", "").replace("\n", " ")
+                prompt = metadata_dict.get('prompt', '').replace("\n", " ")
-                prompt = sanitize_folder_name(prompt)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
-            elif key == "nprompt" and "negative_prompt" in metadata_dict:
+            elif key == "nprompt" and 'negative_prompt' in metadata_dict:
-                prompt = metadata_dict.get("negative_prompt", "").replace("\n", " ")
+                prompt = metadata_dict.get('negative_prompt', '').replace("\n", " ")
-                prompt = sanitize_folder_name(prompt)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
             elif key == "model":
-                model_value = metadata_dict.get("checkpoint")
+                model_value = metadata_dict.get('checkpoint')
                 if isinstance(model_value, (bytes, os.PathLike)):
                     model_value = str(model_value)
 
@@ -335,14 +285,12 @@ class SaveImageLM:
                     model = "model_unavailable"
                 else:
                     model = os.path.splitext(os.path.basename(model_value))[0]
-                    model = sanitize_folder_name(model)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     model = model[:length]
                 filename = filename.replace(segment, model)
             elif key == "date":
                 from datetime import datetime
-
                 now = datetime.now()
                 date_table = {
                     "yyyy": f"{now.year:04d}",
@@ -363,261 +311,46 @@ class SaveImageLM:
                     for k, v in date_table.items():
                         date_format = date_format.replace(k, v)
                     filename = filename.replace(segment, date_format)
-
+                    
         return filename
 
-    @staticmethod
+    def save_images(self, images, filename_prefix, file_format, id, prompt=None, extra_pnginfo=None, 
-    def _get_cached_model_by_name(scanner, name):
+                   lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
-        cache = getattr(scanner, "_cache", None)
-        if cache is None or not name:
-            return None
-
-        candidates = [
-            name,
-            os.path.basename(name),
-            os.path.splitext(os.path.basename(name))[0],
-        ]
-        for model in getattr(cache, "raw_data", []):
-            file_name = model.get("file_name")
-            if file_name in candidates:
-                return model
-        return None
-
-    def _build_recipe_loras(self, recipe_scanner, lora_stack):
-        lora_matches = re.findall(r"<lora:([^:]+):([^>]+)>", lora_stack or "")
-        lora_scanner = getattr(recipe_scanner, "_lora_scanner", None)
-        loras_data = []
-        base_model_counts = {}
-
-        for name, strength in lora_matches:
-            lora_info = self._get_cached_model_by_name(lora_scanner, name)
-            civitai = (lora_info or {}).get("civitai") or {}
-            civitai_model = civitai.get("model") or {}
-            try:
-                parsed_strength = float(strength)
-            except (TypeError, ValueError):
-                parsed_strength = 1.0
-
-            loras_data.append(
-                {
-                    "file_name": name,
-                    "strength": parsed_strength,
-                    "hash": ((lora_info or {}).get("sha256") or "").lower(),
-                    "modelVersionId": civitai.get("id", 0),
-                    "modelName": civitai_model.get("name", name) if lora_info else "",
-                    "modelVersionName": civitai.get("name", "") if lora_info else "",
-                    "isDeleted": False,
-                    "exclude": False,
-                }
-            )
-
-            base_model = (lora_info or {}).get("base_model")
-            if base_model:
-                base_model_counts[base_model] = base_model_counts.get(base_model, 0) + 1
-
-        return lora_matches, loras_data, base_model_counts
-
-    def _build_recipe_checkpoint(self, recipe_scanner, checkpoint_raw):
-        if not isinstance(checkpoint_raw, str) or not checkpoint_raw.strip():
-            return None
-
-        checkpoint_name = checkpoint_raw.strip()
-        file_name = os.path.splitext(os.path.basename(checkpoint_name))[0]
-        checkpoint_scanner = getattr(recipe_scanner, "_checkpoint_scanner", None)
-        checkpoint_info = self._get_cached_model_by_name(
-            checkpoint_scanner, checkpoint_name
-        )
-
-        if not checkpoint_info:
-            return {
-                "type": "checkpoint",
-                "name": checkpoint_name,
-                "file_name": file_name,
-                "hash": self.get_checkpoint_hash(checkpoint_name) or "",
-            }
-
-        civitai = checkpoint_info.get("civitai") or {}
-        civitai_model = civitai.get("model") or {}
-        file_path = checkpoint_info.get("file_path") or checkpoint_info.get("path") or ""
-        cached_file_name = (
-            checkpoint_info.get("file_name")
-            or (os.path.splitext(os.path.basename(file_path))[0] if file_path else "")
-            or file_name
-        )
-
-        return {
-            "type": "checkpoint",
-            "modelId": civitai_model.get("id", 0),
-            "modelVersionId": civitai.get("id", 0),
-            "name": civitai_model.get("name")
-            or checkpoint_info.get("model_name")
-            or checkpoint_name,
-            "version": civitai.get("name", ""),
-            "hash": (
-                checkpoint_info.get("sha256") or checkpoint_info.get("hash") or ""
-            ).lower(),
-            "file_name": cached_file_name,
-            "modelName": civitai_model.get("name", ""),
-            "modelVersionName": civitai.get("name", ""),
-            "baseModel": checkpoint_info.get("base_model")
-            or civitai.get("baseModel", ""),
-        }
-
-    @staticmethod
-    def _derive_recipe_name(lora_matches):
-        recipe_name_parts = [
-            f"{name.strip()}-{float(strength):.2f}" for name, strength in lora_matches[:3]
-        ]
-        return "_".join(recipe_name_parts) or "recipe"
-
-    @staticmethod
-    def _sync_recipe_cache(recipe_scanner, recipe_data, json_path):
-        cache = getattr(recipe_scanner, "_cache", None)
-        if cache is not None:
-            cache.raw_data.append(recipe_data)
-            cache.sorted_by_name = sorted(
-                cache.raw_data, key=lambda item: item.get("title", "").lower()
-            )
-            cache.sorted_by_date = sorted(
-                cache.raw_data,
-                key=lambda item: (
-                    item.get("modified", item.get("created_date", 0)),
-                    item.get("file_path", ""),
-                ),
-                reverse=True,
-            )
-            recipe_scanner._update_folder_metadata(cache)
-            recipe_scanner._update_fts_index_for_recipe(recipe_data, "add")
-
-        recipe_id = str(recipe_data.get("id", ""))
-        if recipe_id:
-            recipe_scanner._json_path_map[recipe_id] = json_path
-        persistent_cache = getattr(recipe_scanner, "_persistent_cache", None)
-        if persistent_cache:
-            persistent_cache.update_recipe(recipe_data, json_path)
-
-    def _save_image_as_recipe(self, file_path, metadata_dict):
-        if not metadata_dict:
-            raise ValueError("No generation metadata found")
-
-        recipe_scanner = ServiceRegistry.get_service_sync("recipe_scanner")
-        if recipe_scanner is None:
-            raise RuntimeError("Recipe scanner unavailable")
-
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir:
-            raise RuntimeError("Recipes directory unavailable")
-        os.makedirs(recipes_dir, exist_ok=True)
-
-        recipe_id = str(uuid.uuid4())
-        optimized_image, extension = ExifUtils.optimize_image(
-            image_data=file_path,
-            target_width=CARD_PREVIEW_WIDTH,
-            format="webp",
-            quality=85,
-            preserve_metadata=True,
-        )
-        image_path = os.path.normpath(os.path.join(recipes_dir, f"{recipe_id}{extension}"))
-        with open(image_path, "wb") as file_obj:
-            file_obj.write(optimized_image)
-
-        lora_stack = metadata_dict.get("loras", "")
-        lora_matches, loras_data, base_model_counts = self._build_recipe_loras(
-            recipe_scanner, lora_stack
-        )
-        checkpoint_entry = self._build_recipe_checkpoint(
-            recipe_scanner, metadata_dict.get("checkpoint")
-        )
-        most_common_base_model = (
-            max(base_model_counts.items(), key=lambda item: item[1])[0]
-            if base_model_counts
-            else ""
-        )
-        current_time = time.time()
-        recipe_data = {
-            "id": recipe_id,
-            "file_path": image_path,
-            "title": self._derive_recipe_name(lora_matches),
-            "modified": current_time,
-            "created_date": current_time,
-            "base_model": most_common_base_model
-            or (checkpoint_entry or {}).get("baseModel", ""),
-            "loras": loras_data,
-            "gen_params": {
-                key: value
-                for key, value in metadata_dict.items()
-                if key not in ["checkpoint", "loras"]
-            },
-            "loras_stack": lora_stack,
-            "fingerprint": calculate_recipe_fingerprint(loras_data),
-        }
-        if checkpoint_entry:
-            recipe_data["checkpoint"] = checkpoint_entry
-
-        json_path = os.path.normpath(
-            os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-        )
-        with open(json_path, "w", encoding="utf-8") as file_obj:
-            json.dump(recipe_data, file_obj, indent=4, ensure_ascii=False)
-
-        ExifUtils.append_recipe_metadata(image_path, recipe_data)
-        self._sync_recipe_cache(recipe_scanner, recipe_data, json_path)
-
-    def save_images(
-        self,
-        images,
-        filename_prefix,
-        file_format,
-        id,
-        prompt=None,
-        extra_pnginfo=None,
-        lossless_webp=True,
-        quality=100,
-        embed_workflow=False,
-        save_with_metadata=True,
-        add_counter_to_filename=True,
-        save_as_recipe=False,
-    ):
         """Save images with metadata"""
         results = []
 
         # Get metadata using the metadata collector
         raw_metadata = get_metadata()
         metadata_dict = MetadataProcessor.to_dict(raw_metadata, id)
-
+            
         metadata = self.format_metadata(metadata_dict)
-
+        
         # Process filename_prefix with pattern substitution
         filename_prefix = self.format_filename(filename_prefix, metadata_dict)
-
+        
         # Get initial save path info once for the batch
-        full_output_folder, filename, counter, subfolder, processed_prefix = (
+        full_output_folder, filename, counter, subfolder, processed_prefix = folder_paths.get_save_image_path(
-            folder_paths.get_save_image_path(
+            filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
-                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
-            )
         )
-
+        
         # Create directory if it doesn't exist
         if not os.path.exists(full_output_folder):
             os.makedirs(full_output_folder, exist_ok=True)
-
+        
         # Process each image with incrementing counter
         for i, image in enumerate(images):
             # Convert the tensor image to numpy array
-            img = 255.0 * image.cpu().numpy()
+            img = 255. * image.cpu().numpy()
             img = Image.fromarray(np.clip(img, 0, 255).astype(np.uint8))
-
+            
             # Generate filename with counter if needed
             base_filename = filename
             if add_counter_to_filename:
                 # Use counter + i to ensure unique filenames for all images in batch
                 current_counter = counter + i
                 base_filename += f"_{current_counter:05}_"
-
+                
             # Set file extension and prepare saving parameters
-            file: str
-            save_kwargs: Dict[str, Any]
-            pnginfo: Optional[PngImagePlugin.PngInfo] = None
             if file_format == "png":
                 file = base_filename + ".png"
                 file_extension = ".png"
@@ -629,25 +362,18 @@ class SaveImageLM:
                 file_extension = ".jpg"
                 save_kwargs = {"quality": quality, "optimize": True}
             elif file_format == "webp":
-                file = base_filename + ".webp"
+                file = base_filename + ".webp" 
                 file_extension = ".webp"
                 # Add optimization param to control performance
-                save_kwargs = {
+                save_kwargs = {"quality": quality, "lossless": lossless_webp, "method": 0}
-                    "quality": quality,
+            
-                    "lossless": lossless_webp,
-                    "method": 0,
-                }
-            else:
-                raise ValueError(f"Unsupported file format: {file_format}")
-
             # Full save path
             file_path = os.path.join(full_output_folder, file)
-
+            
             # Save the image with metadata
             try:
                 if file_format == "png":
-                    assert pnginfo is not None
+                    if metadata:
-                    if save_with_metadata and metadata:
                         pnginfo.add_text("parameters", metadata)
                     if embed_workflow and extra_pnginfo is not None:
                         workflow_json = json.dumps(extra_pnginfo["workflow"])
@@ -656,14 +382,9 @@ class SaveImageLM:
                     img.save(file_path, format="PNG", **save_kwargs)
                 elif file_format == "jpeg":
                     # For JPEG, use piexif
-                    if save_with_metadata and metadata:
+                    if metadata:
                         try:
-                            exif_dict = {
+                            exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
-                                "Exif": {
-                                    piexif.ExifIFD.UserComment: b"UNICODE\0"
-                                    + metadata.encode("utf-16be")
-                                }
-                            }
                             exif_bytes = piexif.dump(exif_dict)
                             save_kwargs["exif"] = exif_bytes
                         except Exception as e:
@@ -674,63 +395,38 @@ class SaveImageLM:
                         # For WebP, use piexif for metadata
                         exif_dict = {}
 
-                        if save_with_metadata and metadata:
+                        if metadata:
-                            exif_dict["Exif"] = {
+                            exif_dict['Exif'] = {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}
-                                piexif.ExifIFD.UserComment: b"UNICODE\0"
+                        
-                                + metadata.encode("utf-16be")
-                            }
-
                         # Add workflow if needed
                         if embed_workflow and extra_pnginfo is not None:
-                            workflow_json = json.dumps(extra_pnginfo["workflow"])
+                            workflow_json = json.dumps(extra_pnginfo["workflow"]) 
-                            exif_dict["0th"] = {
+                            exif_dict['0th'] = {piexif.ImageIFD.ImageDescription: "Workflow:" + workflow_json}
-                                piexif.ImageIFD.ImageDescription: "Workflow:"
+                            
-                                + workflow_json
-                            }
-
                         exif_bytes = piexif.dump(exif_dict)
                         save_kwargs["exif"] = exif_bytes
                     except Exception as e:
                         logger.error(f"Error adding EXIF data: {e}")
-
+                    
                     img.save(file_path, format="WEBP", **save_kwargs)
-
+                
-                if save_as_recipe:
+                results.append({
-                    try:
+                    "filename": file,
-                        self._save_image_as_recipe(file_path, metadata_dict)
+                    "subfolder": subfolder,
-                    except Exception as e:
+                    "type": self.type
-                        logger.warning(
+                })
-                            "Failed to save image as recipe: %s", e, exc_info=True
+                
-                        )
-
-                results.append(
-                    {"filename": file, "subfolder": subfolder, "type": self.type}
-                )
-
             except Exception as e:
                 logger.error(f"Error saving image: {e}")
-
+        
         return results
 
-    def process_image(
+    def process_image(self, images, id, filename_prefix="ComfyUI", file_format="png", prompt=None, extra_pnginfo=None,
-        self,
+                     lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
-        images,
-        id,
-        filename_prefix="ComfyUI",
-        file_format="png",
-        prompt=None,
-        extra_pnginfo=None,
-        lossless_webp=True,
-        quality=100,
-        embed_workflow=False,
-        save_with_metadata=True,
-        add_counter_to_filename=True,
-        save_as_recipe=False,
-    ):
         """Process and save image with metadata"""
         # Make sure the output directory exists
         os.makedirs(self.output_dir, exist_ok=True)
-
+        
         # If images is already a list or array of images, do nothing; otherwise, convert to list
         if isinstance(images, (list, np.ndarray)):
             pass
@@ -740,24 +436,19 @@ class SaveImageLM:
                 images = [images]
             else:  # Multiple images (batch, height, width, channels)
                 images = [img for img in images]
-
+        
         # Save all images
         results = self.save_images(
-            images,
+            images, 
-            filename_prefix,
+            filename_prefix, 
-            file_format,
+            file_format, 
             id,
-            prompt,
+            prompt, 
             extra_pnginfo,
             lossless_webp,
             quality,
             embed_workflow,
-            save_with_metadata,
+            add_counter_to_filename
-            add_counter_to_filename,
-            save_as_recipe,
         )
-
+        
-        return {
+        return (images,)
-            "result": (images,),
-            "ui": {"images": results},
-        }

py/nodes/text.py

@@ -1,15 +1,10 @@
-from __future__ import annotations
-
-from ..services.wildcard_service import contains_dynamic_syntax, get_wildcard_service
-
-
 class TextLM:
     """A simple text node with autocomplete support."""
 
     NAME = "Text (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = (
-        "A simple text input node with autocomplete support for tags, styles, and wildcard expansion."
+        "A simple text input node with autocomplete support for tags and styles."
     )
 
     @classmethod
@@ -20,17 +15,8 @@ class TextLM:
                     "AUTOCOMPLETE_TEXT_PROMPT,STRING",
                     {
                         "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
-                        "placeholder": "Enter text... /character, /artist, /wildcard for quick search",
+                        "placeholder": "Enter text... /char, /artist for quick tag search",
-                        "tooltip": "The text output. Wildcard references inserted with /wildcard are expanded at runtime.",
+                        "tooltip": "The text output.",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    "INT",
-                    {
-                        "forceInput": True,
-                        "tooltip": "Optional seed for wildcard generation. Leave unconnected for non-deterministic wildcard expansion.",
                     },
                 ),
             },
@@ -38,14 +24,10 @@ class TextLM:
 
     RETURN_TYPES = ("STRING",)
     RETURN_NAMES = ("STRING",)
-    OUTPUT_TOOLTIPS = ("The text output.",)
+    OUTPUT_TOOLTIPS = (
+        "The text output.",
+    )
     FUNCTION = "process"
 
-    @classmethod
+    def process(self, text: str):
-    def IS_CHANGED(cls, text: str, seed: int | None = None):
+        return (text,)
-        if contains_dynamic_syntax(text) and seed is None:
-            return float("NaN")
-        return False
-
-    def process(self, text: str, seed: int | None = None):
-        return (get_wildcard_service().expand_text(text, seed=seed),)

py/nodes/trigger_word_toggle.py

@@ -76,9 +76,6 @@ class TriggerWordToggleLM:
         # Filter out empty strings and return as set
         return set(word for word in words if word)
 
-    def _group_has_child_items(self, item):
-        return isinstance(item, dict) and isinstance(item.get("items"), list)
-
     def process_trigger_words(
         self,
         id,
@@ -115,11 +112,7 @@ class TriggerWordToggleLM:
 
                 if isinstance(trigger_data, list):
                     if group_mode:
-                        if any(self._group_has_child_items(item) for item in trigger_data):
+                        if allow_strength_adjustment:
-                            filtered_groups = self._process_group_items(
-                                trigger_data, allow_strength_adjustment
-                            )
-                        elif allow_strength_adjustment:
                             parsed_items = [
                                 self._parse_trigger_item(
                                     item, allow_strength_adjustment
@@ -181,41 +174,6 @@ class TriggerWordToggleLM:
 
         return (filtered_triggers,)
 
-    def _process_group_items(self, trigger_data, allow_strength_adjustment):
-        filtered_groups = []
-
-        for item in trigger_data:
-            group = self._parse_trigger_item(item, allow_strength_adjustment)
-            if not group["text"] or not group["active"]:
-                continue
-
-            raw_items = item.get("items") if isinstance(item, dict) else None
-            if isinstance(raw_items, list):
-                active_items = []
-                for raw_item in raw_items:
-                    child = self._parse_trigger_item(
-                        raw_item, allow_strength_adjustment=False
-                    )
-                    if child["text"] and child["active"]:
-                        active_items.append(child["text"])
-
-                if not active_items:
-                    continue
-
-                group_text = ", ".join(active_items)
-            else:
-                group_text = group["text"]
-
-            filtered_groups.append(
-                self._format_word_output(
-                    group_text,
-                    group["strength"],
-                    allow_strength_adjustment,
-                )
-            )
-
-        return filtered_groups
-
     def _parse_trigger_item(self, item, allow_strength_adjustment):
         text = (item.get("text") or "").strip()
         active = bool(item.get("active", False))

py/nodes/unet_loader.py

@@ -1,205 +0,0 @@
-import logging
-import os
-from typing import List, Tuple
-import comfy.sd # type: ignore
-from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
-
-logger = logging.getLogger(__name__)
-
-
-class UNETLoaderLM:
-    """UNET Loader with support for extra folder paths
-
-    Loads diffusion models/UNets from both standard ComfyUI folders and LoRA Manager's
-    extra folder paths, providing a unified interface for UNET loading.
-    Supports both regular diffusion models and GGUF format models.
-    """
-
-    NAME = "Unet Loader (LoraManager)"
-    CATEGORY = "Lora Manager/loaders"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        # Get list of unet names from scanner (includes extra folder paths)
-        unet_names = s._get_unet_names()
-        return {
-            "required": {
-                "unet_name": (
-                    unet_names,
-                    {"tooltip": "The name of the diffusion model to load."},
-                ),
-                "weight_dtype": (
-                    ["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],
-                    {"tooltip": "The dtype to use for the model weights."},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL",)
-    RETURN_NAMES = ("MODEL",)
-    OUTPUT_TOOLTIPS = ("The model used for denoising latents.",)
-    FUNCTION = "load_unet"
-
-    @classmethod
-    def _get_unet_names(cls) -> List[str]:
-        """Get list of diffusion model names from scanner cache in ComfyUI format (relative path with extension)"""
-        try:
-            from ..services.service_registry import ServiceRegistry
-            import asyncio
-
-            async def _get_names():
-                scanner = await ServiceRegistry.get_checkpoint_scanner()
-                cache = await scanner.get_cached_data()
-
-                # Get all model roots for calculating relative paths
-                model_roots = scanner.get_model_roots()
-
-                # Filter only diffusion_model type and format names
-                names = []
-                for item in cache.raw_data:
-                    if item.get("sub_type") == "diffusion_model":
-                        file_path = item.get("file_path", "")
-                        if file_path:
-                            # Format using relative path with OS-native separator
-                            formatted_name = _format_model_name_for_comfyui(
-                                file_path, model_roots
-                            )
-                            if formatted_name:
-                                names.append(formatted_name)
-
-                return sorted(names)
-
-            try:
-                loop = asyncio.get_running_loop()
-                import concurrent.futures
-
-                def run_in_thread():
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    try:
-                        return new_loop.run_until_complete(_get_names())
-                    finally:
-                        new_loop.close()
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(run_in_thread)
-                    return future.result()
-            except RuntimeError:
-                return asyncio.run(_get_names())
-        except Exception as e:
-            logger.error(f"Error getting unet names: {e}")
-            return []
-
-    def load_unet(self, unet_name: str, weight_dtype: str) -> Tuple:
-        """Load a diffusion model by name, supporting extra folder paths
-
-        Args:
-            unet_name: The name of the diffusion model to load (relative path with extension)
-            weight_dtype: The dtype to use for model weights
-
-        Returns:
-            Tuple of (MODEL,)
-        """
-        import torch
-
-        # Get absolute path from cache using ComfyUI-style name
-        unet_path, metadata = get_checkpoint_info_absolute(unet_name)
-
-        if metadata is None:
-            raise FileNotFoundError(
-                f"Diffusion model '{unet_name}' not found in LoRA Manager cache. "
-                "Make sure the model is indexed and try again."
-            )
-
-        # Check if it's a GGUF model
-        if unet_path.endswith(".gguf"):
-            return self._load_gguf_unet(unet_path, unet_name, weight_dtype)
-
-        # Load regular diffusion model using ComfyUI's API
-        logger.info(f"Loading diffusion model from: {unet_path}")
-
-        # Build model options based on weight_dtype
-        model_options = {}
-        if weight_dtype == "fp8_e4m3fn":
-            model_options["dtype"] = torch.float8_e4m3fn
-        elif weight_dtype == "fp8_e4m3fn_fast":
-            model_options["dtype"] = torch.float8_e4m3fn
-            model_options["fp8_optimizations"] = True
-        elif weight_dtype == "fp8_e5m2":
-            model_options["dtype"] = torch.float8_e5m2
-
-        model = comfy.sd.load_diffusion_model(unet_path, model_options=model_options)
-        return (model,)
-
-    def _load_gguf_unet(
-        self, unet_path: str, unet_name: str, weight_dtype: str
-    ) -> Tuple:
-        """Load a GGUF format diffusion model
-
-        Args:
-            unet_path: Absolute path to the GGUF file
-            unet_name: Name of the model for error messages
-            weight_dtype: The dtype to use for model weights
-
-        Returns:
-            Tuple of (MODEL,)
-        """
-        import torch
-        from .gguf_import_helper import get_gguf_modules
-
-        # Get ComfyUI-GGUF modules using helper (handles various import scenarios)
-        try:
-            loader_module, ops_module, nodes_module = get_gguf_modules()
-            gguf_sd_loader = getattr(loader_module, "gguf_sd_loader")
-            GGMLOps = getattr(ops_module, "GGMLOps")
-            GGUFModelPatcher = getattr(nodes_module, "GGUFModelPatcher")
-        except RuntimeError as e:
-            raise RuntimeError(f"Cannot load GGUF model '{unet_name}'. {str(e)}")
-
-        logger.info(f"Loading GGUF diffusion model from: {unet_path}")
-
-        try:
-            # Load GGUF state dict
-            sd, extra = gguf_sd_loader(unet_path)
-
-            # Prepare kwargs for metadata if supported
-            kwargs = {}
-            import inspect
-
-            valid_params = inspect.signature(
-                comfy.sd.load_diffusion_model_state_dict
-            ).parameters
-            if "metadata" in valid_params:
-                kwargs["metadata"] = extra.get("metadata", {})
-
-            # Setup custom operations with GGUF support
-            ops = GGMLOps()
-
-            # Handle weight_dtype for GGUF models
-            if weight_dtype in ("default", None):
-                ops.Linear.dequant_dtype = None
-            elif weight_dtype in ["target"]:
-                ops.Linear.dequant_dtype = weight_dtype
-            else:
-                ops.Linear.dequant_dtype = getattr(torch, weight_dtype, None)
-
-            # Load the model
-            model = comfy.sd.load_diffusion_model_state_dict(
-                sd, model_options={"custom_operations": ops}, **kwargs
-            )
-
-            if model is None:
-                raise RuntimeError(
-                    f"Could not detect model type for GGUF diffusion model: {unet_path}"
-                )
-
-            # Wrap with GGUFModelPatcher
-            model = GGUFModelPatcher.clone(model)
-
-            return (model,)
-
-        except Exception as e:
-            logger.error(f"Error loading GGUF diffusion model '{unet_name}': {e}")
-            raise RuntimeError(
-                f"Failed to load GGUF diffusion model '{unet_name}': {str(e)}"
-            )

py/nodes/utils.py

@@ -1,35 +1,33 @@
 class AnyType(str):
-    """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
+  """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
-
-    def __ne__(self, __value: object) -> bool:
-        return False
 
+  def __ne__(self, __value: object) -> bool:
+    return False
 
 # Credit to Regis Gaughan, III (rgthree)
 class FlexibleOptionalInputType(dict):
-    """A special class to make flexible nodes that pass data to our python handlers.
+  """A special class to make flexible nodes that pass data to our python handlers.
 
-    Enables both flexible/dynamic input types (like for Any Switch) or a dynamic number of inputs
+  Enables both flexible/dynamic input types (like for Any Switch) or a dynamic number of inputs
-    (like for Any Switch, Context Switch, Context Merge, Power Lora Loader, etc).
+  (like for Any Switch, Context Switch, Context Merge, Power Lora Loader, etc).
 
-    Note, for ComfyUI, all that's needed is the `__contains__` override below, which tells ComfyUI
+  Note, for ComfyUI, all that's needed is the `__contains__` override below, which tells ComfyUI
-    that our node will handle the input, regardless of what it is.
+  that our node will handle the input, regardless of what it is.
 
-    However, with https://github.com/comfyanonymous/ComfyUI/pull/2666 a large change would occur
+  However, with https://github.com/comfyanonymous/ComfyUI/pull/2666 a large change would occur
-    requiring more details on the input itself. There, we need to return a list/tuple where the first
+  requiring more details on the input itself. There, we need to return a list/tuple where the first
-    item is the type. This can be a real type, or use the AnyType for additional flexibility.
+  item is the type. This can be a real type, or use the AnyType for additional flexibility.
 
-    This should be forwards compatible unless more changes occur in the PR.
+  This should be forwards compatible unless more changes occur in the PR.
-    """
+  """
+  def __init__(self, type):
+    self.type = type
 
-    def __init__(self, type):
+  def __getitem__(self, key):
-        self.type = type
+    return (self.type, )
 
-    def __getitem__(self, key):
+  def __contains__(self, key):
-        return (self.type,)
+    return True
-
-    def __contains__(self, key):
-        return True
 
 
 any_type = AnyType("*")
@@ -39,45 +37,25 @@ import os
 import logging
 import copy
 import sys
-import folder_paths  # type: ignore
+import folder_paths
 
 logger = logging.getLogger(__name__)
 
-
-def get_lora_syntax_format():
-    try:
-        from ..services.settings_manager import get_settings_manager
-        return get_settings_manager().get("lora_syntax_format", "legacy")
-    except Exception:
-        return "legacy"
-
-
-def apply_lora_syntax_format(name):
-    fmt = get_lora_syntax_format()
-    if fmt == "legacy":
-        return name.replace("\\", "/").rstrip("/").split("/")[-1]
-    return name
-
-
 def extract_lora_name(lora_path):
-    normalized = lora_path.replace("\\", "/")
+    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-    basename = os.path.basename(normalized)
+    # Get the basename without extension
-    name_no_ext = os.path.splitext(basename)[0]
+    basename = os.path.basename(lora_path)
-    dirname = os.path.dirname(normalized)
+    return os.path.splitext(basename)[0]
-    if dirname and dirname not in (".", "/") and not normalized.startswith("/"):
-        return apply_lora_syntax_format(f"{dirname}/{name_no_ext}")
-    return apply_lora_syntax_format(name_no_ext)
-
 
 def get_loras_list(kwargs):
     """Helper to extract loras list from either old or new kwargs format"""
-    if "loras" not in kwargs:
+    if 'loras' not in kwargs:
         return []
-
+        
-    loras_data = kwargs["loras"]
+    loras_data = kwargs['loras']
     # Handle new format: {'loras': {'__value__': [...]}}
-    if isinstance(loras_data, dict) and "__value__" in loras_data:
+    if isinstance(loras_data, dict) and '__value__' in loras_data:
-        return loras_data["__value__"]
+        return loras_data['__value__']
     # Handle old format: {'loras': [...]}
     elif isinstance(loras_data, list):
         return loras_data
@@ -86,26 +64,24 @@ def get_loras_list(kwargs):
         logger.warning(f"Unexpected loras format: {type(loras_data)}")
         return []
 
-
 def load_state_dict_in_safetensors(path, device="cpu", filter_prefix=""):
-    """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""
+    """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""  
     import safetensors.torch
-
+    
     state_dict = {}
-    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:  # type: ignore[attr-defined]
+    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:
         for k in f.keys():
             if filter_prefix and not k.startswith(filter_prefix):
                 continue
             state_dict[k.removeprefix(filter_prefix)] = f.get_tensor(k)
     return state_dict
 
-
 def to_diffusers(input_lora):
     """Simplified version of to_diffusers for Flux LoRA conversion"""
     import torch
     from diffusers.utils.state_dict_utils import convert_unet_state_dict_to_peft
-    from diffusers.loaders import FluxLoraLoaderMixin  # type: ignore[attr-defined]
+    from diffusers.loaders import FluxLoraLoaderMixin
-
+    
     if isinstance(input_lora, str):
         tensors = load_state_dict_in_safetensors(input_lora, device="cpu")
     else:
@@ -115,27 +91,22 @@ def to_diffusers(input_lora):
     for k, v in tensors.items():
         if v.dtype not in [torch.float64, torch.float32, torch.bfloat16, torch.float16]:
             tensors[k] = v.to(torch.bfloat16)
-
+    
     new_tensors = FluxLoraLoaderMixin.lora_state_dict(tensors)
     new_tensors = convert_unet_state_dict_to_peft(new_tensors)
 
     return new_tensors
 
-
 def nunchaku_load_lora(model, lora_name, lora_strength):
-    """Load a Flux LoRA for Nunchaku model"""
+    """Load a Flux LoRA for Nunchaku model"""   
     # Get full path to the LoRA file. Allow both direct paths and registered LoRA names.
-    lora_path = (
+    lora_path = lora_name if os.path.isfile(lora_name) else folder_paths.get_full_path("loras", lora_name)
-        lora_name
-        if os.path.isfile(lora_name)
-        else folder_paths.get_full_path("loras", lora_name)
-    )
     if not lora_path or not os.path.isfile(lora_path):
         logger.warning("Skipping LoRA '%s' because it could not be found", lora_name)
         return model
 
     model_wrapper = model.model.diffusion_model
-
+    
     # Try to find copy_with_ctx in the same module as ComfyFluxWrapper
     module_name = model_wrapper.__class__.__module__
     module = sys.modules.get(module_name)
@@ -147,16 +118,14 @@ def nunchaku_load_lora(model, lora_name, lora_strength):
         ret_model_wrapper.loras = [*model_wrapper.loras, (lora_path, lora_strength)]
     else:
         # Fallback to legacy logic
-        logger.warning(
+        logger.warning("Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic.")
-            "Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic."
-        )
         transformer = model_wrapper.model
-
+        
         # Save the transformer temporarily
         model_wrapper.model = None
         ret_model = copy.deepcopy(model)  # copy everything except the model
         ret_model_wrapper = ret_model.model.diffusion_model
-
+        
         # Restore the model and set it for the copy
         model_wrapper.model = transformer
         ret_model_wrapper.model = transformer
@@ -164,36 +133,15 @@ def nunchaku_load_lora(model, lora_name, lora_strength):
 
     # Convert the LoRA to diffusers format
     sd = to_diffusers(lora_path)
-
+    
     # Handle embedding adjustment if needed
     if "transformer.x_embedder.lora_A.weight" in sd:
         new_in_channels = sd["transformer.x_embedder.lora_A.weight"].shape[1]
         assert new_in_channels % 4 == 0
         new_in_channels = new_in_channels // 4
-
+        
         old_in_channels = ret_model.model.model_config.unet_config["in_channels"]
         if old_in_channels < new_in_channels:
             ret_model.model.model_config.unet_config["in_channels"] = new_in_channels
-
+    
-    return ret_model
+    return ret_model
-
-
-def detect_nunchaku_model_kind(model):
-    """Return the supported Nunchaku model kind for a Comfy model, if any."""
-    try:
-        model_wrapper = model.model.diffusion_model
-    except (AttributeError, TypeError):
-        return None
-
-    wrapper_name = model_wrapper.__class__.__name__
-    if wrapper_name == "ComfyFluxWrapper":
-        return "flux"
-
-    inner_model = getattr(model_wrapper, "model", None)
-    inner_name = inner_model.__class__.__name__ if inner_model is not None else ""
-    if wrapper_name.endswith("NunchakuQwenImageTransformer2DModel"):
-        return "qwen_image"
-    if inner_name.endswith("NunchakuQwenImageTransformer2DModel"):
-        return "qwen_image"
-
-    return None

py/nodes/wanvideo_lora_select.py

@@ -1,22 +1,10 @@
-import os
+import folder_paths # type: ignore
-from ..utils.utils import get_lora_info_absolute
+from ..utils.utils import get_lora_info
-from ..config import config
 from .utils import FlexibleOptionalInputType, any_type, get_loras_list
 import logging
 
 logger = logging.getLogger(__name__)
 
-
-def _relpath_within_loras(abs_path):
-    """Return abs_path relative to the first matching lora root, or basename as fallback."""
-    all_roots = list(config.loras_roots or []) + list(config.extra_loras_roots or [])
-    for root in all_roots:
-        try:
-            return os.path.relpath(abs_path, root)
-        except ValueError:
-            continue
-    return os.path.basename(abs_path)
-
 class WanVideoLoraSelectLM:
     NAME = "WanVideo Lora Select (LoraManager)"
     CATEGORY = "Lora Manager/stackers"
@@ -68,13 +56,13 @@ class WanVideoLoraSelectLM:
             clip_strength = float(lora.get('clipStrength', model_strength))
             
             # Get lora path and trigger words
-            lora_path, trigger_words = get_lora_info_absolute(lora_name)
+            lora_path, trigger_words = get_lora_info(lora_name)
             
             # Create lora item for WanVideo format
             lora_item = {
-                "path": lora_path,
+                "path": folder_paths.get_full_path("loras", lora_path),
                 "strength": model_strength,
-                "name": os.path.splitext(_relpath_within_loras(lora_path))[0],
+                "name": lora_path.split(".")[0],
                 "blocks": selected_blocks,
                 "layer_filter": layer_filter,
                 "low_mem_load": low_mem_load,

py/nodes/wanvideo_lora_select_from_text.py

@@ -1,23 +1,11 @@
-import os
+import folder_paths # type: ignore
-from ..utils.utils import get_lora_info_absolute
+from ..utils.utils import get_lora_info
-from ..config import config
 from .utils import any_type 
 import logging
 
 # 初始化日志记录器
 logger = logging.getLogger(__name__)
 
-
-def _relpath_within_loras(abs_path):
-    """Return abs_path relative to the first matching lora root, or basename as fallback."""
-    all_roots = list(config.loras_roots or []) + list(config.extra_loras_roots or [])
-    for root in all_roots:
-        try:
-            return os.path.relpath(abs_path, root)
-        except ValueError:
-            continue
-    return os.path.basename(abs_path)
-
 # 定义新节点的类
 class WanVideoLoraTextSelectLM:
     # 节点在UI中显示的名称
@@ -99,12 +87,12 @@ class WanVideoLoraTextSelectLM:
             else:
                 continue
 
-            lora_path, trigger_words = get_lora_info_absolute(lora_name_raw)
+            lora_path, trigger_words = get_lora_info(lora_name_raw)
 
             lora_item = {
-                "path": lora_path,
+                "path": folder_paths.get_full_path("loras", lora_path),
                 "strength": model_strength,
-                "name": os.path.splitext(_relpath_within_loras(lora_path))[0],
+                "name": lora_path.split(".")[0],
                 "blocks": selected_blocks,
                 "layer_filter": layer_filter,
                 "low_mem_load": low_mem_load,

py/recipes/base.py

@@ -7,7 +7,7 @@ import re
 from typing import Dict, List, Any, Optional, Tuple
 from abc import ABC, abstractmethod
 from ..config import config
-from ..utils.constants import VALID_LORA_TYPES, VALID_CHECKPOINT_SUB_TYPES
+from ..utils.constants import VALID_LORA_TYPES
 from ..utils.civitai_utils import rewrite_preview_url
 
 logger = logging.getLogger(__name__)
@@ -58,52 +58,9 @@ class RecipeMetadataParser(ABC):
             civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
             
             if not civitai_info or error_msg == "Model not found":
-                # CivitAI may fail to resolve a hash that is still being
+                # Model not found or deleted
-                # computed (known CivitAI issue). Before marking as deleted,
+                lora_entry['isDeleted'] = True
-                # try to reconcile with a local model that has the same
+                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
-                # filename and matching AutoV3 hash.
-                reconciled = False
-                file_name = lora_entry.get("file_name")
-                if file_name and recipe_scanner and hash_value:
-                    lora_scanner = getattr(recipe_scanner, "_lora_scanner", None)
-                    if lora_scanner:
-                        try:
-                            # Local import to avoid circular dependency:
-                            # base.py → file_utils → settings_manager → ...
-                            #  → recipe_scanner → enrichment → base.py
-                            from ..utils.file_utils import calculate_autov3  # fmt: skip
-                            cache = await lora_scanner.get_cached_data()
-                            for item in getattr(cache, "raw_data", []):
-                                if item.get("file_name") == file_name:
-                                    local_path = item.get("file_path")
-                                    if local_path and os.path.exists(local_path):
-                                        local_autov3 = calculate_autov3(local_path)
-                                        if local_autov3 and local_autov3 == hash_value:
-                                            lora_entry["existsLocally"] = True
-                                            lora_entry["localPath"] = local_path
-                                            lora_entry["hash"] = item.get("sha256", hash_value)
-                                            if "preview_url" in item:
-                                                lora_entry["thumbnailUrl"] = config.get_preview_static_url(item["preview_url"])
-                                            civ = item.get("civitai") or {}
-                                            if isinstance(civ, dict):
-                                                if civ.get("id") is not None:
-                                                    lora_entry["id"] = civ["id"]
-                                                if civ.get("modelId") is not None:
-                                                    lora_entry["modelId"] = civ["modelId"]
-                                                if civ.get("name"):
-                                                    lora_entry["version"] = civ["name"]
-                                                # model_name is the CivitAI model display
-                                                # name stored directly in the cache column.
-                                                cached_model_name = item.get("model_name")
-                                                if cached_model_name:
-                                                    lora_entry["name"] = cached_model_name
-                                            reconciled = True
-                                            break
-                        except Exception:
-                            pass
-                if not reconciled:
-                    lora_entry['isDeleted'] = True
-                    lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
                 return lora_entry
                 
             # Get model type and validate
@@ -216,20 +173,6 @@ class RecipeMetadataParser(ABC):
                 checkpoint['isDeleted'] = True
                 return checkpoint
 
-            # Validate that the model type is actually a checkpoint.
-            # Unlike populate_lora_from_civitai which has this check,
-            # this function was missing type validation — allowing LoRA
-            # version data to be saved as the recipe's checkpoint when the
-            # wrong version ID was passed downstream (fixed in v2.7+).
-            model_type = civitai_data.get('model', {}).get('type', '').lower()
-            if model_type not in VALID_CHECKPOINT_SUB_TYPES:
-                logger.warning(
-                    f"Cannot populate checkpoint: model version {civitai_data.get('id')} "
-                    f"has type '{model_type}', expected one of {VALID_CHECKPOINT_SUB_TYPES}. "
-                    f"Skipping checkpoint enrichment."
-                )
-                return checkpoint
-
             if 'model' in civitai_data and 'name' in civitai_data['model']:
                 checkpoint['name'] = civitai_data['model']['name']
 

py/recipes/constants.py

@@ -13,5 +13,4 @@ GEN_PARAM_KEYS = [
     'seed',
     'size',
     'clip_skip',
-    'denoising_strength',
 ]

py/recipes/enrichment.py

@@ -1,11 +1,11 @@
 import logging
 import json
+import re
 import os
 from typing import Any, Dict, Optional
 from .merger import GenParamsMerger
 from .base import RecipeMetadataParser
 from ..services.metadata_service import get_default_metadata_provider
-from ..utils.civitai_utils import extract_civitai_image_id
 
 logger = logging.getLogger(__name__)
 
@@ -16,65 +16,54 @@ class RecipeEnricher:
     async def enrich_recipe(
         recipe: Dict[str, Any],
         civitai_client: Any,
-        request_params: Optional[Dict[str, Any]] = None,
+        request_params: Optional[Dict[str, Any]] = None
-        prefetched_civitai_meta_raw: Optional[Dict[str, Any]] = None,
-        prefetched_model_version_id: Optional[int] = None,
     ) -> bool:
         """
         Enrich a recipe dictionary in-place with metadata from Civitai and embedded params.
-
+        
         Args:
             recipe: The recipe dictionary to enrich. Must have 'gen_params' initialized.
             civitai_client: Authenticated Civitai client instance.
             request_params: (Optional) Parameters from a user request (e.g. import).
-            prefetched_civitai_meta_raw: (Optional) Pre-fetched raw meta from Civitai
+            
-                get_image_info, avoiding a duplicate API call.
-            prefetched_model_version_id: (Optional) Pre-fetched model version ID.
-
         Returns:
             bool: True if the recipe was modified, False otherwise.
         """
         updated = False
         gen_params = recipe.get("gen_params", {})
-
+        
-        # 1. Obtain Civitai metadata
+        # 1. Fetch Civitai Info if available
         civitai_meta = None
-        model_version_id = prefetched_model_version_id
+        model_version_id = None
-
+        
-        source_path = recipe.get("source_path", "")
+        source_url = recipe.get("source_url") or recipe.get("source_path", "")
-
+        
-        if prefetched_civitai_meta_raw is not None:
+        # Check if it's a Civitai image URL
-            raw_meta = prefetched_civitai_meta_raw
+        image_id_match = re.search(r'civitai\.com/images/(\d+)', str(source_url))
-            if isinstance(raw_meta, dict):
+        if image_id_match:
-                if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
+            image_id = image_id_match.group(1)
-                    civitai_meta = raw_meta["meta"]
+            try:
-                else:
+                image_info = await civitai_client.get_image_info(image_id)
-                    civitai_meta = raw_meta
+                if image_info:
-        else:
+                    # Handle nested meta often found in Civitai API responses
-            image_id = extract_civitai_image_id(str(source_path))
+                    raw_meta = image_info.get("meta")
-            if image_id:
+                    if isinstance(raw_meta, dict):
-                try:
+                        if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
-                    image_info = await civitai_client.get_image_info(
+                            civitai_meta = raw_meta["meta"]
-                        image_id, source_url=str(source_path)
+                        else:
-                    )
+                            civitai_meta = raw_meta
-                    if image_info:
+                    
-                        raw_meta = image_info.get("meta")
+                    model_version_id = image_info.get("modelVersionId")
-                        if isinstance(raw_meta, dict):
+                    
-                            if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
+                    # If not at top level, check resources in meta
-                                civitai_meta = raw_meta["meta"]
+                    if not model_version_id and civitai_meta:
-                            else:
+                        resources = civitai_meta.get("civitaiResources", [])
-                                civitai_meta = raw_meta
+                        for res in resources:
-
+                            if res.get("type") == "checkpoint":
-                        model_version_id = image_info.get("modelVersionId")
+                                model_version_id = res.get("modelVersionId")
-                except Exception as e:
+                                break
-                    logger.warning(f"Failed to fetch Civitai image info: {e}")
+            except Exception as e:
-
+                logger.warning(f"Failed to fetch Civitai image info: {e}")
-        if not model_version_id and civitai_meta:
-            resources = civitai_meta.get("civitaiResources", [])
-            for res in resources:
-                if res.get("type") == "checkpoint":
-                    model_version_id = res.get("modelVersionId")
-                    break
 
         # 2. Merge Parameters
         # Priority: request_params > civitai_meta > embedded (existing gen_params)
@@ -190,42 +179,27 @@ class RecipeEnricher:
             existing_cp = recipe.get("checkpoint")
             if existing_cp is None:
                 existing_cp = {}
-
-            # Extract baseModel from raw civitai_info before populate_checkpoint_from_civitai
-            # (populate may reject non-checkpoint types and lose this data)
-            base_model_from_civitai: str = ""
-            if isinstance(civitai_info, dict):
-                base_model_from_civitai = civitai_info.get("baseModel", "") or ""
-            elif isinstance(civitai_info, tuple) and len(civitai_info) > 0 and isinstance(civitai_info[0], dict):
-                base_model_from_civitai = civitai_info[0].get("baseModel", "") or ""
-
             checkpoint_data = await RecipeMetadataParser.populate_checkpoint_from_civitai(existing_cp, civitai_info)
-
+            # 1. First, resolve base_model using full data before we format it away
-            # 1. Resolve base_model from checkpoint_data first, then fall back to raw civitai_info
             current_base_model = recipe.get("base_model")
-            resolved_base_model = checkpoint_data.get("baseModel") or base_model_from_civitai
+            resolved_base_model = checkpoint_data.get("baseModel")
             if resolved_base_model:
+                # Update if empty OR if it matches our generic prefix but is less specific
                 is_generic = not current_base_model or current_base_model.lower() in ["flux", "sdxl", "sd15"]
                 if is_generic and resolved_base_model != current_base_model:
                     recipe["base_model"] = resolved_base_model
-
+            
-            # 2. Only format and save checkpoint if it has real data (not just type after type rejection)
+            # 2. Format according to requirements: type, modelId, modelVersionId, modelName, modelVersionName
-            has_checkpoint_data = any([
+            formatted_checkpoint = {
-                checkpoint_data.get("modelId"),
+                "type": "checkpoint",
-                checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
+                "modelId": checkpoint_data.get("modelId"),
-                checkpoint_data.get("name"),
+                "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
-                checkpoint_data.get("version"),
+                "modelName": checkpoint_data.get("name"), # In base.py, 'name' is populated from civitai_data['model']['name']
-            ])
+                "modelVersionName": checkpoint_data.get("version") # In base.py, 'version' is populated from civitai_data['name']
-            if has_checkpoint_data:
+            }
-                formatted_checkpoint = {
+            # Remove None values
-                    "type": "checkpoint",
+            recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
-                    "modelId": checkpoint_data.get("modelId"),
+            
-                    "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
-                    "modelName": checkpoint_data.get("name"),
-                    "modelVersionName": checkpoint_data.get("version"),
-                }
-                recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
-
             return True
         else:
             # Fallback to name extraction if we don't already have one

py/recipes/factory.py

@@ -6,25 +6,23 @@ from .parsers import (
     ComfyMetadataParser,
     MetaFormatParser,
     AutomaticMetadataParser,
-    CivitaiApiMetadataParser,
+    CivitaiApiMetadataParser
-    SuiImageParamsParser,
 )
 from .base import RecipeMetadataParser
 
 logger = logging.getLogger(__name__)
 
-
 class RecipeParserFactory:
     """Factory for creating recipe metadata parsers"""
-
+    
     @staticmethod
-    def create_parser(metadata) -> RecipeMetadataParser | None:
+    def create_parser(metadata) -> RecipeMetadataParser:
         """
         Create appropriate parser based on the metadata content
-
+        
         Args:
             metadata: The metadata from the image (dict or str)
-
+            
         Returns:
             Appropriate RecipeMetadataParser implementation
         """
@@ -36,18 +34,17 @@ class RecipeParserFactory:
             except Exception as e:
                 logger.debug(f"CivitaiApiMetadataParser check failed: {e}")
                 pass
-
+            
             # Convert dict to string for other parsers that expect string input
             try:
                 import json
-
                 metadata_str = json.dumps(metadata)
             except Exception as e:
                 logger.debug(f"Failed to convert dict to JSON string: {e}")
                 return None
         else:
             metadata_str = metadata
-
+        
         # Try ComfyMetadataParser which requires valid JSON
         try:
             if ComfyMetadataParser().is_metadata_matching(metadata_str):
@@ -55,14 +52,7 @@ class RecipeParserFactory:
         except Exception:
             # If JSON parsing fails, move on to other parsers
             pass
-
+        
-        # Try SuiImageParamsParser for SuiImage metadata format
-        try:
-            if SuiImageParamsParser().is_metadata_matching(metadata_str):
-                return SuiImageParamsParser()
-        except Exception:
-            pass
-
         # Check other parsers that expect string input
         if RecipeFormatParser().is_metadata_matching(metadata_str):
             return RecipeFormatParser()

py/recipes/merger.py

@@ -1,33 +1,27 @@
 from typing import Any, Dict, Optional
 import logging
 
-from .constants import GEN_PARAM_KEYS
-
 logger = logging.getLogger(__name__)
 
-
 class GenParamsMerger:
     """Utility to merge generation parameters from multiple sources with priority."""
 
-    ALLOWED_KEYS = set(GEN_PARAM_KEYS)
-
     BLACKLISTED_KEYS = {
         "id", "url", "userId", "username", "createdAt", "updatedAt", "hash", "meta",
         "draft", "extra", "width", "height", "process", "quantity", "workflow",
         "baseModel", "resources", "disablePoi", "aspectRatio", "Created Date",
         "experimental", "civitaiResources", "civitai_resources", "Civitai resources",
         "modelVersionId", "modelId", "hashes", "Model", "Model hash", "checkpoint_hash",
-        "checkpoint", "checksum", "model_checksum", "raw_metadata",
+        "checkpoint", "checksum", "model_checksum"
     }
-
+    
     NORMALIZATION_MAPPING = {
-        "cfg": "cfg_scale",
+        # Civitai specific
         "cfgScale": "cfg_scale",
         "clipSkip": "clip_skip",
         "negativePrompt": "negative_prompt",
+        # Case variations
         "Sampler": "sampler",
-        "sampler_name": "sampler",
-        "scheduler": "sampler",
         "Steps": "steps",
         "Seed": "seed",
         "Size": "size",
@@ -42,40 +36,63 @@ class GenParamsMerger:
     def merge(
         request_params: Optional[Dict[str, Any]] = None,
         civitai_meta: Optional[Dict[str, Any]] = None,
-        embedded_metadata: Optional[Dict[str, Any]] = None,
+        embedded_metadata: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
         Merge generation parameters from three sources.
-
+        
         Priority: request_params > civitai_meta > embedded_metadata
+        
+        Args:
+            request_params: Params provided directly in the import request
+            civitai_meta: Params from Civitai Image API 'meta' field
+            embedded_metadata: Params extracted from image EXIF/embedded metadata
+            
+        Returns:
+            Merged parameters dictionary
         """
-        result: Dict[str, Any] = {}
+        result = {}
 
+        # 1. Start with embedded metadata (lowest priority)
         if embedded_metadata:
-            if "gen_params" in embedded_metadata and isinstance(
+            # If it's a full recipe metadata, we use its gen_params
-                embedded_metadata["gen_params"], dict
+            if "gen_params" in embedded_metadata and isinstance(embedded_metadata["gen_params"], dict):
-            ):
                 GenParamsMerger._update_normalized(result, embedded_metadata["gen_params"])
             else:
+                # Otherwise assume the dict itself contains gen_params
                 GenParamsMerger._update_normalized(result, embedded_metadata)
 
+        # 2. Layer Civitai meta (medium priority)
         if civitai_meta:
             GenParamsMerger._update_normalized(result, civitai_meta)
 
+        # 3. Layer request params (highest priority)
         if request_params:
             GenParamsMerger._update_normalized(result, request_params)
 
-        return result
+        # Filter out blacklisted keys and also the original camelCase keys if they were normalized
+        final_result = {}
+        for k, v in result.items():
+            if k in GenParamsMerger.BLACKLISTED_KEYS:
+                continue
+            if k in GenParamsMerger.NORMALIZATION_MAPPING:
+                continue
+            final_result[k] = v
+            
+        return final_result
 
     @staticmethod
     def _update_normalized(target: Dict[str, Any], source: Dict[str, Any]) -> None:
-        """Update target dict with normalized, persistence-safe keys from source."""
+        """Update target dict with normalized keys from source."""
-        for key, value in source.items():
+        for k, v in source.items():
-            if key in GenParamsMerger.BLACKLISTED_KEYS:
+            normalized_key = GenParamsMerger.NORMALIZATION_MAPPING.get(k, k)
-                continue
+            target[normalized_key] = v
-
+            # Also keep the original key for now if it's not the same, 
-            normalized_key = GenParamsMerger.NORMALIZATION_MAPPING.get(key, key)
+            # so we can filter at the end or avoid losing it if it wasn't supposed to be renamed?
-            if normalized_key not in GenParamsMerger.ALLOWED_KEYS:
+            # Actually, if we rename it, we should probably NOT keep both in 'target' 
-                continue
+            # because we want to filter them out at the end anyway.
-
+            if normalized_key != k:
-            target[normalized_key] = value
+                # If we are overwriting an existing snake_case key with a camelCase one's value,
+                # that's fine because of the priority order of calls to _update_normalized.
+                pass
+            target[k] = v

py/recipes/parsers/__init__.py

@@ -5,7 +5,6 @@ from .comfy import ComfyMetadataParser
 from .meta_format import MetaFormatParser
 from .automatic import AutomaticMetadataParser
 from .civitai_image import CivitaiApiMetadataParser
-from .sui_image_params import SuiImageParamsParser
 
 __all__ = [
     'RecipeFormatParser',
@@ -13,5 +12,4 @@ __all__ = [
     'MetaFormatParser',
     'AutomaticMetadataParser',
     'CivitaiApiMetadataParser',
-    'SuiImageParamsParser',
 ]

py/recipes/parsers/civitai_image.py

@@ -6,20 +6,18 @@ from typing import Dict, Any, Union
 from ..base import RecipeMetadataParser
 from ..constants import GEN_PARAM_KEYS
 from ...services.metadata_service import get_default_metadata_provider
-from ...config import config
 
 logger = logging.getLogger(__name__)
 
-
 class CivitaiApiMetadataParser(RecipeMetadataParser):
     """Parser for Civitai image metadata format"""
-
+    
     def is_metadata_matching(self, metadata) -> bool:
         """Check if the metadata matches the Civitai image metadata format
-
+        
         Args:
             metadata: The metadata from the image (dict)
-
+            
         Returns:
             bool: True if this parser can handle the metadata
         """
@@ -30,7 +28,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             # Check for common CivitAI image metadata fields
             civitai_image_fields = (
                 "resources",
-                "civitaiResources",
+                "civitaiResources", 
                 "additionalResources",
                 "hashes",
                 "prompt",
@@ -42,8 +40,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                 "width",
                 "height",
                 "Model",
-                "Model hash",
+                "Model hash"
-                "modelVersionIds",
             )
             return any(key in payload for key in civitai_image_fields)
 
@@ -53,9 +50,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
         # Check for LoRA hash patterns
         hashes = metadata.get("hashes")
-        if isinstance(hashes, dict) and any(
+        if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
-            str(key).lower().startswith("lora:") for key in hashes
-        ):
             return True
 
         # Check nested meta object (common in CivitAI image responses)
@@ -66,31 +61,22 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
             # Also check for LoRA hash patterns in nested meta
             hashes = nested_meta.get("hashes")
-            if isinstance(hashes, dict) and any(
+            if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
-                str(key).lower().startswith("lora:") for key in hashes
-            ):
                 return True
 
         return False
-
+    
-    async def parse_metadata(  # type: ignore[override]
+    async def parse_metadata(self, metadata, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
-        self, user_comment, recipe_scanner=None, civitai_client=None,
-        local_cache: dict[str, Any] | None = None,
-    ) -> Dict[str, Any]:
         """Parse metadata from Civitai image format
-
+        
         Args:
-            user_comment: The metadata from the image (dict)
+            metadata: The metadata from the image (dict)
             recipe_scanner: Optional recipe scanner service
             civitai_client: Optional Civitai API client (deprecated, use metadata_provider instead)
-            local_cache: Optional dict mapping sha256/autov3 hash → scanner cache item.
+            
-                         When provided, matching models skip CivitAI API calls.
-
         Returns:
             Dict containing parsed recipe data
         """
-        metadata: Dict[str, Any] = user_comment  # type: ignore[assignment]
-        metadata = user_comment
         try:
             # Get metadata provider instead of using civitai_client directly
             metadata_provider = await get_default_metadata_provider()
@@ -114,19 +100,19 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     )
                 ):
                     metadata = inner_meta
-
+            
             # Initialize result structure
             result = {
-                "base_model": None,
+                'base_model': None,
-                "loras": [],
+                'loras': [],
-                "model": None,
+                'model': None,
-                "gen_params": {},
+                'gen_params': {},
-                "from_civitai_image": True,
+                'from_civitai_image': True
             }
-
+            
             # Track already added LoRAs to prevent duplicates
             added_loras = {}  # key: model_version_id or hash, value: index in result["loras"]
-
+            
             # Extract hash information from hashes field for LoRA matching
             lora_hashes = {}
             if "hashes" in metadata and isinstance(metadata["hashes"], dict):
@@ -135,14 +121,14 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     if key_str.lower().startswith("lora:"):
                         lora_name = key_str.split(":", 1)[1]
                         lora_hashes[lora_name] = hash_value
-
+            
             # Extract prompt and negative prompt
             if "prompt" in metadata:
                 result["gen_params"]["prompt"] = metadata["prompt"]
-
+            
             if "negativePrompt" in metadata:
                 result["gen_params"]["negative_prompt"] = metadata["negativePrompt"]
-
+            
             # Extract other generation parameters
             param_mapping = {
                 "steps": "steps",
@@ -152,197 +138,98 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                 "Size": "size",
                 "clipSkip": "clip_skip",
             }
-
+            
             for civitai_key, our_key in param_mapping.items():
                 if civitai_key in metadata and our_key in GEN_PARAM_KEYS:
                     result["gen_params"][our_key] = metadata[civitai_key]
-
+            
             # Extract base model information - directly if available
             if "baseModel" in metadata:
                 result["base_model"] = metadata["baseModel"]
             elif "Model hash" in metadata and metadata_provider:
                 model_hash = metadata["Model hash"]
-                model_info, error = await metadata_provider.get_model_by_hash(
+                model_info, error = await metadata_provider.get_model_by_hash(model_hash)
-                    model_hash
-                )
                 if model_info:
                     result["base_model"] = model_info.get("baseModel", "")
             elif "Model" in metadata and isinstance(metadata.get("resources"), list):
                 # Try to find base model in resources
                 for resource in metadata.get("resources", []):
-                    if resource.get("type") == "model" and resource.get(
+                    if resource.get("type") == "model" and resource.get("name") == metadata.get("Model"):
-                        "name"
-                    ) == metadata.get("Model"):
                         # This is likely the checkpoint model
                         if metadata_provider and resource.get("hash"):
-                            (
+                            model_info, error = await metadata_provider.get_model_by_hash(resource.get("hash"))
-                                model_info,
-                                error,
-                            ) = await metadata_provider.get_model_by_hash(
-                                resource.get("hash")
-                            )
                             if model_info:
                                 result["base_model"] = model_info.get("baseModel", "")
-
+            
             base_model_counts = {}
-
+            
             # Process standard resources array
             if "resources" in metadata and isinstance(metadata["resources"], list):
                 for resource in metadata["resources"]:
-                    resource_type = resource.get("type", "lora")
-
-                    # Track resources with type "model" — these are checkpoint models.
-                    # The resources array is the most reliable source for checkpoint
-                    # identification because it has an explicit type field and hash,
-                    # unlike modelVersionIds which is a flat list with no type info.
-                    if resource_type == "model":
-                        checkpoint_entry = {
-                            "id": 0,
-                            "modelId": 0,
-                            "name": resource.get("name", "Unknown Model"),
-                            "version": "",
-                            "type": resource.get("type", "model"),
-                            "existsLocally": False,
-                            "localPath": None,
-                            "file_name": resource.get("name", ""),
-                            "hash": resource.get("hash", "") or "",
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
-                            "baseModel": "",
-                            "size": 0,
-                            "downloadUrl": "",
-                            "isDeleted": False,
-                        }
-
-                        # Try to look up base model from the checkpoint hash
-                        cp_hash = checkpoint_entry.get("hash")
-                        if cp_hash and metadata_provider:
-                            local_cached = local_cache.get(cp_hash) if local_cache else None
-                            if local_cached:
-                                self._populate_entry_from_cache(
-                                    checkpoint_entry, local_cached
-                                )
-                                bm = checkpoint_entry.get("baseModel", "")
-                                if bm and not result["base_model"]:
-                                    result["base_model"] = bm
-                            else:
-                                try:
-                                    civitai_info = (
-                                        await metadata_provider.get_model_by_hash(
-                                            cp_hash
-                                        )
-                                    )
-                                    civitai_data, error_msg = (
-                                        (civitai_info, None)
-                                        if not isinstance(civitai_info, tuple)
-                                        else civitai_info
-                                    )
-                                    if civitai_data and error_msg != "Model not found":
-                                        if 'model' in civitai_data and 'name' in civitai_data['model']:
-                                            checkpoint_entry['name'] = civitai_data['model']['name']
-                                        checkpoint_entry['id'] = civitai_data.get('id', 0)
-                                        checkpoint_entry['modelId'] = civitai_data.get('modelId', 0)
-                                        if 'name' in civitai_data:
-                                            checkpoint_entry['version'] = civitai_data['name']
-                                        base_model = civitai_data.get('baseModel', '')
-                                        if base_model:
-                                            checkpoint_entry['baseModel'] = base_model
-                                            if not result['base_model']:
-                                                result['base_model'] = base_model
-                                except Exception as e:
-                                    logger.error(
-                                        f"Error fetching checkpoint info for hash "
-                                        f"{cp_hash}: {e}"
-                                    )
-
-                        if result["model"] is None:
-                            result["model"] = checkpoint_entry
-                        continue
-
                     # Modified to process resources without a type field as potential LoRAs
-                    if resource_type == "lora":
+                    if resource.get("type", "lora") == "lora":
                         lora_hash = resource.get("hash", "")
-
+                        
                         # Try to get hash from the hashes field if not present in resource
                         if not lora_hash and resource.get("name"):
                             lora_hash = lora_hashes.get(resource["name"], "")
-
+                        
                         # Skip LoRAs without proper identification (hash or modelVersionId)
                         if not lora_hash and not resource.get("modelVersionId"):
-                            logger.debug(
+                            logger.debug(f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId")
-                                f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId"
-                            )
                             continue
-
+                        
                         # Skip if we've already added this LoRA by hash
                         if lora_hash and lora_hash in added_loras:
                             continue
-
+                        
                         lora_entry = {
-                            "name": resource.get("name", "Unknown LoRA"),
+                            'name': resource.get("name", "Unknown LoRA"),
-                            "type": "lora",
+                            'type': "lora",
-                            "weight": float(resource.get("weight", 1.0)),
+                            'weight': float(resource.get("weight", 1.0)),
-                            "hash": lora_hash,
+                            'hash': lora_hash,
-                            "existsLocally": False,
+                            'existsLocally': False,
-                            "localPath": None,
+                            'localPath': None,
-                            "file_name": resource.get("name", "Unknown"),
+                            'file_name': resource.get("name", "Unknown"),
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
-                            "baseModel": "",
+                            'baseModel': '',
-                            "size": 0,
+                            'size': 0,
-                            "downloadUrl": "",
+                            'downloadUrl': '',
-                            "isDeleted": False,
+                            'isDeleted': False
                         }
-
+                        
                         # Try to get info from Civitai if hash is available
-                        if lora_hash and metadata_provider:
+                        if lora_entry['hash'] and metadata_provider:
-                            local_cached = local_cache.get(lora_hash) if local_cache else None
+                            try:
-                            if local_cached:
+                                civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                                self._populate_entry_from_cache(
+                                
-                                    lora_entry, local_cached
+                                populated_entry = await self.populate_lora_from_civitai(
+                                    lora_entry,
+                                    civitai_info,
+                                    recipe_scanner,
+                                    base_model_counts,
+                                    lora_hash
                                 )
-                                # Track by version ID for deduplication
+                                
-                                if lora_entry.get("id"):
+                                if populated_entry is None:
-                                    added_loras[str(lora_entry["id"])] = len(
+                                    continue  # Skip invalid LoRA types
-                                        result["loras"]
+                                    
-                                    )
+                                lora_entry = populated_entry
-                            else:
+                                
-                                try:
+                                # If we have a version ID from Civitai, track it for deduplication
-                                    civitai_info = (
+                                if 'id' in lora_entry and lora_entry['id']:
-                                        await metadata_provider.get_model_by_hash(lora_hash)
+                                    added_loras[str(lora_entry['id'])] = len(result["loras"])
-                                    )
+                            except Exception as e:
-
+                                logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
-                                    populated_entry = await self.populate_lora_from_civitai(
+                        
-                                        lora_entry,
-                                        civitai_info,
-                                        recipe_scanner,
-                                        base_model_counts,
-                                        lora_hash,
-                                    )
-
-                                    if populated_entry is None:
-                                        continue  # Skip invalid LoRA types
-
-                                    lora_entry = populated_entry
-
-                                    # If we have a version ID from Civitai, track it for deduplication
-                                    if "id" in lora_entry and lora_entry["id"]:
-                                        added_loras[str(lora_entry["id"])] = len(
-                                            result["loras"]
-                                        )
-                                except Exception as e:
-                                    logger.error(
-                                        f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
-                                    )
-
                         # Track by hash if we have it
                         if lora_hash:
                             added_loras[lora_hash] = len(result["loras"])
-
+                            
                         result["loras"].append(lora_entry)
-
+            
             # Process civitaiResources array
-            if "civitaiResources" in metadata and isinstance(
+            if "civitaiResources" in metadata and isinstance(metadata["civitaiResources"], list):
-                metadata["civitaiResources"], list
-            ):
                 for resource in metadata["civitaiResources"]:
                     # Get resource type and identifier
                     resource_type = str(resource.get("type") or "").lower()
@@ -350,39 +237,32 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                     if resource_type == "checkpoint":
                         checkpoint_entry = {
-                            "id": resource.get("modelVersionId", 0),
+                            'id': resource.get("modelVersionId", 0),
-                            "modelId": resource.get("modelId", 0),
+                            'modelId': resource.get("modelId", 0),
-                            "name": resource.get("modelName", "Unknown Checkpoint"),
+                            'name': resource.get("modelName", "Unknown Checkpoint"),
-                            "version": resource.get("modelVersionName", ""),
+                            'version': resource.get("modelVersionName", ""),
-                            "type": resource.get("type", "checkpoint"),
+                            'type': resource.get("type", "checkpoint"),
-                            "existsLocally": False,
+                            'existsLocally': False,
-                            "localPath": None,
+                            'localPath': None,
-                            "file_name": resource.get("modelName", ""),
+                            'file_name': resource.get("modelName", ""),
-                            "hash": resource.get("hash", "") or "",
+                            'hash': resource.get("hash", "") or "",
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
-                            "baseModel": "",
+                            'baseModel': '',
-                            "size": 0,
+                            'size': 0,
-                            "downloadUrl": "",
+                            'downloadUrl': '',
-                            "isDeleted": False,
+                            'isDeleted': False
                         }
 
                         if version_id and metadata_provider:
                             try:
-                                civitai_info = (
+                                civitai_info = await metadata_provider.get_model_version_info(version_id)
-                                    await metadata_provider.get_model_version_info(
-                                        version_id
-                                    )
-                                )
 
-                                checkpoint_entry = (
+                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
-                                    await self.populate_checkpoint_from_civitai(
+                                    checkpoint_entry,
-                                        checkpoint_entry, civitai_info
+                                    civitai_info
-                                    )
                                 )
                             except Exception as e:
-                                logger.error(
+                                logger.error(f"Error fetching Civitai info for checkpoint version {version_id}: {e}")
-                                    f"Error fetching Civitai info for checkpoint version {version_id}: {e}"
-                                )
 
                         if result["model"] is None:
                             result["model"] = checkpoint_entry
@@ -395,35 +275,31 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                     # Initialize lora entry
                     lora_entry = {
-                        "id": resource.get("modelVersionId", 0),
+                        'id': resource.get("modelVersionId", 0),
-                        "modelId": resource.get("modelId", 0),
+                        'modelId': resource.get("modelId", 0),
-                        "name": resource.get("modelName", "Unknown LoRA"),
+                        'name': resource.get("modelName", "Unknown LoRA"),
-                        "version": resource.get("modelVersionName", ""),
+                        'version': resource.get("modelVersionName", ""),
-                        "type": resource.get("type", "lora"),
+                        'type': resource.get("type", "lora"),
-                        "weight": round(float(resource.get("weight", 1.0)), 2),
+                        'weight': round(float(resource.get("weight", 1.0)), 2),
-                        "existsLocally": False,
+                        'existsLocally': False,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
+                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        "baseModel": "",
+                        'baseModel': '',
-                        "size": 0,
+                        'size': 0,
-                        "downloadUrl": "",
+                        'downloadUrl': '',
-                        "isDeleted": False,
+                        'isDeleted': False
                     }
 
                     # Try to get info from Civitai if modelVersionId is available
                     if version_id and metadata_provider:
                         try:
                             # Use get_model_version_info instead of get_model_version
-                            civitai_info = (
+                            civitai_info = await metadata_provider.get_model_version_info(version_id)
-                                await metadata_provider.get_model_version_info(
-                                    version_id
-                                )
-                            )
 
                             populated_entry = await self.populate_lora_from_civitai(
                                 lora_entry,
                                 civitai_info,
                                 recipe_scanner,
-                                base_model_counts,
+                                base_model_counts
                             )
 
                             if populated_entry is None:
@@ -431,148 +307,76 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                             lora_entry = populated_entry
                         except Exception as e:
-                            logger.error(
+                            logger.error(f"Error fetching Civitai info for model version {version_id}: {e}")
-                                f"Error fetching Civitai info for model version {version_id}: {e}"
-                            )
 
                     # Track this LoRA in our deduplication dict
                     if version_id:
                         added_loras[version_id] = len(result["loras"])
 
                     result["loras"].append(lora_entry)
-
+            
             # Process additionalResources array
-            if "additionalResources" in metadata and isinstance(
+            if "additionalResources" in metadata and isinstance(metadata["additionalResources"], list):
-                metadata["additionalResources"], list
-            ):
                 for resource in metadata["additionalResources"]:
                     # Skip resources that aren't LoRAs or LyCORIS
-                    if (
+                    if resource.get("type") not in ["lora", "lycoris"] and "type" not in resource:
-                        resource.get("type") not in ["lora", "lycoris"]
-                        and "type" not in resource
-                    ):
                         continue
-
+                        
                     lora_type = resource.get("type", "lora")
                     name = resource.get("name", "")
-
+                    
                     # Extract ID from URN format if available
                     version_id = None
                     if name and "civitai:" in name:
                         parts = name.split("@")
                         if len(parts) > 1:
                             version_id = parts[1]
-
+                            
                             # Skip if we've already added this LoRA
                             if version_id in added_loras:
                                 continue
-
+                    
                     lora_entry = {
-                        "name": name,
+                        'name': name,
-                        "type": lora_type,
+                        'type': lora_type,
-                        "weight": float(resource.get("strength", 1.0)),
+                        'weight': float(resource.get("strength", 1.0)),
-                        "hash": "",
+                        'hash': "",
-                        "existsLocally": False,
+                        'existsLocally': False,
-                        "localPath": None,
+                        'localPath': None,
-                        "file_name": name,
+                        'file_name': name,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
+                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        "baseModel": "",
+                        'baseModel': '',
-                        "size": 0,
+                        'size': 0,
-                        "downloadUrl": "",
+                        'downloadUrl': '',
-                        "isDeleted": False,
+                        'isDeleted': False
                     }
-
+                    
                     # If we have a version ID and metadata provider, try to get more info
                     if version_id and metadata_provider:
                         try:
                             # Use get_model_version_info with the version ID
-                            civitai_info = (
+                            civitai_info = await metadata_provider.get_model_version_info(version_id)
-                                await metadata_provider.get_model_version_info(
+                            
-                                    version_id
-                                )
-                            )
-
                             populated_entry = await self.populate_lora_from_civitai(
                                 lora_entry,
                                 civitai_info,
                                 recipe_scanner,
-                                base_model_counts,
+                                base_model_counts
                             )
-
+                            
                             if populated_entry is None:
                                 continue  # Skip invalid LoRA types
-
+                                
                             lora_entry = populated_entry
-
+                            
                             # Track this LoRA for deduplication
                             if version_id:
                                 added_loras[version_id] = len(result["loras"])
                         except Exception as e:
-                            logger.error(
+                            logger.error(f"Error fetching Civitai info for model ID {version_id}: {e}")
-                                f"Error fetching Civitai info for model ID {version_id}: {e}"
+                    
-                            )
-
                         result["loras"].append(lora_entry)
 
-            # Process modelVersionIds from Civitai image API
-            # These are model version IDs returned at root level when meta doesn't contain resources
-            if "modelVersionIds" in metadata and isinstance(
-                metadata["modelVersionIds"], list
-            ):
-                for version_id in metadata["modelVersionIds"]:
-                    version_id_str = str(version_id)
-
-                    # Skip if we've already added this LoRA by version ID
-                    if version_id_str in added_loras:
-                        continue
-
-                    # Initialize lora entry with version ID
-                    lora_entry = {
-                        "id": version_id,
-                        "modelId": 0,
-                        "name": "Unknown LoRA",
-                        "version": "",
-                        "type": "lora",
-                        "weight": 1.0,
-                        "existsLocally": False,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
-                        "baseModel": "",
-                        "size": 0,
-                        "downloadUrl": "",
-                        "isDeleted": False,
-                    }
-
-                    # Fetch model info from Civitai
-                    if metadata_provider and version_id_str:
-                        try:
-                            civitai_info = (
-                                await metadata_provider.get_model_version_info(
-                                    version_id_str
-                                )
-                            )
-
-                            populated_entry = await self.populate_lora_from_civitai(
-                                lora_entry,
-                                civitai_info,
-                                recipe_scanner,
-                                base_model_counts,
-                            )
-
-                            if populated_entry is None:
-                                continue  # Skip invalid LoRA types
-
-                            lora_entry = populated_entry
-                        except Exception as e:
-                            logger.error(
-                                f"Error fetching Civitai info for model version {version_id}: {e}"
-                            )
-
-                    # Track this LoRA for deduplication
-                    if version_id_str:
-                        added_loras[version_id_str] = len(result["loras"])
-
-                    result["loras"].append(lora_entry)
-
             # If we found LoRA hashes in the metadata but haven't already
             # populated entries for them, fall back to creating LoRAs from
             # the hashes section. Some Civitai image responses only include
@@ -586,32 +390,30 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     continue
 
                 lora_entry = {
-                    "name": lora_name,
+                    'name': lora_name,
-                    "type": "lora",
+                    'type': "lora",
-                    "weight": 1.0,
+                    'weight': 1.0,
-                    "hash": lora_hash,
+                    'hash': lora_hash,
-                    "existsLocally": False,
+                    'existsLocally': False,
-                    "localPath": None,
+                    'localPath': None,
-                    "file_name": lora_name,
+                    'file_name': lora_name,
-                    "thumbnailUrl": "/loras_static/images/no-preview.png",
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
-                    "baseModel": "",
+                    'baseModel': '',
-                    "size": 0,
+                    'size': 0,
-                    "downloadUrl": "",
+                    'downloadUrl': '',
-                    "isDeleted": False,
+                    'isDeleted': False
                 }
 
                 if metadata_provider:
                     try:
-                        civitai_info = await metadata_provider.get_model_by_hash(
+                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                            lora_hash
-                        )
 
                         populated_entry = await self.populate_lora_from_civitai(
                             lora_entry,
                             civitai_info,
                             recipe_scanner,
                             base_model_counts,
-                            lora_hash,
+                            lora_hash
                         )
 
                         if populated_entry is None:
@@ -619,131 +421,80 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                         lora_entry = populated_entry
 
-                        if "id" in lora_entry and lora_entry["id"]:
+                        if 'id' in lora_entry and lora_entry['id']:
-                            added_loras[str(lora_entry["id"])] = len(result["loras"])
+                            added_loras[str(lora_entry['id'])] = len(result["loras"])
                     except Exception as e:
-                        logger.error(
+                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}")
-                            f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}"
-                        )
 
                 added_loras[lora_hash] = len(result["loras"])
                 result["loras"].append(lora_entry)
 
             # Check for LoRA info in the format "Lora_0 Model hash", "Lora_0 Model name", etc.
             lora_index = 0
-            while (
+            while f"Lora_{lora_index} Model hash" in metadata and f"Lora_{lora_index} Model name" in metadata:
-                f"Lora_{lora_index} Model hash" in metadata
-                and f"Lora_{lora_index} Model name" in metadata
-            ):
                 lora_hash = metadata[f"Lora_{lora_index} Model hash"]
                 lora_name = metadata[f"Lora_{lora_index} Model name"]
-                lora_strength_model = float(
+                lora_strength_model = float(metadata.get(f"Lora_{lora_index} Strength model", 1.0))
-                    metadata.get(f"Lora_{lora_index} Strength model", 1.0)
+                
-                )
-
                 # Skip if we've already added this LoRA by hash
                 if lora_hash and lora_hash in added_loras:
                     lora_index += 1
                     continue
-
+                
                 lora_entry = {
-                    "name": lora_name,
+                    'name': lora_name,
-                    "type": "lora",
+                    'type': "lora",
-                    "weight": lora_strength_model,
+                    'weight': lora_strength_model,
-                    "hash": lora_hash,
+                    'hash': lora_hash,
-                    "existsLocally": False,
+                    'existsLocally': False,
-                    "localPath": None,
+                    'localPath': None,
-                    "file_name": lora_name,
+                    'file_name': lora_name,
-                    "thumbnailUrl": "/loras_static/images/no-preview.png",
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
-                    "baseModel": "",
+                    'baseModel': '',
-                    "size": 0,
+                    'size': 0,
-                    "downloadUrl": "",
+                    'downloadUrl': '',
-                    "isDeleted": False,
+                    'isDeleted': False
                 }
-
+                
                 # Try to get info from Civitai if hash is available
-                if lora_entry["hash"] and metadata_provider:
+                if lora_entry['hash'] and metadata_provider:
                     try:
-                        civitai_info = await metadata_provider.get_model_by_hash(
+                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                            lora_hash
+                        
-                        )
-
                         populated_entry = await self.populate_lora_from_civitai(
                             lora_entry,
                             civitai_info,
                             recipe_scanner,
                             base_model_counts,
-                            lora_hash,
+                            lora_hash
                         )
-
+                        
                         if populated_entry is None:
                             lora_index += 1
                             continue  # Skip invalid LoRA types
-
+                            
                         lora_entry = populated_entry
-
+                        
                         # If we have a version ID from Civitai, track it for deduplication
-                        if "id" in lora_entry and lora_entry["id"]:
+                        if 'id' in lora_entry and lora_entry['id']:
-                            added_loras[str(lora_entry["id"])] = len(result["loras"])
+                            added_loras[str(lora_entry['id'])] = len(result["loras"])
                     except Exception as e:
-                        logger.error(
+                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
-                            f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
+                
-                        )
-
                 # Track by hash if we have it
                 if lora_hash:
                     added_loras[lora_hash] = len(result["loras"])
-
+                    
                 result["loras"].append(lora_entry)
-
+                
                 lora_index += 1
-
+            
             # If base model wasn't found earlier, use the most common one from LoRAs
             if not result["base_model"] and base_model_counts:
-                result["base_model"] = max(
+                result["base_model"] = max(base_model_counts.items(), key=lambda x: x[1])[0]
-                    base_model_counts.items(), key=lambda x: x[1]
+            
-                )[0]
-
             return result
-
+            
         except Exception as e:
             logger.error(f"Error parsing Civitai image metadata: {e}", exc_info=True)
             return {"error": str(e), "loras": []}
-
-    @staticmethod
-    def _populate_entry_from_cache(
-        entry: dict[str, Any],
-        cache_item: dict[str, Any],
-    ) -> None:
-        """Fill a lora/checkpoint entry from a scanner cache item.
-
-        Avoids CivitAI API calls for models that exist locally.
-        Mirrors the population logic in
-        ``RecipeMetadataParser.populate_lora_from_civitai()`` but operates
-        entirely on cached data.
-        """
-        civ = cache_item.get("civitai") or {}
-        if isinstance(civ, dict):
-            if civ.get("id") is not None:
-                entry["id"] = civ["id"]
-            if civ.get("modelId") is not None:
-                entry["modelId"] = civ["modelId"]
-            if civ.get("name"):
-                entry["version"] = civ["name"]
-            cached_name = cache_item.get("model_name")
-            if cached_name:
-                entry["name"] = cached_name
-        entry["existsLocally"] = True
-        local_path = cache_item.get("file_path")
-        if local_path:
-            entry["localPath"] = local_path
-        sha256 = cache_item.get("sha256")
-        if sha256:
-            entry["hash"] = sha256
-        if "preview_url" in cache_item:
-            entry["thumbnailUrl"] = config.get_preview_static_url(
-                cache_item["preview_url"]
-            )
-        base_model = cache_item.get("base_model", "")
-        if base_model:
-            entry["baseModel"] = base_model

py/recipes/parsers/sui_image_params.py

@@ -1,188 +0,0 @@
-"""Parser for SuiImage (Stable Diffusion WebUI) metadata format."""
-
-import json
-import logging
-from typing import Dict, Any, Optional, List
-from ..base import RecipeMetadataParser
-from ...services.metadata_service import get_default_metadata_provider
-
-logger = logging.getLogger(__name__)
-
-
-class SuiImageParamsParser(RecipeMetadataParser):
-    """Parser for SuiImage metadata JSON format.
-
-    This format is used by some Stable Diffusion WebUI variants.
-    Structure:
-    {
-        "sui_image_params": {
-            "prompt": "...",
-            "negativeprompt": "...",
-            "model": "...",
-            "seed": ...,
-            "steps": ...,
-            ...
-        },
-        "sui_models": [
-            {"name": "...", "param": "model", "hash": "..."},
-            ...
-        ],
-        "sui_extra_data": {...}
-    }
-    """
-
-    def is_metadata_matching(self, user_comment: str) -> bool:
-        """Check if the user comment matches the SuiImage metadata format"""
-        try:
-            data = json.loads(user_comment)
-            return isinstance(data, dict) and 'sui_image_params' in data
-        except (json.JSONDecodeError, TypeError):
-            return False
-
-    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
-        """Parse metadata from SuiImage metadata format"""
-        try:
-            metadata_provider = await get_default_metadata_provider()
-
-            data = json.loads(user_comment)
-            params = data.get('sui_image_params', {})
-            models = data.get('sui_models', [])
-
-            # Extract prompt and negative prompt
-            prompt = params.get('prompt', '')
-            negative_prompt = params.get('negativeprompt', '') or params.get('negative_prompt', '')
-
-            # Extract generation parameters
-            gen_params = {}
-            if prompt:
-                gen_params['prompt'] = prompt
-            if negative_prompt:
-                gen_params['negative_prompt'] = negative_prompt
-
-            # Map standard parameters
-            param_mapping = {
-                'steps': 'steps',
-                'seed': 'seed',
-                'cfgscale': 'cfg_scale',
-                'cfg_scale': 'cfg_scale',
-                'width': 'width',
-                'height': 'height',
-                'sampler': 'sampler',
-                'scheduler': 'scheduler',
-                'model': 'model',
-                'vae': 'vae',
-            }
-
-            for src_key, dest_key in param_mapping.items():
-                if src_key in params and params[src_key] is not None:
-                    gen_params[dest_key] = params[src_key]
-
-            # Add size info if available
-            if 'width' in gen_params and 'height' in gen_params:
-                gen_params['size'] = f"{gen_params['width']}x{gen_params['height']}"
-
-            # Process models - extract checkpoint and loras
-            loras: List[Dict[str, Any]] = []
-            checkpoint: Optional[Dict[str, Any]] = None
-
-            for model in models:
-                model_name = model.get('name', '')
-                param_type = model.get('param', '')
-                model_hash = model.get('hash', '')
-
-                # Remove .safetensors extension for cleaner name
-                clean_name = model_name.replace('.safetensors', '') if model_name else ''
-
-                # Check if this is a LoRA by looking at the name or param type
-                is_lora = 'lora' in model_name.lower() or param_type.lower().startswith('lora')
-
-                if is_lora:
-                    lora_entry = {
-                        'id': 0,
-                        'modelId': 0,
-                        'name': clean_name,
-                        'version': '',
-                        'type': 'lora',
-                        'weight': 1.0,
-                        'existsLocally': False,
-                        'localPath': None,
-                        'file_name': model_name,
-                        'hash': model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
-                    }
-
-                    # Try to get additional info from metadata provider
-                    if metadata_provider and model_hash:
-                        try:
-                            civitai_info = await metadata_provider.get_model_by_hash(
-                                model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash
-                            )
-                            if civitai_info:
-                                lora_entry = await self.populate_lora_from_civitai(
-                                    lora_entry, civitai_info, recipe_scanner
-                                )
-                        except Exception as e:
-                            logger.debug(f"Error fetching info for LoRA {clean_name}: {e}")
-
-                    if lora_entry:
-                        loras.append(lora_entry)
-                elif param_type == 'model' or 'lora' not in model_name.lower():
-                    # This is likely a checkpoint
-                    checkpoint_entry = {
-                        'id': 0,
-                        'modelId': 0,
-                        'name': clean_name,
-                        'version': '',
-                        'type': 'checkpoint',
-                        'hash': model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash,
-                        'existsLocally': False,
-                        'localPath': None,
-                        'file_name': model_name,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
-                    }
-
-                    # Try to get additional info from metadata provider
-                    if metadata_provider and model_hash:
-                        try:
-                            civitai_info = await metadata_provider.get_model_by_hash(
-                                model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash
-                            )
-                            if civitai_info:
-                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
-                                    checkpoint_entry, civitai_info
-                                )
-                        except Exception as e:
-                            logger.debug(f"Error fetching info for checkpoint {clean_name}: {e}")
-
-                    checkpoint = checkpoint_entry
-
-            # Determine base model from loras or checkpoint
-            base_model = None
-            if loras:
-                base_models = [lora.get('baseModel') for lora in loras if lora.get('baseModel')]
-                if base_models:
-                    from collections import Counter
-                    base_model_counts = Counter(base_models)
-                    base_model = base_model_counts.most_common(1)[0][0]
-            elif checkpoint and checkpoint.get('baseModel'):
-                base_model = checkpoint['baseModel']
-
-            return {
-                'base_model': base_model,
-                'loras': loras,
-                'checkpoint': checkpoint,
-                'gen_params': gen_params,
-                'from_sui_image_params': True
-            }
-
-        except Exception as e:
-            logger.error(f"Error parsing SuiImage metadata: {e}", exc_info=True)
-            return {"error": str(e), "loras": []}

py/routes/base_model_routes.py

@@ -204,7 +204,6 @@ class BaseModelRoutes(ABC):
             service=service,
             update_service=update_service,
             metadata_provider_selector=get_metadata_provider,
-            settings_service=self._settings,
             logger=logger,
         )
         return ModelHandlerSet(
@@ -251,7 +250,7 @@ class BaseModelRoutes(ABC):
 
     def _find_model_file(self, files):
         """Find the appropriate model file from the files list - can be overridden by subclasses."""
-        return next((file for file in files if file.get("type") in ("Model", "Diffusion Model") and file.get("primary") is True), None)
+        return next((file for file in files if file.get("type") == "Model" and file.get("primary") is True), None)
 
     def get_handler(self, name: str) -> Callable[[web.Request], web.StreamResponse]:
         """Expose handlers for subclasses or tests."""

py/routes/base_recipe_routes.py

@@ -1,5 +1,4 @@
 """Base infrastructure shared across recipe routes."""
-
 from __future__ import annotations
 
 import logging
@@ -17,14 +16,12 @@ from ..services.recipes import (
     RecipePersistenceService,
     RecipeSharingService,
 )
-from ..services.batch_import_service import BatchImportService
 from ..services.server_i18n import server_i18n
 from ..services.service_registry import ServiceRegistry
 from ..services.settings_manager import get_settings_manager
 from ..utils.constants import CARD_PREVIEW_WIDTH
 from ..utils.exif_utils import ExifUtils
 from .handlers.recipe_handlers import (
-    BatchImportHandler,
     RecipeAnalysisHandler,
     RecipeHandlerSet,
     RecipeListingHandler,
@@ -119,10 +116,7 @@ class BaseRecipeRoutes:
         recipe_scanner_getter = lambda: self.recipe_scanner
         civitai_client_getter = lambda: self.civitai_client
 
-        standalone_mode = (
+        standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-            os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-            or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-        )
         if not standalone_mode:
             from ..metadata_collector import get_metadata  # type: ignore[import-not-found]
             from ..metadata_collector.metadata_processor import (  # type: ignore[import-not-found]
@@ -196,22 +190,6 @@ class BaseRecipeRoutes:
             sharing_service=sharing_service,
         )
 
-        from ..services.websocket_manager import ws_manager
-
-        batch_import_service = BatchImportService(
-            analysis_service=analysis_service,
-            persistence_service=persistence_service,
-            ws_manager=ws_manager,
-            logger=logger,
-        )
-        batch_import = BatchImportHandler(
-            ensure_dependencies_ready=self.ensure_dependencies_ready,
-            recipe_scanner_getter=recipe_scanner_getter,
-            civitai_client_getter=civitai_client_getter,
-            logger=logger,
-            batch_import_service=batch_import_service,
-        )
-
         return RecipeHandlerSet(
             page_view=page_view,
             listing=listing,
@@ -219,5 +197,4 @@ class BaseRecipeRoutes:
             management=management,
             analysis=analysis,
             sharing=sharing,
-            batch_import=batch_import,
         )

py/routes/checkpoint_routes.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Set
+from typing import Dict
 from aiohttp import web
 
 from .base_model_routes import BaseModelRoutes
@@ -82,22 +82,12 @@ class CheckpointRoutes(BaseModelRoutes):
             return web.json_response({"error": str(e)}, status=500)
     
     async def get_checkpoints_roots(self, request: web.Request) -> web.Response:
-        """Return the list of checkpoint roots from config (including extra paths)"""
+        """Return the list of checkpoint roots from config"""
         try:
-            # Merge checkpoints_roots with extra_checkpoints_roots, preserving order and removing duplicates
+            roots = config.checkpoints_roots
-            roots: List[str] = []
-            roots.extend(config.checkpoints_roots or [])
-            roots.extend(config.extra_checkpoints_roots or [])
-            # Remove duplicates while preserving order
-            seen: set = set()
-            unique_roots: List[str] = []
-            for root in roots:
-                if root and root not in seen:
-                    seen.add(root)
-                    unique_roots.append(root)
             return web.json_response({
                 "success": True,
-                "roots": unique_roots
+                "roots": roots
             })
         except Exception as e:
             logger.error(f"Error getting checkpoint roots: {e}", exc_info=True)
@@ -107,22 +97,12 @@ class CheckpointRoutes(BaseModelRoutes):
             }, status=500)
 
     async def get_unet_roots(self, request: web.Request) -> web.Response:
-        """Return the list of unet roots from config (including extra paths)"""
+        """Return the list of unet roots from config"""
         try:
-            # Merge unet_roots with extra_unet_roots, preserving order and removing duplicates
+            roots = config.unet_roots
-            roots: List[str] = []
-            roots.extend(config.unet_roots or [])
-            roots.extend(config.extra_unet_roots or [])
-            # Remove duplicates while preserving order
-            seen: set = set()
-            unique_roots: List[str] = []
-            for root in roots:
-                if root and root not in seen:
-                    seen.add(root)
-                    unique_roots.append(root)
             return web.json_response({
                 "success": True,
-                "roots": unique_roots
+                "roots": roots
             })
         except Exception as e:
             logger.error(f"Error getting unet roots: {e}", exc_info=True)

py/routes/handlers/base_model_handlers.py

@@ -1,141 +0,0 @@
-"""Handlers for base model related endpoints."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Awaitable, Callable, Dict
-
-from aiohttp import web
-
-from ...services.civitai_base_model_service import get_civitai_base_model_service
-
-logger = logging.getLogger(__name__)
-
-
-class BaseModelHandlerSet:
-    """Collection of handlers for base model operations."""
-
-    def __init__(
-        self,
-        base_model_service_factory: Callable[[], Any] = get_civitai_base_model_service,
-    ) -> None:
-        self._base_model_service_factory = base_model_service_factory
-
-    def to_route_mapping(
-        self,
-    ) -> Dict[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
-        """Return mapping of route names to handler methods."""
-        return {
-            "get_base_models": self.get_base_models,
-            "refresh_base_models": self.refresh_base_models,
-            "get_base_model_categories": self.get_base_model_categories,
-            "get_base_model_cache_status": self.get_base_model_cache_status,
-        }
-
-    async def get_base_models(self, request: web.Request) -> web.Response:
-        """Get merged base models (hardcoded + remote from Civitai).
-
-        Query Parameters:
-            refresh: If 'true', force refresh from API
-
-        Returns:
-            JSON response with:
-            - models: List of base model names
-            - source: 'cache', 'api', or 'fallback'
-            - last_updated: ISO timestamp
-            - counts: hardcoded_count, remote_count, merged_count
-        """
-        try:
-            service = await self._base_model_service_factory()
-
-            # Check for refresh parameter
-            force_refresh = request.query.get("refresh", "").lower() == "true"
-
-            result = await service.get_base_models(force_refresh=force_refresh)
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": result,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_models: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def refresh_base_models(self, request: web.Request) -> web.Response:
-        """Force refresh base models from Civitai API.
-
-        Returns:
-            JSON response with refreshed data
-        """
-        try:
-            service = await self._base_model_service_factory()
-            result = await service.refresh_cache()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": result,
-                    "message": "Base models cache refreshed successfully",
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in refresh_base_models: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def get_base_model_categories(self, request: web.Request) -> web.Response:
-        """Get categorized base models.
-
-        Returns:
-            JSON response with categorized models
-        """
-        try:
-            service = await self._base_model_service_factory()
-            categories = service.get_model_categories()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": categories,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_model_categories: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def get_base_model_cache_status(self, request: web.Request) -> web.Response:
-        """Get cache status for base models.
-
-        Returns:
-            JSON response with cache status
-        """
-        try:
-            service = await self._base_model_service_factory()
-            status = service.get_cache_status()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": status,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_model_cache_status: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )

py/routes/handlers/example_images_handlers.py

@@ -1,14 +1,11 @@
 """Handler set for example image routes."""
 from __future__ import annotations
 
-import logging
 from dataclasses import dataclass
 from typing import Callable, Mapping
 
 from aiohttp import web
 
-logger = logging.getLogger(__name__)
-
 from ...services.use_cases.example_images import (
     DownloadExampleImagesConfigurationError,
     DownloadExampleImagesInProgressError,
@@ -125,9 +122,6 @@ class ExampleImagesManagementHandler:
             return web.json_response({'success': False, 'error': str(exc)}, status=400)
         except ExampleImagesImportError as exc:
             return web.json_response({'success': False, 'error': str(exc)}, status=500)
-        except Exception as exc:
-            logger.exception("Unexpected error importing example images")
-            return web.json_response({'success': False, 'error': str(exc)}, status=500)
 
     async def delete_example_image(self, request: web.Request) -> web.StreamResponse:
         return await self._processor.delete_custom_image(request)

py/routes/handlers/preview_handlers.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import logging
-import mimetypes
 import urllib.parse
 from pathlib import Path
 
@@ -13,12 +12,6 @@ from ...config import config as global_config
 
 logger = logging.getLogger(__name__)
 
-_CHUNK_SIZE = 1024 * 1024  # 1 MB — balance between streaming iteration overhead and per-chunk memory
-
-# Video file extensions that bypass native sendfile on Windows
-# to avoid IOCP/ProactorEventLoop crashes during client disconnect.
-_VIDEO_EXTENSIONS = frozenset({".mp4", ".webm", ".mov", ".avi", ".mkv"})
-
 
 class PreviewHandler:
     """Serve preview assets for the active library at request time."""
@@ -55,58 +48,8 @@ class PreviewHandler:
             logger.debug("Preview file not found at %s", str(resolved))
             raise web.HTTPNotFound(text="Preview file not found")
 
-        # aiohttp's FileResponse handles range requests, content headers, and
+        # aiohttp's FileResponse handles range requests and content headers for us.
-        # uses kernel sendfile (zero-copy DMA) on Linux/macOS. On Windows it
+        return web.FileResponse(path=resolved, chunk_size=256 * 1024)
-        # uses IOCP-based _sendfile_native which can crash when the client
-        # disconnects mid-transfer during fast scrolling. The _stream_file()
-        # fallback is kept for a future compat toggle.
-        #
-        # Set explicit Cache-Control so the browser can cache video (and image)
-        # previews across VirtualScroller recycling cycles. Without this,
-        # Chrome does not cache 206 Partial Content responses for <video>
-        # elements, causing the same video to be re-downloaded on every scroll.
-        resp = web.FileResponse(path=resolved, chunk_size=_CHUNK_SIZE)
-        resp.headers["Cache-Control"] = "public, max-age=86400"
-        return resp
-
-    async def _stream_file(
-        self, request: web.Request, path: Path
-    ) -> web.StreamResponse:
-        """Stream a file chunk-by-chunk, bypassing native sendfile.
-
-        This avoids the Windows IOCP ``_sendfile_native`` crash that occurs
-        when the client disconnects during a large file transfer.
-        """
-        content_type, _ = mimetypes.guess_type(str(path))
-        if content_type is None:
-            content_type = "application/octet-stream"
-
-        file_size = path.stat().st_size
-        resp = web.StreamResponse()
-        resp.content_type = content_type
-        resp.content_length = file_size
-
-        # Allow browser caching: video previews rarely change during a session.
-        # The frontend already appends ?t={version} to bust cache on update.
-        resp.headers["Cache-Control"] = "public, max-age=86400"
-
-        await resp.prepare(request)
-
-        try:
-            with open(path, "rb") as f:
-                while True:
-                    chunk = f.read(_CHUNK_SIZE)
-                    if not chunk:
-                        break
-                    await resp.write(chunk)
-        except (ConnectionResetError, ConnectionAbortedError):
-            # Client disconnected during streaming — expected when scrolling
-            # rapidly through a library with animated previews.
-            pass
-        except OSError as exc:
-            logger.debug("I/O error streaming preview %s: %s", path, exc)
-
-        return resp
 
 
 __all__ = ["PreviewHandler"]

py/routes/misc_route_registrar.py

@@ -22,17 +22,10 @@ class RouteDefinition:
 MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/settings", "get_settings"),
     RouteDefinition("POST", "/api/lm/settings", "update_settings"),
-    RouteDefinition("GET", "/api/lm/doctor/diagnostics", "get_doctor_diagnostics"),
-    RouteDefinition("POST", "/api/lm/doctor/repair-cache", "repair_doctor_cache"),
-    RouteDefinition("POST", "/api/lm/doctor/resolve-filename-conflicts", "resolve_doctor_filename_conflicts"),
-    RouteDefinition("POST", "/api/lm/doctor/export-bundle", "export_doctor_bundle"),
     RouteDefinition("GET", "/api/lm/priority-tags", "get_priority_tags"),
     RouteDefinition("GET", "/api/lm/settings/libraries", "get_settings_libraries"),
     RouteDefinition("POST", "/api/lm/settings/libraries/activate", "activate_library"),
     RouteDefinition("GET", "/api/lm/health-check", "health_check"),
-    RouteDefinition("GET", "/api/lm/supporters", "get_supporters"),
-    RouteDefinition("GET", "/api/lm/wildcards/search", "search_wildcards"),
-    RouteDefinition("POST", "/api/lm/wildcards/open-location", "open_wildcards_location"),
     RouteDefinition("POST", "/api/lm/open-file-location", "open_file_location"),
     RouteDefinition("POST", "/api/lm/update-usage-stats", "update_usage_stats"),
     RouteDefinition("GET", "/api/lm/get-usage-stats", "get_usage_stats"),
@@ -43,57 +36,13 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/update-node-widget", "update_node_widget"),
     RouteDefinition("GET", "/api/lm/get-registry", "get_registry"),
     RouteDefinition("GET", "/api/lm/check-model-exists", "check_model_exists"),
-    RouteDefinition("GET", "/api/lm/check-models-exist", "check_models_exist"),
-    RouteDefinition(
-        "GET",
-        "/api/lm/model-version-download-status",
-        "get_model_version_download_status",
-    ),
-    RouteDefinition(
-        "POST",
-        "/api/lm/model-version-download-status",
-        "set_model_version_download_status",
-    ),
-    RouteDefinition(
-        "GET",
-        "/api/lm/set-model-version-download-status",
-        "set_model_version_download_status",
-    ),
     RouteDefinition("GET", "/api/lm/civitai/user-models", "get_civitai_user_models"),
-    RouteDefinition(
+    RouteDefinition("POST", "/api/lm/download-metadata-archive", "download_metadata_archive"),
-        "POST", "/api/lm/download-metadata-archive", "download_metadata_archive"
+    RouteDefinition("POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"),
-    ),
+    RouteDefinition("GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/model-versions-status", "get_model_versions_status"),
-        "POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"
-    ),
-    RouteDefinition("GET", "/api/lm/backup/status", "get_backup_status"),
-    RouteDefinition("POST", "/api/lm/backup/export", "export_backup"),
-    RouteDefinition("POST", "/api/lm/backup/import", "import_backup"),
-    RouteDefinition("POST", "/api/lm/backup/open-location", "open_backup_location"),
-    RouteDefinition(
-        "GET", "/api/lm/model-versions-status", "get_model_versions_status"
-    ),
     RouteDefinition("POST", "/api/lm/settings/open-location", "open_settings_location"),
     RouteDefinition("GET", "/api/lm/custom-words/search", "search_custom_words"),
-    RouteDefinition("GET", "/api/lm/example-workflows", "get_example_workflows"),
-    RouteDefinition(
-        "GET", "/api/lm/example-workflows/{filename}", "get_example_workflow"
-    ),
-    # Base model management routes
-    RouteDefinition("GET", "/api/lm/base-models", "get_base_models"),
-    RouteDefinition("POST", "/api/lm/base-models/refresh", "refresh_base_models"),
-    RouteDefinition(
-        "GET", "/api/lm/base-models/categories", "get_base_model_categories"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/base-models/cache-status", "get_base_model_cache_status"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/delete-model-version", "delete_model_version"
-    ),
 )
 
 
@@ -117,11 +66,7 @@ class MiscRouteRegistrar:
         definitions: Iterable[RouteDefinition] = MISC_ROUTE_DEFINITIONS,
     ) -> None:
         for definition in definitions:
-            self._bind(
+            self._bind(definition.method, definition.path, handler_lookup[definition.handler_name])
-                definition.method,
-                definition.path,
-                handler_lookup[definition.handler_name],
-            )
 
     def _bind(self, method: str, path: str, handler: Callable) -> None:
         add_method_name = self._METHOD_MAP[method.upper()]

py/routes/misc_routes.py

@@ -19,12 +19,9 @@ from ..services.downloader import get_downloader
 from ..utils.usage_stats import UsageStats
 from .handlers.misc_handlers import (
     CustomWordsHandler,
-    DoctorHandler,
-    ExampleWorkflowsHandler,
     FileSystemHandler,
     HealthCheckHandler,
     LoraCodeHandler,
-    BackupHandler,
     MetadataArchiveHandler,
     MiscHandlerSet,
     ModelExampleFilesHandler,
@@ -32,21 +29,17 @@ from .handlers.misc_handlers import (
     NodeRegistry,
     NodeRegistryHandler,
     SettingsHandler,
-    SupportersHandler,
     TrainedWordsHandler,
     UsageStatsHandler,
-    WildcardsHandler,
     build_service_registry_adapter,
 )
-from .handlers.base_model_handlers import BaseModelHandlerSet
 from .misc_route_registrar import MiscRouteRegistrar
 
 logger = logging.getLogger(__name__)
 
-standalone_mode = (
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get(
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    "HF_HUB_DISABLE_TELEMETRY", "0"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+) == "0"
-)
 
 
 class MiscRoutes:
@@ -81,9 +74,7 @@ class MiscRoutes:
         self._node_registry = node_registry or NodeRegistry()
         self._standalone_mode = standalone_mode_flag
 
-        self._handler_mapping: (
+        self._handler_mapping: Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None = None
-            Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None
-        ) = None
 
     @staticmethod
     def setup_routes(app: web.Application) -> None:
@@ -95,9 +86,7 @@ class MiscRoutes:
         registrar = self._registrar_factory(app)
         registrar.register_routes(self._ensure_handler_mapping())
 
-    def _ensure_handler_mapping(
+    def _ensure_handler_mapping(self) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
-        self,
-    ) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
         if self._handler_mapping is None:
             handler_set = self._create_handler_set()
             self._handler_mapping = handler_set.to_route_mapping()
@@ -119,7 +108,6 @@ class MiscRoutes:
             settings_service=self._settings,
             metadata_provider_updater=self._metadata_provider_updater,
         )
-        backup = BackupHandler()
         filesystem = FileSystemHandler(settings_service=self._settings)
         node_registry_handler = NodeRegistryHandler(
             node_registry=self._node_registry,
@@ -131,11 +119,6 @@ class MiscRoutes:
             metadata_provider_factory=self._metadata_provider_factory,
         )
         custom_words = CustomWordsHandler()
-        wildcards = WildcardsHandler()
-        supporters = SupportersHandler()
-        doctor = DoctorHandler(settings_service=self._settings)
-        example_workflows = ExampleWorkflowsHandler()
-        base_model = BaseModelHandlerSet()
 
         return self._handler_set_factory(
             health=health,
@@ -147,14 +130,8 @@ class MiscRoutes:
             node_registry=node_registry_handler,
             model_library=model_library,
             metadata_archive=metadata_archive,
-            backup=backup,
             filesystem=filesystem,
             custom_words=custom_words,
-            wildcards=wildcards,
-            supporters=supporters,
-            doctor=doctor,
-            example_workflows=example_workflows,
-            base_model=base_model,
         )
 
 

py/routes/model_route_registrar.py

@@ -1,5 +1,4 @@
 """Route registrar for model endpoints."""
-
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -22,17 +21,12 @@ class RouteDefinition:
 
 COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/{prefix}/list", "get_models"),
-    RouteDefinition("GET", "/api/lm/{prefix}/excluded", "get_excluded_models"),
     RouteDefinition("POST", "/api/lm/{prefix}/delete", "delete_model"),
     RouteDefinition("POST", "/api/lm/{prefix}/exclude", "exclude_model"),
-    RouteDefinition("POST", "/api/lm/{prefix}/unexclude", "unexclude_model"),
     RouteDefinition("POST", "/api/lm/{prefix}/fetch-civitai", "fetch_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/fetch-all-civitai", "fetch_all_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/relink-civitai", "relink_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/replace-preview", "replace_preview"),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/set-preview-from-url", "set_preview_from_url"
-    ),
     RouteDefinition("POST", "/api/lm/{prefix}/save-metadata", "save_metadata"),
     RouteDefinition("POST", "/api/lm/{prefix}/add-tags", "add_tags"),
     RouteDefinition("POST", "/api/lm/{prefix}/rename", "rename_model"),
@@ -42,9 +36,7 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/{prefix}/move_models_bulk", "move_models_bulk"),
     RouteDefinition("GET", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
     RouteDefinition("POST", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"),
-        "GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"
-    ),
     RouteDefinition("GET", "/api/lm/{prefix}/top-tags", "get_top_tags"),
     RouteDefinition("GET", "/api/lm/{prefix}/base-models", "get_base_models"),
     RouteDefinition("GET", "/api/lm/{prefix}/model-types", "get_model_types"),
@@ -52,95 +44,30 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/{prefix}/roots", "get_model_roots"),
     RouteDefinition("GET", "/api/lm/{prefix}/folders", "get_folders"),
     RouteDefinition("GET", "/api/lm/{prefix}/folder-tree", "get_folder_tree"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"),
-        "GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"
-    ),
     RouteDefinition("GET", "/api/lm/{prefix}/find-duplicates", "find_duplicate_models"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"),
-        "GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"
-    ),
     RouteDefinition("GET", "/api/lm/{prefix}/get-notes", "get_model_notes"),
     RouteDefinition("GET", "/api/lm/{prefix}/preview-url", "get_model_preview_url"),
     RouteDefinition("GET", "/api/lm/{prefix}/civitai-url", "get_model_civitai_url"),
     RouteDefinition("GET", "/api/lm/{prefix}/metadata", "get_model_metadata"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/model-description", "get_model_description"),
-        "GET", "/api/lm/{prefix}/model-description", "get_model_description"
-    ),
     RouteDefinition("GET", "/api/lm/{prefix}/relative-paths", "get_relative_paths"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"),
-        "GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/version/{modelVersionId}", "get_civitai_model_by_version"),
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"),
-    RouteDefinition(
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"),
-        "GET",
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/fetch-missing-license", "fetch_missing_civitai_license_data"),
-        "/api/lm/{prefix}/civitai/model/version/{modelVersionId}",
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"),
-        "get_civitai_model_by_version",
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"),
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"),
-        "GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"
-    ),
-    RouteDefinition(
-        "POST",
-        "/api/lm/{prefix}/updates/fetch-missing-license",
-        "fetch_missing_civitai_license_data",
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"
-    ),
     RouteDefinition("POST", "/api/lm/download-model", "download_model"),
     RouteDefinition("GET", "/api/lm/download-model-get", "download_model_get"),
     RouteDefinition("GET", "/api/lm/cancel-download-get", "cancel_download_get"),
-    RouteDefinition("GET", "/api/lm/skip-download", "skip_download_get"),
     RouteDefinition("GET", "/api/lm/pause-download", "pause_download_get"),
     RouteDefinition("GET", "/api/lm/resume-download", "resume_download_get"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/download-progress/{download_id}", "get_download_progress"),
-        "GET", "/api/lm/download-progress/{download_id}", "get_download_progress"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/queue", "get_download_queue"),
-    RouteDefinition("GET", "/api/lm/downloads/queue/add", "add_to_download_queue"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/remove", "remove_from_download_queue"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/move-to-top", "move_queue_item_to_top"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/move-to-end", "move_queue_item_to_end"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/clear", "clear_download_queue"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/history", "get_download_history"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/clear", "clear_download_history"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/delete", "delete_download_history_item"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/retry", "retry_download_from_history"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/retry-all", "retry_all_failed_downloads"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/stats", "get_download_stats"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/complete", "complete_download_in_queue"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/status", "update_download_queue_status"
-    ),
     RouteDefinition("POST", "/api/lm/{prefix}/cancel-task", "cancel_task"),
     RouteDefinition("GET", "/{prefix}", "handle_models_page"),
 )
@@ -167,18 +94,12 @@ class ModelRouteRegistrar:
         definitions: Iterable[RouteDefinition] = COMMON_ROUTE_DEFINITIONS,
     ) -> None:
         for definition in definitions:
-            self._bind_route(
+            self._bind_route(definition.method, definition.build_path(prefix), handler_lookup[definition.handler_name])
-                definition.method,
-                definition.build_path(prefix),
-                handler_lookup[definition.handler_name],
-            )
 
     def add_route(self, method: str, path: str, handler: Callable) -> None:
         self._bind_route(method, path, handler)
 
-    def add_prefixed_route(
+    def add_prefixed_route(self, method: str, path_template: str, prefix: str, handler: Callable) -> None:
-        self, method: str, path_template: str, prefix: str, handler: Callable
-    ) -> None:
         self._bind_route(method, path_template.replace("{prefix}", prefix), handler)
 
     def _bind_route(self, method: str, path: str, handler: Callable) -> None:

py/routes/recipe_route_registrar.py

@@ -1,5 +1,4 @@
 """Route registrar for recipe endpoints."""
-
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -23,9 +22,7 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}", "get_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/import-remote", "import_remote_recipe"),
     RouteDefinition("POST", "/api/lm/recipes/analyze-image", "analyze_uploaded_image"),
-    RouteDefinition(
+    RouteDefinition("POST", "/api/lm/recipes/analyze-local-image", "analyze_local_image"),
-        "POST", "/api/lm/recipes/analyze-local-image", "analyze_local_image"
-    ),
     RouteDefinition("POST", "/api/lm/recipes/save", "save_recipe"),
     RouteDefinition("DELETE", "/api/lm/recipe/{recipe_id}", "delete_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/top-tags", "get_top_tags"),
@@ -33,13 +30,9 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/recipes/roots", "get_roots"),
     RouteDefinition("GET", "/api/lm/recipes/folders", "get_folders"),
     RouteDefinition("GET", "/api/lm/recipes/folder-tree", "get_folder_tree"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"),
-        "GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"
-    ),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share", "share_recipe"),
-    RouteDefinition(
+    RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"),
-        "GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"
-    ),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/syntax", "get_recipe_syntax"),
     RouteDefinition("PUT", "/api/lm/recipe/{recipe_id}/update", "update_recipe"),
     RouteDefinition("POST", "/api/lm/recipe/move", "move_recipe"),
@@ -47,40 +40,13 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/recipe/lora/reconnect", "reconnect_lora"),
     RouteDefinition("GET", "/api/lm/recipes/find-duplicates", "find_duplicates"),
     RouteDefinition("POST", "/api/lm/recipes/bulk-delete", "bulk_delete"),
-    RouteDefinition(
+    RouteDefinition("POST", "/api/lm/recipes/save-from-widget", "save_recipe_from_widget"),
-        "POST", "/api/lm/recipes/save-from-widget", "save_recipe_from_widget"
-    ),
     RouteDefinition("GET", "/api/lm/recipes/for-lora", "get_recipes_for_lora"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/for-checkpoint", "get_recipes_for_checkpoint"
-    ),
     RouteDefinition("GET", "/api/lm/recipes/scan", "scan_recipes"),
     RouteDefinition("POST", "/api/lm/recipes/repair", "repair_recipes"),
     RouteDefinition("POST", "/api/lm/recipes/cancel-repair", "cancel_repair"),
     RouteDefinition("POST", "/api/lm/recipe/{recipe_id}/repair", "repair_recipe"),
-    RouteDefinition("POST", "/api/lm/recipes/repair-bulk", "repair_recipes_bulk"),
     RouteDefinition("GET", "/api/lm/recipes/repair-progress", "get_repair_progress"),
-    RouteDefinition("POST", "/api/lm/recipes/batch-import/start", "start_batch_import"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/batch-import/progress", "get_batch_import_progress"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/batch-import/cancel", "cancel_batch_import"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/batch-import/directory", "start_directory_import"
-    ),
-    RouteDefinition("POST", "/api/lm/recipes/browse-directory", "browse_directory"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/check-image-exists", "check_image_exists"
-    ),
-    RouteDefinition("GET", "/api/lm/recipes/import-from-url", "import_from_url"),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/create-from-example", "create_from_example"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipe/{recipe_id}/reimport", "reimport_recipe"
-    ),
 )
 
 
@@ -97,9 +63,7 @@ class RecipeRouteRegistrar:
     def __init__(self, app: web.Application) -> None:
         self._app = app
 
-    def register_routes(
+    def register_routes(self, handler_lookup: Mapping[str, Callable[[web.Request], object]]) -> None:
-        self, handler_lookup: Mapping[str, Callable[[web.Request], object]]
-    ) -> None:
         for definition in ROUTE_DEFINITIONS:
             handler = handler_lookup[definition.handler_name]
             self._bind_route(definition.method, definition.path, handler)

py/routes/stats_routes.py

@@ -11,8 +11,6 @@ from ..config import config
 from ..services.settings_manager import get_settings_manager
 from ..services.server_i18n import server_i18n
 from ..services.service_registry import ServiceRegistry
-from ..services.model_query import normalize_sub_type, resolve_sub_type
-from ..utils.constants import VALID_LORA_SUB_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.usage_stats import UsageStats
 
 logger = logging.getLogger(__name__)
@@ -142,21 +140,6 @@ class StatsRoutes:
             # Get usage statistics
             usage_data = await self.usage_stats.get_stats()
             
-            # CivitAI model type distribution across all model types
-            # Use the same logic as the filter panel: normalize_sub_type(resolve_sub_type(entry))
-            # with sub-type validation per model type
-            model_types_counter: Counter[str] = Counter()
-            for entry in lora_cache.raw_data:
-                ntype = normalize_sub_type(resolve_sub_type(entry))
-                if ntype and ntype in VALID_LORA_SUB_TYPES:
-                    model_types_counter[ntype] += 1
-            for entry in checkpoint_cache.raw_data:
-                ntype = normalize_sub_type(resolve_sub_type(entry))
-                if ntype and ntype in VALID_CHECKPOINT_SUB_TYPES:
-                    model_types_counter[ntype] += 1
-            # Embeddings: always count as "embedding" regardless of CivitAI sub-type
-            model_types_counter['embedding'] = len(embedding_cache.raw_data)
-            
             return web.json_response({
                 'success': True,
                 'data': {
@@ -171,8 +154,7 @@ class StatsRoutes:
                     'total_generations': usage_data.get('total_executions', 0),
                     'unused_loras': self._count_unused_models(lora_cache.raw_data, usage_data.get('loras', {})),
                     'unused_checkpoints': self._count_unused_models(checkpoint_cache.raw_data, usage_data.get('checkpoints', {})),
-                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {})),
+                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {}))
-                    'model_types_distribution': dict(model_types_counter.most_common())
                 }
             })
             
@@ -227,80 +209,6 @@ class StatsRoutes:
                 'error': str(e)
             }, status=500)
 
-    async def get_model_usage_list(self, request: web.Request) -> web.Response:
-        """Get paginated model usage list for infinite scrolling"""
-        try:
-            await self.init_services()
-            
-            model_type = request.query.get('type', 'lora')
-            sort_order = request.query.get('sort', 'desc')
-            
-            try:
-                limit = int(request.query.get('limit', '50'))
-                offset = int(request.query.get('offset', '0'))
-            except ValueError:
-                limit = 50
-                offset = 0
-
-            # Get usage statistics
-            usage_data = await self.usage_stats.get_stats()
-            
-            # Select proper cache and usage dict based on type
-            if model_type == 'lora':
-                cache = await self.lora_scanner.get_cached_data()
-                type_usage_data = usage_data.get('loras', {})
-            elif model_type == 'checkpoint':
-                cache = await self.checkpoint_scanner.get_cached_data()
-                type_usage_data = usage_data.get('checkpoints', {})
-            elif model_type == 'embedding':
-                cache = await self.embedding_scanner.get_cached_data()
-                type_usage_data = usage_data.get('embeddings', {})
-            else:
-                return web.json_response({'success': False, 'error': f"Invalid model type: {model_type}"}, status=400)
-
-            # Create list of all models
-            all_models = []
-            for item in cache.raw_data:
-                sha256 = item.get('sha256')
-                usage_info = type_usage_data.get(sha256, {}) if sha256 else {}
-                usage_count = usage_info.get('total', 0) if isinstance(usage_info, dict) else 0
-                
-                all_models.append({
-                    'name': item.get('model_name', 'Unknown'),
-                    'usage_count': usage_count,
-                    'base_model': item.get('base_model', 'Unknown'),
-                    'preview_url': config.get_preview_static_url(item.get('preview_url', '')),
-                    'folder': item.get('folder', '')
-                })
-
-            # Sort the models
-            reverse = (sort_order == 'desc')
-            all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()), reverse=reverse)
-            if not reverse:
-                # If asc, sort by usage_count ascending, but keep name ascending
-                all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()))
-            else:
-                all_models.sort(key=lambda x: (-x['usage_count'], x['name'].lower()))
-
-            # Slice for pagination
-            paginated_models = all_models[offset:offset + limit]
-
-            return web.json_response({
-                'success': True,
-                'data': {
-                    'items': paginated_models,
-                    'total': len(all_models),
-                    'type': model_type
-                }
-            })
-
-        except Exception as e:
-            logger.error(f"Error getting model usage list: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-
     async def get_base_model_distribution(self, request: web.Request) -> web.Response:
         """Get base model distribution statistics"""
         try:
@@ -477,12 +385,9 @@ class StatsRoutes:
                 if unused_lora_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedLoras.high',
+                        'title': 'High Number of Unused LoRAs',
-                        'params': {
+                        'description': f'{unused_lora_percent:.1f}% of your LoRAs ({unused_loras}/{total_loras}) have never been used.',
-                            'percent': f'{unused_lora_percent:.1f}',
+                        'suggestion': 'Consider organizing or archiving unused models to free up storage space.'
-                            'count': str(unused_loras),
-                            'total': str(total_loras)
-                        }
                     })
             
             if total_checkpoints > 0:
@@ -490,12 +395,9 @@ class StatsRoutes:
                 if unused_checkpoint_percent > 30:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedCheckpoints.detected',
+                        'title': 'Unused Checkpoints Detected',
-                        'params': {
+                        'description': f'{unused_checkpoint_percent:.1f}% of your checkpoints ({unused_checkpoints}/{total_checkpoints}) have never been used.',
-                            'percent': f'{unused_checkpoint_percent:.1f}',
+                        'suggestion': 'Review and consider removing checkpoints you no longer need.'
-                            'count': str(unused_checkpoints),
-                            'total': str(total_checkpoints)
-                        }
                     })
             
             if total_embeddings > 0:
@@ -503,12 +405,9 @@ class StatsRoutes:
                 if unused_embedding_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedEmbeddings.high',
+                        'title': 'High Number of Unused Embeddings',
-                        'params': {
+                        'description': f'{unused_embedding_percent:.1f}% of your embeddings ({unused_embeddings}/{total_embeddings}) have never been used.',
-                            'percent': f'{unused_embedding_percent:.1f}',
+                        'suggestion': 'Consider organizing or archiving unused embeddings to optimize your collection.'
-                            'count': str(unused_embeddings),
-                            'total': str(total_embeddings)
-                        }
                     })
             
             # Storage insights
@@ -519,20 +418,18 @@ class StatsRoutes:
             if total_size > 100 * 1024 * 1024 * 1024:  # 100GB
                 insights.append({
                     'type': 'info',
-                    'key': 'insights.collection.large',
+                    'title': 'Large Collection Detected',
-                    'params': {
+                    'description': f'Your model collection is using {self._format_size(total_size)} of storage.',
-                        'size': self._format_size(total_size)
+                    'suggestion': 'Consider using external storage or cloud solutions for better organization.'
-                    }
                 })
             
             # Recent activity insight
             if usage_data.get('total_executions', 0) > 100:
                 insights.append({
                     'type': 'success',
-                    'key': 'insights.activity.active',
+                    'title': 'Active User',
-                    'params': {
+                    'description': f'You\'ve completed {usage_data["total_executions"]} generations so far!',
-                        'count': str(usage_data['total_executions'])
+                    'suggestion': 'Keep exploring and creating amazing content with your models.'
-                    }
                 })
             
             return web.json_response({
@@ -633,7 +530,6 @@ class StatsRoutes:
         # Register API routes
         app.router.add_get('/api/lm/stats/collection-overview', self.get_collection_overview)
         app.router.add_get('/api/lm/stats/usage-analytics', self.get_usage_analytics)
-        app.router.add_get('/api/lm/stats/model-usage-list', self.get_model_usage_list)
         app.router.add_get('/api/lm/stats/base-model-distribution', self.get_base_model_distribution)
         app.router.add_get('/api/lm/stats/tag-analytics', self.get_tag_analytics)
         app.router.add_get('/api/lm/stats/storage-analytics', self.get_storage_analytics)

py/routes/update_routes.py

@@ -1,6 +1,7 @@
 import os
 import logging
 import toml
+import git
 import zipfile
 import shutil
 import tempfile
@@ -10,7 +11,6 @@ from typing import Dict, List
 
 from ..utils.settings_paths import ensure_settings_file
 from ..services.downloader import get_downloader
-from ..services.service_registry import ServiceRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -212,19 +212,8 @@ class UpdateRoutes:
 
             zip_path = tmp_zip_path
 
-            # Close the downloaded-versions SQLite connection before cleaning,
+            # Skip both settings.json, civitai and model cache folder
-            # so that shutil.rmtree() does not fail on Windows (the process
+            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache'])
-            # cannot delete a file with an outstanding open handle).
-            try:
-                history_svc = ServiceRegistry._services.get("downloaded_version_history_service")
-                if history_svc is not None:
-                    history_svc.close()
-                    logger.info("Closed downloaded-version history database connection")
-            except Exception:
-                logger.debug("Could not close downloaded-version history database", exc_info=True)
-
-            # Skip settings.json, civitai, model cache and runtime cache folders
-            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache', 'cache', 'wildcards', 'backups', 'stats'])
 
             # Extract ZIP to temp dir
             with tempfile.TemporaryDirectory() as tmp_dir:
@@ -233,17 +222,16 @@ class UpdateRoutes:
                     # Find extracted folder (GitHub ZIP contains a root folder)
                     extracted_root = next(os.scandir(tmp_dir)).path
 
-                    # Copy files, skipping user data that should be preserved
+                    # Copy files, skipping settings.json and civitai folder
-                    skip_items = {'settings.json', 'civitai', 'wildcards', 'backups', 'stats'}
                     for item in os.listdir(extracted_root):
-                        if item in skip_items:
+                        if item == 'settings.json' or item == 'civitai':
                             continue
                         src = os.path.join(extracted_root, item)
                         dst = os.path.join(plugin_root, item)
                         if os.path.isdir(src):
                             if os.path.exists(dst):
                                 shutil.rmtree(dst)
-                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns(*skip_items))
+                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns('settings.json', 'civitai'))
                         else:
                             shutil.copy2(src, dst)
 
@@ -251,17 +239,15 @@ class UpdateRoutes:
                     # for ComfyUI Manager to work properly
                     tracking_info_file = os.path.join(plugin_root, '.tracking')
                     tracking_files = []
-                    skip_tracked = {'civitai', 'wildcards', 'backups', 'stats'}
                     for root, dirs, files in os.walk(extracted_root):
-                        # Skip user data directories and their contents
+                        # Skip civitai folder and its contents
                         rel_root = os.path.relpath(root, extracted_root)
-                        top_dir = rel_root.split(os.sep)[0] if rel_root != '.' else ''
+                        if rel_root == 'civitai' or rel_root.startswith('civitai' + os.sep):
-                        if top_dir in skip_tracked:
                             continue
                         for file in files:
                             rel_path = os.path.relpath(os.path.join(root, file), extracted_root)
-                            # Skip settings.json and any file under user data dirs
+                            # Skip settings.json and any file under civitai
-                            if rel_path == 'settings.json' or rel_path.split(os.sep)[0] in skip_tracked:
+                            if rel_path == 'settings.json' or rel_path.startswith('civitai' + os.sep):
                                 continue
                             tracking_files.append(rel_path.replace("\\", "/"))
                     with open(tracking_info_file, "w", encoding='utf-8') as file:
@@ -356,15 +342,6 @@ class UpdateRoutes:
         Returns:
             tuple: (success, new_version)
         """
-        try:
-            import git
-        except ImportError:
-            logger.error(
-                "GitPython is not available: the git executable was not found in PATH. "
-                "Install git or set $GIT_PYTHON_GIT_EXECUTABLE to the git binary path."
-            )
-            return False, ""
-
         try:
             # Open the Git repository
             repo = git.Repo(plugin_root)
@@ -461,7 +438,6 @@ class UpdateRoutes:
             if not os.path.exists(os.path.join(plugin_root, '.git')):
                 return git_info
 
-            import git
             repo = git.Repo(plugin_root)
             commit = repo.head.commit
             git_info['commit_hash'] = commit.hexsha

py/services/aria2_downloader.py

@@ -1,602 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import os
-import secrets
-import shutil
-import socket
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
-
-import aiohttp
-
-from .downloader import DownloadProgress, get_downloader, is_ssl_cert_verify_error
-from .aria2_transfer_state import Aria2TransferStateStore
-from .settings_manager import get_settings_manager
-
-logger = logging.getLogger(__name__)
-
-def _try_certifi_ca_path() -> str | None:
-    """Return the certifi CA bundle path if available, else None."""
-    try:
-        import certifi  # type: ignore[import-untyped]
-
-        path = certifi.where()
-        if os.path.isfile(path):
-            logger.debug(
-                "aria2 --ca-certificate: using certifi CA bundle at %s", path
-            )
-            return path
-    except ImportError:
-        pass
-
-    logger.debug("aria2 --ca-certificate: certifi not available")
-    return None
-
-
-CIVITAI_DOWNLOAD_URL_PREFIXES = (
-    "https://civitai.com/api/download/",
-    "https://civitai.red/api/download/",
-)
-
-
-class Aria2Error(RuntimeError):
-    """Raised when aria2 integration fails."""
-
-
-@dataclass
-class Aria2Transfer:
-    """Track an aria2 download registered by the Python coordinator."""
-
-    gid: str
-    save_path: str
-
-
-class Aria2Downloader:
-    """Manage an aria2 RPC daemon for recommended model downloads."""
-
-    _instance = None
-    _lock = asyncio.Lock()
-
-    @classmethod
-    async def get_instance(cls) -> "Aria2Downloader":
-        async with cls._lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    def __init__(self) -> None:
-        if hasattr(self, "_initialized"):
-            return
-
-        self._initialized = True
-        self._process: Optional[asyncio.subprocess.Process] = None
-        self._rpc_port: Optional[int] = None
-        self._rpc_secret = ""
-        self._rpc_url = ""
-        self._rpc_session: Optional[aiohttp.ClientSession] = None
-        self._rpc_session_lock = asyncio.Lock()
-        self._process_lock = asyncio.Lock()
-        self._transfers: Dict[str, Aria2Transfer] = {}
-        self._poll_interval = 0.5
-        self._state_store = Aria2TransferStateStore()
-
-    @property
-    def is_running(self) -> bool:
-        return self._process is not None and self._process.returncode is None
-
-    async def download_file(
-        self,
-        url: str,
-        save_path: str,
-        *,
-        download_id: str,
-        progress_callback=None,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> Tuple[bool, str]:
-        """Download a file using aria2 RPC and wait for completion."""
-
-        await self._ensure_process()
-        save_path = os.path.abspath(save_path)
-        transfer = self._transfers.get(download_id)
-        if transfer is None or os.path.abspath(transfer.save_path) != save_path:
-            gid = await self._schedule_download(
-                url,
-                save_path,
-                download_id=download_id,
-                headers=headers,
-            )
-            transfer = Aria2Transfer(gid=gid, save_path=save_path)
-            self._transfers[download_id] = transfer
-
-        try:
-            while True:
-                status = await self.get_status(download_id)
-                if status is None:
-                    return False, "aria2 download not found"
-
-                snapshot = self._build_progress_snapshot(status)
-                if progress_callback is not None:
-                    await self._dispatch_progress(progress_callback, snapshot)
-
-                state = status.get("status", "")
-                if state == "complete":
-                    completed_path = self._resolve_completed_path(status, save_path)
-                    return True, completed_path
-                if state == "error":
-                    return False, status.get("errorMessage") or "aria2 download failed"
-                if state == "removed":
-                    return False, "Download was cancelled"
-
-                await asyncio.sleep(self._poll_interval)
-        finally:
-            self._transfers.pop(download_id, None)
-
-    async def _schedule_download(
-        self,
-        url: str,
-        save_path: str,
-        *,
-        download_id: str,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> str:
-        save_dir = os.path.dirname(save_path)
-        out_name = os.path.basename(save_path)
-
-        Path(save_dir).mkdir(parents=True, exist_ok=True)
-
-        resolved_url = url
-        request_headers = headers
-        if headers and url.startswith(CIVITAI_DOWNLOAD_URL_PREFIXES):
-            resolved_url = await self._resolve_authenticated_redirect_url(url, headers)
-            if resolved_url != url:
-                request_headers = None
-                logger.debug(
-                    "Resolved Civitai download %s to signed URL for aria2",
-                    download_id,
-                )
-
-        options: Dict[str, str] = {
-            "dir": save_dir,
-            "out": out_name,
-            "continue": "true",
-            "max-connection-per-server": "4",
-            "split": "4",
-            "min-split-size": "1M",
-            "allow-overwrite": "true",
-            "auto-file-renaming": "false",
-            "file-allocation": "none",
-        }
-        if request_headers:
-            options["header"] = [
-                f"{key}: {value}" for key, value in request_headers.items()
-            ]
-
-        logger.debug(
-            "Submitting aria2 download %s -> %s (auth=%s, civitai_signed=%s)",
-            download_id,
-            save_path,
-            bool(request_headers),
-            resolved_url != url,
-        )
-
-        try:
-            gid = await self._rpc_call("aria2.addUri", [[resolved_url], options])
-        except Exception as exc:
-            raise Aria2Error(f"Failed to schedule aria2 download: {exc}") from exc
-
-        logger.debug("aria2 accepted download %s with gid %s", download_id, gid)
-        await self._state_store.upsert(
-            download_id,
-            {
-                "gid": gid,
-                "save_path": save_path,
-                "status": "downloading",
-                "url": url,
-            },
-        )
-        return gid
-
-    async def get_status(self, download_id: str) -> Optional[Dict[str, Any]]:
-        """Return the raw aria2 status payload for a known download."""
-
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return None
-
-        keys = [
-            "gid",
-            "status",
-            "totalLength",
-            "completedLength",
-            "downloadSpeed",
-            "errorMessage",
-            "files",
-        ]
-        try:
-            status = await self._rpc_call("aria2.tellStatus", [transfer.gid, keys])
-        except Exception as exc:
-            raise Aria2Error(f"Failed to query aria2 download status: {exc}") from exc
-
-        if isinstance(status, dict):
-            return status
-        return None
-
-    async def get_status_by_gid(self, gid: str) -> Optional[Dict[str, Any]]:
-        keys = [
-            "gid",
-            "status",
-            "totalLength",
-            "completedLength",
-            "downloadSpeed",
-            "errorMessage",
-            "files",
-        ]
-        try:
-            status = await self._rpc_call("aria2.tellStatus", [gid, keys])
-        except Exception as exc:
-            message = str(exc)
-            if "cannot be found" in message.lower() or "not found" in message.lower():
-                return None
-            raise Aria2Error(f"Failed to query aria2 download status: {exc}") from exc
-
-        if isinstance(status, dict):
-            return status
-        return None
-
-    async def restore_transfer(self, download_id: str, gid: str, save_path: str) -> None:
-        await self._ensure_process()
-        self._transfers[download_id] = Aria2Transfer(
-            gid=gid,
-            save_path=os.path.abspath(save_path),
-        )
-
-    async def reassign_transfer(
-        self, from_download_id: str, to_download_id: str
-    ) -> Optional[Aria2Transfer]:
-        transfer = self._transfers.get(from_download_id)
-        if transfer is None:
-            return None
-
-        self._transfers[to_download_id] = transfer
-        if from_download_id != to_download_id:
-            self._transfers.pop(from_download_id, None)
-        return transfer
-
-    async def has_transfer(self, download_id: str) -> bool:
-        return download_id in self._transfers
-
-    async def pause_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.forcePause", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.upsert(download_id, {"status": "paused"})
-        return {"success": True, "message": "Download paused successfully"}
-
-    async def resume_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.unpause", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.upsert(download_id, {"status": "downloading"})
-        return {"success": True, "message": "Download resumed successfully"}
-
-    async def cancel_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.forceRemove", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.remove(download_id)
-        return {"success": True, "message": "Download cancelled successfully"}
-
-    async def close(self) -> None:
-        """Shut down the RPC process and session."""
-
-        if self._rpc_session is not None:
-            await self._rpc_session.close()
-            self._rpc_session = None
-
-        process = self._process
-        self._process = None
-        self._transfers.clear()
-
-        if process is None:
-            return
-
-        if process.returncode is None:
-            process.terminate()
-            try:
-                await asyncio.wait_for(process.wait(), timeout=5.0)
-            except asyncio.TimeoutError:
-                process.kill()
-                await process.wait()
-
-    async def _dispatch_progress(self, callback, snapshot: DownloadProgress) -> None:
-        try:
-            result = callback(snapshot, snapshot)
-        except TypeError:
-            result = callback(snapshot.percent_complete)
-
-        if asyncio.iscoroutine(result):
-            await result
-        elif hasattr(result, "__await__"):
-            await result
-
-    def _build_progress_snapshot(self, status: Dict[str, Any]) -> DownloadProgress:
-        completed = self._parse_int(status.get("completedLength"))
-        total = self._parse_int(status.get("totalLength"))
-        speed = float(self._parse_int(status.get("downloadSpeed")))
-        percent = 0.0
-        if total > 0:
-            percent = (completed / total) * 100.0
-
-        return DownloadProgress(
-            percent_complete=max(0.0, min(percent, 100.0)),
-            bytes_downloaded=completed,
-            total_bytes=total or None,
-            bytes_per_second=speed,
-            timestamp=datetime.now().timestamp(),
-        )
-
-    def _resolve_completed_path(self, status: Dict[str, Any], default_path: str) -> str:
-        files = status.get("files")
-        if isinstance(files, list) and files:
-            first = files[0]
-            if isinstance(first, dict):
-                candidate = first.get("path")
-                if isinstance(candidate, str) and candidate:
-                    return candidate
-        return default_path
-
-    @staticmethod
-    def _parse_int(value: Any) -> int:
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            return 0
-
-    async def _resolve_authenticated_redirect_url(
-        self,
-        url: str,
-        headers: Dict[str, str],
-    ) -> str:
-        downloader = await get_downloader()
-        session = await downloader.session
-        request_headers = dict(downloader.default_headers)
-        request_headers.update(headers)
-        request_headers["Accept-Encoding"] = "identity"
-
-        try:
-            async with session.get(
-                url,
-                headers=request_headers,
-                allow_redirects=False,
-                proxy=downloader.proxy_url,
-            ) as response:
-                if response.status in {301, 302, 303, 307, 308}:
-                    location = response.headers.get("Location")
-                    if location:
-                        return location
-                    raise Aria2Error(
-                        "Authenticated Civitai redirect did not include a Location header"
-                    )
-
-                if response.status == 200:
-                    return url
-
-                body = await response.text()
-                raise Aria2Error(
-                    f"Failed to resolve authenticated Civitai redirect: status={response.status} body={body[:300]}"
-                )
-        except aiohttp.ClientError as exc:
-            if is_ssl_cert_verify_error(exc):
-                logger.error(
-                    "SSL certificate verification failed during Civitai redirect "
-                    "resolution for %s. This is usually caused by an outdated CA "
-                    "certificate bundle. Recommended fixes:\n"
-                    "  1. pip install --upgrade certifi\n"
-                    "  2. pip install pip-system-certs",
-                    url,
-                )
-            raise Aria2Error(
-                f"Failed to resolve authenticated Civitai redirect: {exc}"
-            ) from exc
-
-    async def _ensure_process(self) -> None:
-        async with self._process_lock:
-            if self.is_running and await self._ping():
-                return
-
-            await self.close()
-
-            executable = self._resolve_executable()
-            self._rpc_port = self._find_free_port()
-            self._rpc_secret = secrets.token_hex(16)
-            self._rpc_url = f"http://127.0.0.1:{self._rpc_port}/jsonrpc"
-
-            command = [
-                executable,
-                "--enable-rpc=true",
-                "--rpc-listen-all=false",
-                f"--rpc-listen-port={self._rpc_port}",
-                f"--rpc-secret={self._rpc_secret}",
-                "--check-certificate=true",
-                # Point aria2 at certifi's CA bundle when available so it uses
-                # the same certificate store as Python downloads.
-                *((
-                    f"--ca-certificate={ca_cert}",
-                ) if (ca_cert := _try_certifi_ca_path()) else ()),
-                "--allow-overwrite=true",
-                "--auto-file-renaming=false",
-                "--file-allocation=none",
-                "--max-concurrent-downloads=5",
-                "--continue=true",
-                "--daemon=false",
-                "--quiet=true",
-                f"--stop-with-process={os.getpid()}",
-            ]
-
-            logger.info("Starting aria2 RPC daemon from %s", executable)
-            self._process = await asyncio.create_subprocess_exec(
-                *command,
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-            await self._wait_until_ready()
-
-    def _resolve_executable(self) -> str:
-        settings = get_settings_manager()
-        configured_path = (settings.get("aria2c_path") or "").strip()
-        candidate = configured_path or "aria2c"
-
-        resolved = shutil.which(candidate)
-        if resolved:
-            return resolved
-
-        if configured_path and os.path.isfile(configured_path) and os.access(
-            configured_path, os.X_OK
-        ):
-            return configured_path
-
-        raise Aria2Error(
-            "aria2c executable was not found. Install aria2 or configure aria2c_path."
-        )
-
-    async def _wait_until_ready(self) -> None:
-        assert self._process is not None
-
-        start_time = asyncio.get_running_loop().time()
-        last_error = ""
-        while asyncio.get_running_loop().time() - start_time < 10.0:
-            if self._process.returncode is not None:
-                stderr_output = ""
-                if self._process.stderr is not None:
-                    try:
-                        stderr_output = (
-                            await asyncio.wait_for(self._process.stderr.read(), timeout=0.2)
-                        ).decode("utf-8", errors="replace")
-                    except Exception:
-                        stderr_output = ""
-                raise Aria2Error(
-                    f"aria2 RPC process exited early with code {self._process.returncode}: {stderr_output.strip()}"
-                )
-
-            try:
-                if await self._ping():
-                    return
-            except Exception as exc:  # pragma: no cover - startup race
-                last_error = str(exc)
-
-            await asyncio.sleep(0.2)
-
-        raise Aria2Error(
-            f"Timed out waiting for aria2 RPC to become ready{': ' + last_error if last_error else ''}"
-        )
-
-    async def _ping(self) -> bool:
-        try:
-            result = await self._rpc_call("aria2.getVersion", [])
-        except Exception:
-            return False
-
-        return isinstance(result, dict)
-
-    async def _rpc_call(self, method: str, params: list[Any]) -> Any:
-        if not self._rpc_url:
-            raise Aria2Error("aria2 RPC endpoint is not initialized")
-
-        session = await self._get_rpc_session()
-        payload = {
-            "jsonrpc": "2.0",
-            "id": secrets.token_hex(8),
-            "method": method,
-            "params": [f"token:{self._rpc_secret}", *params],
-        }
-
-        async with session.post(self._rpc_url, json=payload) as response:
-            text = await response.text()
-
-        try:
-            body = json.loads(text)
-        except json.JSONDecodeError:
-            body = None
-
-        if body is None:
-            if response.status != 200:
-                raise Aria2Error(
-                    f"aria2 RPC returned status {response.status} with non-JSON body: {text}"
-                )
-            raise Aria2Error(f"Invalid aria2 RPC response: {text}")
-
-        if "error" in body:
-            error = body["error"] or {}
-            code = error.get("code") if isinstance(error, dict) else None
-            message = error.get("message") if isinstance(error, dict) else str(error)
-            logger.error(
-                "aria2 RPC %s failed with HTTP %s, code=%s, message=%s",
-                method,
-                response.status,
-                code,
-                message,
-            )
-            status_message = (
-                f"aria2 RPC {method} failed with status {response.status}: {message}"
-                if response.status != 200
-                else message
-            )
-            raise Aria2Error(status_message or "Unknown aria2 RPC error")
-
-        if response.status != 200:
-            logger.error(
-                "aria2 RPC %s returned unexpected HTTP status %s without error payload: %s",
-                method,
-                response.status,
-                body,
-            )
-            raise Aria2Error(
-                f"aria2 RPC {method} returned unexpected status {response.status}"
-            )
-
-        return body.get("result")
-
-    async def _get_rpc_session(self) -> aiohttp.ClientSession:
-        if self._rpc_session is None or self._rpc_session.closed:
-            async with self._rpc_session_lock:
-                if self._rpc_session is None or self._rpc_session.closed:
-                    timeout = aiohttp.ClientTimeout(total=30)
-                    self._rpc_session = aiohttp.ClientSession(timeout=timeout)
-        return self._rpc_session
-
-    @staticmethod
-    def _find_free_port() -> int:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.bind(("127.0.0.1", 0))
-            sock.listen(1)
-            return int(sock.getsockname()[1])
-
-
-async def get_aria2_downloader() -> Aria2Downloader:
-    """Get the singleton aria2 downloader."""
-
-    return await Aria2Downloader.get_instance()

py/services/aria2_transfer_state.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-from copy import deepcopy
-from typing import Any, Dict, Optional
-
-from ..utils.cache_paths import get_cache_base_dir
-
-
-def get_aria2_state_path() -> str:
-    base_dir = get_cache_base_dir(create=True)
-    state_dir = os.path.join(base_dir, "aria2")
-    os.makedirs(state_dir, exist_ok=True)
-    return os.path.join(state_dir, "downloads.json")
-
-
-class Aria2TransferStateStore:
-    """Persist aria2 transfer metadata needed for restart recovery."""
-
-    _locks_by_path: Dict[str, asyncio.Lock] = {}
-
-    def __init__(self, state_path: Optional[str] = None) -> None:
-        self._state_path = os.path.abspath(state_path or get_aria2_state_path())
-        self._lock = self._locks_by_path.setdefault(self._state_path, asyncio.Lock())
-
-    def _read_all_unlocked(self) -> Dict[str, Dict[str, Any]]:
-        try:
-            with open(self._state_path, "r", encoding="utf-8") as handle:
-                data = json.load(handle)
-        except FileNotFoundError:
-            return {}
-        except json.JSONDecodeError:
-            return {}
-
-        if not isinstance(data, dict):
-            return {}
-
-        normalized: Dict[str, Dict[str, Any]] = {}
-        for download_id, entry in data.items():
-            if isinstance(download_id, str) and isinstance(entry, dict):
-                normalized[download_id] = entry
-        return normalized
-
-    def _write_all_unlocked(self, data: Dict[str, Dict[str, Any]]) -> None:
-        directory = os.path.dirname(self._state_path)
-        if directory:
-            os.makedirs(directory, exist_ok=True)
-
-        temp_path = f"{self._state_path}.tmp"
-        with open(temp_path, "w", encoding="utf-8") as handle:
-            json.dump(data, handle, ensure_ascii=True, indent=2, sort_keys=True)
-        os.replace(temp_path, self._state_path)
-
-    async def load_all(self) -> Dict[str, Dict[str, Any]]:
-        async with self._lock:
-            return deepcopy(self._read_all_unlocked())
-
-    async def get(self, download_id: str) -> Optional[Dict[str, Any]]:
-        async with self._lock:
-            return deepcopy(self._read_all_unlocked().get(download_id))
-
-    async def upsert(self, download_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        async with self._lock:
-            data = self._read_all_unlocked()
-            current = data.get(download_id, {})
-            current.update(payload)
-            data[download_id] = current
-            self._write_all_unlocked(data)
-            return deepcopy(current)
-
-    async def remove(self, download_id: str) -> None:
-        async with self._lock:
-            data = self._read_all_unlocked()
-            if download_id in data:
-                del data[download_id]
-                self._write_all_unlocked(data)
-
-    async def find_by_save_path(
-        self, save_path: str, *, exclude_download_id: Optional[str] = None
-    ) -> Optional[Dict[str, Any]]:
-        normalized_target = os.path.abspath(save_path)
-        async with self._lock:
-            data = self._read_all_unlocked()
-            for download_id, entry in data.items():
-                if exclude_download_id and download_id == exclude_download_id:
-                    continue
-                candidate = entry.get("save_path")
-                if isinstance(candidate, str) and os.path.abspath(candidate) == normalized_target:
-                    result = dict(entry)
-                    result["download_id"] = download_id
-                    return result
-        return None
-
-    async def reassign(self, from_download_id: str, to_download_id: str) -> Optional[Dict[str, Any]]:
-        async with self._lock:
-            data = self._read_all_unlocked()
-            existing = data.get(from_download_id)
-            if existing is None:
-                return None
-            updated = dict(existing)
-            updated["download_id"] = to_download_id
-            data[to_download_id] = updated
-            if from_download_id != to_download_id:
-                data.pop(from_download_id, None)
-            self._write_all_unlocked(data)
-            return deepcopy(updated)

py/services/auto_tag_service.py

@@ -1,139 +0,0 @@
-"""
-Auto-tag extraction service for model cards.
-
-Extracts implicit model attributes (HIGH/LOW, I2V/T2V/TI2V, Lightning, Turbo)
-from filename, base_model, and CivitAI version name — no manual tagging required.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Dict, List, Set
-
-# ── Tag category definitions ──────────────────────────────────────────
-# Each category maps a display label to a regex pattern.
-# Patterns are case-insensitive and matched against filename, base_model,
-# and civitai version name.
-
-# Use (?<![a-zA-Z0-9]) and (?![a-zA-Z0-9]) instead of \b because
-# Python's \b treats underscore as a word character, so \bHIGH\b
-# won't match '_HIGH_' in filenames.
-_B = r"(?<![a-zA-Z0-9])"   # left boundary
-_E = r"(?![a-zA-Z0-9])"    # right boundary
-
-AUTO_TAG_CATEGORIES: Dict[str, str] = {
-    "HIGH":      _B + r"HIGH" + _E,
-    "LOW":       _B + r"(?<!F)LOW" + _E,
-    "I2V":       _B + r"I2V" + _E,
-    "T2V":       _B + r"T2V" + _E,
-    "TI2V":      _B + r"TI2V" + _E,
-    "Lightning": _B + r"Lightning" + _E,
-    "Turbo":     _B + r"Turbo" + _E,
-}
-
-# Tags that belong to the "mode" group (HIGH/LOW)
-MODE_TAGS = {"HIGH", "LOW"}
-
-# Tags that belong to the "video mode" group (I2V/T2V/TI2V)
-VIDEO_MODE_TAGS = {"I2V", "T2V", "TI2V"}
-
-# Tags that belong to the "speed/optimization" group
-SPEED_TAGS = {"Lightning", "Turbo"}
-
-# ── Display category groups (for settings UI) ─────────────────────────
-
-AUTO_TAG_GROUPS = {
-    "mode":   {"HIGH", "LOW"},
-    "video":  {"I2V", "T2V", "TI2V"},
-    "speed":  {"Lightning", "Turbo"},
-}
-
-# Default enabled categories
-DEFAULT_ENABLED_GROUPS = {"mode", "video"}
-
-
-def _collect_sources(model_data: Dict) -> List[str]:
-    """Collect all text sources from model data for tag matching."""
-    sources: List[str] = []
-
-    file_name = model_data.get("file_name", "")
-    if file_name:
-        sources.append(file_name)
-
-    base_model = model_data.get("base_model", "")
-    if base_model:
-        sources.append(base_model)
-
-    civitai = model_data.get("civitai", {})
-    if isinstance(civitai, dict):
-        version_name = civitai.get("name", "")
-        if version_name:
-            sources.append(version_name)
-
-    return sources
-
-
-def extract_auto_tags(model_data: Dict) -> List[str]:
-    """Extract auto-detected tags from model metadata.
-
-    Uses a two-layer approach:
-      Layer 1 — Regex-based detection against filename, base_model, and
-                CivitAI version name.
-      Layer 2 — Merge in any user-defined tags that overlap with known
-                auto-tag categories. This provides a manual fallback when
-                auto-detection fails (e.g. "I2V HN" or unlabeled models).
-
-    HIGH/LOW tags are only returned when the base_model indicates a Wan
-    family model — no other model architecture uses this distinction.
-
-    Args:
-        model_data: Model metadata dict with keys:
-            file_name, base_model, civitai (with optional 'name' field),
-            tags (user-defined tag list, used as fallback).
-
-    Returns:
-        Sorted list of unique auto-tag strings (e.g. ["I2V"]).
-    """
-    sources = _collect_sources(model_data)
-    base_model = model_data.get("base_model", "")
-    is_wan = "wan" in base_model.lower()
-
-    found: Set[str] = set()
-
-    # ── Layer 1: regex-based detection ────────────────────────────
-    if sources:
-        for label, pattern in AUTO_TAG_CATEGORIES.items():
-            # HIGH/LOW are Wan-specific — skip for non-Wan to avoid noise
-            if label in ("HIGH", "LOW"):
-                if not is_wan:
-                    continue
-                # Use case-insensitive character class + case-sensitive boundary,
-                # so "HighNoise" (camelCase) matches but "highlight" doesn't.
-                # Boundary: not followed by lowercase letter (= word has ended).
-                ci = "".join(f"[{c.lower()}{c.upper()}]" for c in label)
-                if label == "LOW":
-                    regex = re.compile(r"(?<![Ff])" + ci + r"(?![a-z])")
-                else:
-                    regex = re.compile(ci + r"(?![a-z])")
-            else:
-                regex = re.compile(pattern, re.IGNORECASE)
-            for source in sources:
-                if regex.search(source):
-                    found.add(label)
-                    break
-
-    # ── Layer 2: user-defined tags as manual fallback ─────────────
-    # When auto-detection fails (abbreviated names like "Hi"/"Lo",
-    # "I2V HN", or unlabeled models), users can add canonical tags
-    # (HIGH, LOW, I2V, etc.) to the model's regular tags for correct
-    # badge display and filtering. Matching is case-insensitive so
-    # "high"/"High"/"HIGH" all resolve to the canonical label.
-    user_tags = model_data.get("tags")
-    if user_tags:
-        label_map = {label.lower(): label for label in AUTO_TAG_CATEGORIES}
-        for t in user_tags:
-            canonical = label_map.get(t.lower())
-            if canonical:
-                found.add(canonical)
-
-    return sorted(found)

py/services/backup_service.py

@@ -1,423 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import hashlib
-import json
-import logging
-import os
-import shutil
-import tempfile
-import time
-import zipfile
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Iterable, Optional
-
-from ..utils.cache_paths import CacheType, get_cache_base_dir, get_cache_file_path
-from ..utils.settings_paths import get_settings_dir
-from .settings_manager import get_settings_manager
-
-logger = logging.getLogger(__name__)
-
-
-BACKUP_MANIFEST_VERSION = 1
-DEFAULT_BACKUP_RETENTION_COUNT = 5
-DEFAULT_BACKUP_INTERVAL_SECONDS = 24 * 60 * 60
-
-
-@dataclass(frozen=True)
-class BackupEntry:
-    kind: str
-    archive_path: str
-    target_path: str
-    sha256: str
-    size: int
-    mtime: float
-
-
-class BackupService:
-    """Create and restore user-state backup archives."""
-
-    _instance: "BackupService | None" = None
-    _instance_lock = asyncio.Lock()
-
-    def __init__(self, *, settings_manager=None, backup_dir: str | None = None) -> None:
-        self._settings = settings_manager or get_settings_manager()
-        self._backup_dir = Path(backup_dir or self._resolve_backup_dir())
-        self._backup_dir.mkdir(parents=True, exist_ok=True)
-        self._lock = asyncio.Lock()
-        self._auto_task: asyncio.Task[None] | None = None
-
-    @classmethod
-    async def get_instance(cls) -> "BackupService":
-        async with cls._instance_lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            cls._instance._ensure_auto_snapshot_task()
-            return cls._instance
-
-    @staticmethod
-    def _resolve_backup_dir() -> str:
-        return os.path.join(get_settings_dir(create=True), "backups")
-
-    def get_backup_dir(self) -> str:
-        return str(self._backup_dir)
-
-    def _ensure_auto_snapshot_task(self) -> None:
-        if self._auto_task is not None and not self._auto_task.done():
-            return
-
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            return
-
-        self._auto_task = loop.create_task(self._auto_backup_loop())
-
-    def _get_setting_bool(self, key: str, default: bool) -> bool:
-        try:
-            return bool(self._settings.get(key, default))
-        except Exception:
-            return default
-
-    def _get_setting_int(self, key: str, default: int) -> int:
-        try:
-            value = self._settings.get(key, default)
-            return max(1, int(value))
-        except Exception:
-            return default
-
-    def _settings_file_path(self) -> str:
-        settings_file = getattr(self._settings, "settings_file", None)
-        if settings_file:
-            return str(settings_file)
-        return os.path.join(get_settings_dir(create=True), "settings.json")
-
-    def _download_history_path(self) -> str:
-        base_dir = get_cache_base_dir(create=True)
-        history_dir = os.path.join(base_dir, "download_history")
-        os.makedirs(history_dir, exist_ok=True)
-        return os.path.join(history_dir, "downloaded_versions.sqlite")
-
-    def _model_update_dir(self) -> str:
-        return str(Path(get_cache_file_path(CacheType.MODEL_UPDATE, create_dir=True)).parent)
-
-    def _model_update_targets(self) -> list[tuple[str, str, str]]:
-        """Return (kind, archive_path, target_path) tuples for backup."""
-
-        targets: list[tuple[str, str, str]] = []
-
-        settings_path = self._settings_file_path()
-        targets.append(("settings", "settings/settings.json", settings_path))
-
-        history_path = self._download_history_path()
-        targets.append(
-            (
-                "download_history",
-                "cache/download_history/downloaded_versions.sqlite",
-                history_path,
-            )
-        )
-
-        symlink_path = get_cache_file_path(CacheType.SYMLINK, create_dir=True)
-        targets.append(
-            (
-                "symlink_map",
-                "cache/symlink/symlink_map.json",
-                symlink_path,
-            )
-        )
-
-        model_update_dir = Path(self._model_update_dir())
-        if model_update_dir.exists():
-            for sqlite_file in sorted(model_update_dir.glob("*.sqlite")):
-                targets.append(
-                    (
-                        "model_update",
-                        f"cache/model_update/{sqlite_file.name}",
-                        str(sqlite_file),
-                    )
-                )
-
-        stats_path = os.path.join(get_settings_dir(create=True), "stats", "lora_manager_stats.json")
-        if os.path.exists(stats_path):
-            targets.append(
-                (
-                    "usage_stats",
-                    "stats/lora_manager_stats.json",
-                    stats_path,
-                )
-            )
-
-        return targets
-
-    @staticmethod
-    def _hash_file(path: str) -> tuple[str, int, float]:
-        digest = hashlib.sha256()
-        total = 0
-        with open(path, "rb") as handle:
-            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-                total += len(chunk)
-                digest.update(chunk)
-        mtime = os.path.getmtime(path)
-        return digest.hexdigest(), total, mtime
-
-    def _build_manifest(self, entries: Iterable[BackupEntry], *, snapshot_type: str) -> dict[str, Any]:
-        created_at = datetime.now(timezone.utc).isoformat()
-        active_library = None
-        try:
-            active_library = self._settings.get_active_library_name()
-        except Exception:
-            active_library = None
-
-        return {
-            "manifest_version": BACKUP_MANIFEST_VERSION,
-            "created_at": created_at,
-            "snapshot_type": snapshot_type,
-            "active_library": active_library,
-            "files": [
-                {
-                    "kind": entry.kind,
-                    "archive_path": entry.archive_path,
-                    "target_path": entry.target_path,
-                    "sha256": entry.sha256,
-                    "size": entry.size,
-                    "mtime": entry.mtime,
-                }
-                for entry in entries
-            ],
-        }
-
-    def _write_archive(self, archive_path: str, entries: list[BackupEntry], manifest: dict[str, Any]) -> None:
-        with zipfile.ZipFile(
-            archive_path,
-            mode="w",
-            compression=zipfile.ZIP_DEFLATED,
-            compresslevel=6,
-        ) as zf:
-            zf.writestr(
-                "manifest.json",
-                json.dumps(manifest, indent=2, ensure_ascii=False).encode("utf-8"),
-            )
-            for entry in entries:
-                zf.write(entry.target_path, arcname=entry.archive_path)
-
-    async def create_snapshot(self, *, snapshot_type: str = "manual", persist: bool = False) -> dict[str, Any]:
-        """Create a backup archive.
-
-        If ``persist`` is true, the archive is stored in the backup directory
-        and retained according to the configured retention policy.
-        """
-
-        async with self._lock:
-            raw_targets = self._model_update_targets()
-            entries: list[BackupEntry] = []
-            for kind, archive_path, target_path in raw_targets:
-                if not os.path.exists(target_path):
-                    continue
-                sha256, size, mtime = self._hash_file(target_path)
-                entries.append(
-                    BackupEntry(
-                        kind=kind,
-                        archive_path=archive_path,
-                        target_path=target_path,
-                        sha256=sha256,
-                        size=size,
-                        mtime=mtime,
-                    )
-                )
-
-            if not entries:
-                raise FileNotFoundError("No backupable files were found")
-
-            manifest = self._build_manifest(entries, snapshot_type=snapshot_type)
-            archive_name = self._build_archive_name(snapshot_type=snapshot_type)
-            fd, temp_path = tempfile.mkstemp(suffix=".zip", dir=str(self._backup_dir))
-            os.close(fd)
-
-            try:
-                self._write_archive(temp_path, entries, manifest)
-                if persist:
-                    final_path = self._backup_dir / archive_name
-                    os.replace(temp_path, final_path)
-                    self._prune_snapshots()
-                    return {
-                        "archive_path": str(final_path),
-                        "archive_name": final_path.name,
-                        "manifest": manifest,
-                    }
-
-                with open(temp_path, "rb") as handle:
-                    data = handle.read()
-                return {
-                    "archive_name": archive_name,
-                    "archive_bytes": data,
-                    "manifest": manifest,
-                }
-            finally:
-                with contextlib.suppress(FileNotFoundError):
-                    os.remove(temp_path)
-
-    def _build_archive_name(self, *, snapshot_type: str) -> str:
-        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
-        return f"lora-manager-backup-{timestamp}-{snapshot_type}.zip"
-
-    def _prune_snapshots(self) -> None:
-        retention = self._get_setting_int(
-            "backup_retention_count", DEFAULT_BACKUP_RETENTION_COUNT
-        )
-        archives = sorted(
-            self._backup_dir.glob("lora-manager-backup-*-auto.zip"),
-            key=lambda path: path.stat().st_mtime,
-            reverse=True,
-        )
-        for path in archives[retention:]:
-            with contextlib.suppress(OSError):
-                path.unlink()
-
-    async def restore_snapshot(self, archive_path: str) -> dict[str, Any]:
-        """Restore backup contents from a ZIP archive."""
-
-        async with self._lock:
-            try:
-                zf = zipfile.ZipFile(archive_path, mode="r")
-            except zipfile.BadZipFile as exc:
-                raise ValueError("Backup archive is not a valid ZIP file") from exc
-
-            with zf:
-                try:
-                    manifest = json.loads(zf.read("manifest.json").decode("utf-8"))
-                except KeyError as exc:
-                    raise ValueError("Backup archive is missing manifest.json") from exc
-
-                if not isinstance(manifest, dict):
-                    raise ValueError("Backup manifest is invalid")
-                if manifest.get("manifest_version") != BACKUP_MANIFEST_VERSION:
-                    raise ValueError("Backup manifest version is not supported")
-
-                files = manifest.get("files", [])
-                if not isinstance(files, list):
-                    raise ValueError("Backup manifest file list is invalid")
-
-                extracted_paths: list[tuple[str, str]] = []
-                temp_dir = Path(tempfile.mkdtemp(prefix="lora-manager-restore-"))
-                try:
-                    for item in files:
-                        if not isinstance(item, dict):
-                            continue
-                        archive_member = item.get("archive_path")
-                        if not isinstance(archive_member, str) or not archive_member:
-                            continue
-                        archive_member_path = Path(archive_member)
-                        if archive_member_path.is_absolute() or ".." in archive_member_path.parts:
-                            raise ValueError(f"Invalid archive member path: {archive_member}")
-
-                        kind = item.get("kind")
-                        target_path = self._resolve_restore_target(kind, archive_member)
-                        if target_path is None:
-                            continue
-
-                        extracted_path = temp_dir / archive_member_path
-                        extracted_path.parent.mkdir(parents=True, exist_ok=True)
-                        with zf.open(archive_member) as source, open(
-                            extracted_path, "wb"
-                        ) as destination:
-                            shutil.copyfileobj(source, destination)
-
-                        expected_hash = item.get("sha256")
-                        if isinstance(expected_hash, str) and expected_hash:
-                            actual_hash, _, _ = self._hash_file(str(extracted_path))
-                            if actual_hash != expected_hash:
-                                raise ValueError(
-                                    f"Checksum mismatch for {archive_member}"
-                                )
-
-                        extracted_paths.append((str(extracted_path), target_path))
-
-                    for extracted_path, target_path in extracted_paths:
-                        os.makedirs(os.path.dirname(target_path), exist_ok=True)
-                        os.replace(extracted_path, target_path)
-                finally:
-                    shutil.rmtree(temp_dir, ignore_errors=True)
-
-            return {
-                "success": True,
-                "restored_files": len(extracted_paths),
-                "snapshot_type": manifest.get("snapshot_type"),
-            }
-
-    def _resolve_restore_target(self, kind: Any, archive_member: str) -> str | None:
-        if kind == "settings":
-            return self._settings_file_path()
-        if kind == "download_history":
-            return self._download_history_path()
-        if kind == "symlink_map":
-            return get_cache_file_path(CacheType.SYMLINK, create_dir=True)
-        if kind == "model_update":
-            filename = os.path.basename(archive_member)
-            return str(Path(get_cache_file_path(CacheType.MODEL_UPDATE, create_dir=True)).parent / filename)
-        if kind == "usage_stats":
-            return os.path.join(get_settings_dir(create=True), "stats", "lora_manager_stats.json")
-        return None
-
-    async def create_auto_snapshot_if_due(self) -> Optional[dict[str, Any]]:
-        if not self._get_setting_bool("backup_auto_enabled", True):
-            return None
-
-        latest = self.get_latest_auto_snapshot()
-        now = time.time()
-        if latest and now - latest["mtime"] < DEFAULT_BACKUP_INTERVAL_SECONDS:
-            return None
-
-        return await self.create_snapshot(snapshot_type="auto", persist=True)
-
-    async def _auto_backup_loop(self) -> None:
-        while True:
-            try:
-                await self.create_auto_snapshot_if_due()
-                await asyncio.sleep(DEFAULT_BACKUP_INTERVAL_SECONDS)
-            except asyncio.CancelledError:
-                raise
-            except Exception as exc:  # pragma: no cover - defensive guard
-                logger.warning("Automatic backup snapshot failed: %s", exc, exc_info=True)
-                await asyncio.sleep(60)
-
-    def get_available_snapshots(self) -> list[dict[str, Any]]:
-        snapshots: list[dict[str, Any]] = []
-        for path in sorted(self._backup_dir.glob("lora-manager-backup-*.zip")):
-            try:
-                stat = path.stat()
-            except OSError:
-                continue
-            snapshots.append(
-                {
-                    "name": path.name,
-                    "path": str(path),
-                    "size": stat.st_size,
-                    "mtime": stat.st_mtime,
-                    "is_auto": path.name.endswith("-auto.zip"),
-                }
-            )
-        snapshots.sort(key=lambda item: item["mtime"], reverse=True)
-        return snapshots
-
-    def get_latest_auto_snapshot(self) -> Optional[dict[str, Any]]:
-        autos = [snapshot for snapshot in self.get_available_snapshots() if snapshot["is_auto"]]
-        if not autos:
-            return None
-        return autos[0]
-
-    def get_status(self) -> dict[str, Any]:
-        snapshots = self.get_available_snapshots()
-        return {
-            "backupDir": self.get_backup_dir(),
-            "enabled": self._get_setting_bool("backup_auto_enabled", True),
-            "retentionCount": self._get_setting_int(
-                "backup_retention_count", DEFAULT_BACKUP_RETENTION_COUNT
-            ),
-            "snapshotCount": len(snapshots),
-            "latestSnapshot": snapshots[0] if snapshots else None,
-            "latestAutoSnapshot": self.get_latest_auto_snapshot(),
-        }

py/services/base_model_service.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 import asyncio
-import re
 from typing import Any, Dict, List, Optional, Type, TYPE_CHECKING
 import logging
 import os
@@ -20,7 +19,6 @@ from .model_query import (
     resolve_sub_type,
 )
 from .settings_manager import get_settings_manager
-from ..utils.civitai_utils import build_civitai_model_page_url
 
 logger = logging.getLogger(__name__)
 
@@ -77,7 +75,6 @@ class BaseModelService(ABC):
         base_models: list = None,
         model_types: list = None,
         tags: Optional[Dict[str, str]] = None,
-        auto_tags: Optional[Dict[str, str]] = None,
         search_options: dict = None,
         hash_filters: dict = None,
         favorites_only: bool = False,
@@ -96,11 +93,6 @@ class BaseModelService(ABC):
             sorted_data = await self._fetch_with_usage_sort(sort_params)
         else:
             sorted_data = await self.cache_repository.fetch_sorted(sort_params)
-        # Pre-compute auto_tags for every item — needed for both filtering
-        # and display. Computation is cheap (string regex on 2-3 fields).
-        from .auto_tag_service import extract_auto_tags
-        for item in sorted_data:
-            item["auto_tags"] = extract_auto_tags(item)
         fetch_duration = time.perf_counter() - t0
         initial_count = len(sorted_data)
 
@@ -116,7 +108,6 @@ class BaseModelService(ABC):
                 base_models=base_models,
                 model_types=model_types,
                 tags=tags,
-                auto_tags=auto_tags,
                 favorites_only=favorites_only,
                 search_options=search_options,
                 tag_logic=tag_logic,
@@ -186,57 +177,6 @@ class BaseModelService(ABC):
         )
         return paginated
 
-    async def get_excluded_paginated_data(
-        self,
-        page: int,
-        page_size: int,
-        sort_by: str = "name",
-        search: str = None,
-        fuzzy_search: bool = False,
-        search_options: dict = None,
-        **kwargs,
-    ) -> Dict:
-        """Get paginated excluded model data."""
-        excluded_paths = list(self.scanner.get_excluded_models())
-        excluded_entries: List[Dict[str, Any]] = []
-        stale_paths: List[str] = []
-
-        for file_path in excluded_paths:
-            if not file_path or not os.path.exists(file_path):
-                stale_paths.append(file_path)
-                continue
-
-            entry = await self._build_excluded_entry(file_path)
-            if entry:
-                excluded_entries.append(entry)
-            else:
-                stale_paths.append(file_path)
-
-        if stale_paths:
-            current_excluded = getattr(self.scanner, "_excluded_models", None)
-            if isinstance(current_excluded, list):
-                stale_set = set(stale_paths)
-                self.scanner._excluded_models = [
-                    path for path in current_excluded if path not in stale_set
-                ]
-                persist_current_cache = getattr(self.scanner, "_persist_current_cache", None)
-                if callable(persist_current_cache):
-                    await persist_current_cache()
-
-        excluded_entries = self._sort_entries(excluded_entries, sort_by)
-
-        if search:
-            excluded_entries = await self._apply_search_filters(
-                excluded_entries,
-                search,
-                fuzzy_search,
-                search_options,
-            )
-
-        paginated = self._paginate(excluded_entries, page, page_size)
-        paginated["items"] = await self._annotate_update_flags(paginated["items"])
-        return paginated
-
     async def _fetch_with_usage_sort(self, sort_params):
         """Fetch data sorted by usage count (desc/asc)."""
         cache = await self.cache_repository.get_cache()
@@ -267,71 +207,11 @@ class BaseModelService(ABC):
 
         reverse = sort_params.order == "desc"
         annotated.sort(
-            key=lambda x: (
+            key=lambda x: (x.get("usage_count", 0), x.get("model_name", "").lower()),
-                x.get("usage_count", 0),
-                x.get("model_name", "").lower(),
-                x.get("file_path", "").lower()
-            ),
             reverse=reverse,
         )
         return annotated
 
-    def _sort_entries(self, data: List[Dict[str, Any]], sort_by: str) -> List[Dict[str, Any]]:
-        sort_params = self.cache_repository.parse_sort(sort_by)
-        key_name = sort_params.key
-
-        if key_name == "date":
-            key_fn = lambda item: (
-                float(item.get("modified", 0.0) or 0.0),
-                (item.get("model_name") or item.get("file_name") or "").lower(),
-                item.get("file_path", "").lower(),
-            )
-        elif key_name == "size":
-            key_fn = lambda item: (
-                int(item.get("size", 0) or 0),
-                (item.get("model_name") or item.get("file_name") or "").lower(),
-                item.get("file_path", "").lower(),
-            )
-        elif key_name == "usage":
-            key_fn = lambda item: (
-                int(item.get("usage_count", 0) or 0),
-                (item.get("model_name") or item.get("file_name") or "").lower(),
-                item.get("file_path", "").lower(),
-            )
-        else:
-            key_fn = lambda item: (
-                (item.get("model_name") or item.get("file_name") or "").lower(),
-                item.get("file_path", "").lower(),
-            )
-
-        return sorted(data, key=key_fn, reverse=sort_params.order == "desc")
-
-    async def _build_excluded_entry(self, file_path: str) -> Optional[Dict[str, Any]]:
-        root_path = self.scanner._find_root_for_file(file_path)
-        if not root_path:
-            return None
-
-        metadata, should_skip = await MetadataManager.load_metadata(
-            file_path,
-            self.metadata_class,
-        )
-        if should_skip:
-            return None
-
-        if metadata is None:
-            metadata = await self.scanner._create_default_metadata(file_path)
-            if metadata is None:
-                return None
-
-        metadata = self.scanner.adjust_metadata(metadata, file_path, root_path)
-        folder = os.path.dirname(os.path.relpath(file_path, root_path)).replace(
-            os.path.sep, "/"
-        )
-        entry = self.scanner._build_cache_entry(metadata, folder=folder)
-        entry = self.scanner.adjust_cached_entry(entry)
-        entry["exclude"] = True
-        return entry
-
     async def _apply_hash_filters(
         self, data: List[Dict], hash_filters: Dict
     ) -> List[Dict]:
@@ -361,7 +241,6 @@ class BaseModelService(ABC):
         base_models: list = None,
         model_types: list = None,
         tags: Optional[Dict[str, str]] = None,
-        auto_tags: Optional[Dict[str, str]] = None,
         favorites_only: bool = False,
         search_options: dict = None,
         tag_logic: str = "any",
@@ -375,7 +254,6 @@ class BaseModelService(ABC):
             base_models=base_models,
             model_types=model_types,
             tags=tags,
-            auto_tags=auto_tags,
             favorites_only=favorites_only,
             search_options=normalized_options,
             tag_logic=tag_logic,
@@ -502,15 +380,6 @@ class BaseModelService(ABC):
             strategy = "same_base"
         same_base_mode = strategy == "same_base"
 
-        # Check user setting for hiding early access updates
-        hide_early_access = False
-        try:
-            hide_early_access = bool(
-                self.settings.get("hide_early_access_updates", False)
-            )
-        except Exception:
-            hide_early_access = False
-
         records = None
         resolved: Optional[Dict[int, bool]] = None
         if same_base_mode:
@@ -519,7 +388,7 @@ class BaseModelService(ABC):
                 try:
                     records = await record_method(self.model_type, ordered_ids)
                     resolved = {
-                        model_id: record.has_update(hide_early_access=hide_early_access)
+                        model_id: record.has_update()
                         for model_id, record in records.items()
                     }
                 except Exception as exc:
@@ -537,11 +406,7 @@ class BaseModelService(ABC):
             bulk_method = getattr(self.update_service, "has_updates_bulk", None)
             if callable(bulk_method):
                 try:
-                    resolved = await bulk_method(
+                    resolved = await bulk_method(self.model_type, ordered_ids)
-                        self.model_type,
-                        ordered_ids,
-                        hide_early_access=hide_early_access,
-                    )
                 except Exception as exc:
                     logger.error(
                         "Failed to resolve update status in bulk for %s models (%s): %s",
@@ -554,9 +419,7 @@ class BaseModelService(ABC):
 
         if resolved is None:
             tasks = [
-                self.update_service.has_update(
+                self.update_service.has_update(self.model_type, model_id)
-                    self.model_type, model_id, hide_early_access=hide_early_access
-                )
                 for model_id in ordered_ids
             ]
             results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -594,7 +457,6 @@ class BaseModelService(ABC):
                     flag = record.has_update_for_base(
                         threshold_version,
                         base_model,
-                        hide_early_access=hide_early_access,
                     )
                 else:
                     flag = default_flag
@@ -718,19 +580,13 @@ class BaseModelService(ABC):
             normalized_type = normalize_sub_type(resolve_sub_type(entry))
             if not normalized_type:
                 continue
-
+            
             # Filter by valid sub-types based on scanner type
-            if (
+            if self.model_type == "lora" and normalized_type not in VALID_LORA_SUB_TYPES:
-                self.model_type == "lora"
-                and normalized_type not in VALID_LORA_SUB_TYPES
-            ):
                 continue
-            if (
+            if self.model_type == "checkpoint" and normalized_type not in VALID_CHECKPOINT_SUB_TYPES:
-                self.model_type == "checkpoint"
-                and normalized_type not in VALID_CHECKPOINT_SUB_TYPES
-            ):
                 continue
-
+            
             type_counts[normalized_type] = type_counts.get(normalized_type, 0) + 1
 
         sorted_types = sorted(
@@ -870,86 +726,30 @@ class BaseModelService(ABC):
         """Get the static preview URL for a model file"""
         cache = await self.scanner.get_cached_data()
 
-        name_normalized = model_name.replace("\\", "/")
-        name_no_ext = name_normalized
-        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
-            if name_no_ext.lower().endswith(ext):
-                name_no_ext = name_no_ext[: -len(ext)]
-                break
-
-        has_path = "/" in name_no_ext
-        basename = os.path.basename(name_no_ext) if has_path else name_no_ext
-        best_fallback = None
-
         for model in cache.raw_data:
-            file_name = model.get("file_name", "")
+            if model["file_name"] == model_name:
-            folder = model.get("folder", "")
-            file_name_no_ext = file_name
-            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
-                if file_name_no_ext.lower().endswith(ext):
-                    file_name_no_ext = file_name_no_ext[: -len(ext)]
-                    break
-            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
-
-            if name_no_ext == file_name_no_ext or name_no_ext == path_name:
                 preview_url = model.get("preview_url")
                 if preview_url:
                     from ..config import config
 
                     return config.get_preview_static_url(preview_url)
 
-            if has_path and file_name_no_ext == basename:
-                if folder and name_no_ext.startswith(folder.replace("\\", "/") + "/"):
-                    best_fallback = model
-                elif best_fallback is None:
-                    best_fallback = model
-
-        if best_fallback:
-            preview_url = best_fallback.get("preview_url")
-            if preview_url:
-                from ..config import config
-
-                return config.get_preview_static_url(preview_url)
-
         return "/loras_static/images/no-preview.png"
 
     async def get_model_civitai_url(self, model_name: str) -> Dict[str, Optional[str]]:
         """Get the Civitai URL for a model file"""
         cache = await self.scanner.get_cached_data()
 
-        name_normalized = model_name.replace("\\", "/")
-        name_no_ext = name_normalized
-        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
-            if name_no_ext.lower().endswith(ext):
-                name_no_ext = name_no_ext[: -len(ext)]
-                break
-
-        has_path = "/" in name_no_ext
-        basename = os.path.basename(name_no_ext) if has_path else name_no_ext
-        best_fallback = None
-
         for model in cache.raw_data:
-            file_name = model.get("file_name", "")
+            if model["file_name"] == model_name:
-            folder = model.get("folder", "")
-            file_name_no_ext = file_name
-            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
-                if file_name_no_ext.lower().endswith(ext):
-                    file_name_no_ext = file_name_no_ext[: -len(ext)]
-                    break
-            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
-
-            if name_no_ext == file_name_no_ext or name_no_ext == path_name:
                 civitai_data = model.get("civitai", {})
                 model_id = civitai_data.get("modelId")
                 version_id = civitai_data.get("id")
 
                 if model_id:
-                    civitai_host = self.settings.get("civitai_host", "civitai.com")
+                    civitai_url = f"https://civitai.com/models/{model_id}"
-                    civitai_url = build_civitai_model_page_url(
+                    if version_id:
-                        model_id,
+                        civitai_url += f"?modelVersionId={version_id}"
-                        version_id,
-                        host=civitai_host,
-                    )
 
                     return {
                         "civitai_url": civitai_url,
@@ -957,27 +757,6 @@ class BaseModelService(ABC):
                         "version_id": str(version_id) if version_id else None,
                     }
 
-            if has_path and file_name_no_ext == basename:
-                if folder and name_no_ext.startswith(folder.replace("\\", "/") + "/"):
-                    best_fallback = model
-                elif best_fallback is None:
-                    best_fallback = model
-
-        if best_fallback:
-            civitai_data = best_fallback.get("civitai", {})
-            model_id = civitai_data.get("modelId")
-            if model_id:
-                version_id = civitai_data.get("id")
-                civitai_host = self.settings.get("civitai_host", "civitai.com")
-                civitai_url = build_civitai_model_page_url(
-                    model_id, version_id, host=civitai_host
-                )
-                return {
-                    "civitai_url": civitai_url,
-                    "model_id": str(model_id),
-                    "version_id": str(version_id) if version_id else None,
-                }
-
         return {"civitai_url": None, "model_id": None, "version_id": None}
 
     async def get_model_metadata(self, file_path: str) -> Optional[Dict]:
@@ -991,17 +770,6 @@ class BaseModelService(ABC):
         )
         if should_skip or metadata is None:
             return None
-
-        # Prune stale example-image metadata entries whose files no longer
-        # exist on disk (e.g. a user deleted the files manually).
-        from ..utils.example_images_metadata import MetadataUpdater
-
-        was_modified = await MetadataUpdater.prune_stale_example_images(metadata)
-        if was_modified:
-            asyncio.create_task(
-                MetadataManager.save_metadata(file_path, metadata)
-            )
-
         return self.filter_civitai_data(metadata.to_dict().get("civitai", {}))
 
     async def get_model_description(self, file_path: str) -> Optional[str]:
@@ -1031,61 +799,38 @@ class BaseModelService(ABC):
 
         return include_terms, exclude_terms
 
-    @staticmethod
-    def _remove_model_extension(path: str) -> str:
-        """Remove model file extension (.safetensors, .ckpt, .pt, .bin) for cleaner matching."""
-        return re.sub(r"\.(safetensors|ckpt|pt|bin)$", "", path, flags=re.IGNORECASE)
-
     @staticmethod
     def _relative_path_matches_tokens(
         path_lower: str, include_terms: List[str], exclude_terms: List[str]
     ) -> bool:
-        """Determine whether a relative path string satisfies include/exclude tokens.
+        """Determine whether a relative path string satisfies include/exclude tokens."""
-
+        if any(term and term in path_lower for term in exclude_terms):
-        Matches against the path without extension to avoid matching .safetensors
-        when searching for 's'.
-        """
-        # Use path without extension for matching
-        path_for_matching = BaseModelService._remove_model_extension(path_lower)
-
-        if any(term and term in path_for_matching for term in exclude_terms):
             return False
 
         for term in include_terms:
-            if term and term not in path_for_matching:
+            if term and term not in path_lower:
                 return False
 
         return True
 
     @staticmethod
     def _relative_path_sort_key(relative_path: str, include_terms: List[str]) -> tuple:
-        """Sort paths by how well they satisfy the include tokens.
+        """Sort paths by how well they satisfy the include tokens."""
-
+        path_lower = relative_path.lower()
-        Sorts based on path without extension for consistent ordering.
-        """
-        # Use path without extension for sorting
-        path_for_sorting = BaseModelService._remove_model_extension(
-            relative_path.lower()
-        )
         prefix_hits = sum(
-            1 for term in include_terms if term and path_for_sorting.startswith(term)
+            1 for term in include_terms if term and path_lower.startswith(term)
         )
         match_positions = [
-            path_for_sorting.find(term)
+            path_lower.find(term)
             for term in include_terms
-            if term and term in path_for_sorting
+            if term and term in path_lower
         ]
         first_match_index = min(match_positions) if match_positions else 0
 
-        return (
+        return (-prefix_hits, first_match_index, len(relative_path), path_lower)
-            -prefix_hits,
-            first_match_index,
-            len(path_for_sorting),
-            path_for_sorting,
-        )
 
     async def search_relative_paths(
-        self, search_term: str, limit: int = 15, offset: int = 0
+        self, search_term: str, limit: int = 15
     ) -> List[str]:
         """Search model relative file paths for autocomplete functionality"""
         cache = await self.scanner.get_cached_data()
@@ -1096,7 +841,6 @@ class BaseModelService(ABC):
         # Get model roots for path calculation
         model_roots = self.scanner.get_model_roots()
 
-        # Collect all matching paths first (needed for proper sorting and offset)
         for model in cache.raw_data:
             file_path = model.get("file_path", "")
             if not file_path:
@@ -1125,12 +869,12 @@ class BaseModelService(ABC):
             ):
                 matching_paths.append(relative_path)
 
+                if len(matching_paths) >= limit * 2:  # Get more for better sorting
+                    break
+
         # Sort by relevance (prefix and earliest hits first, then by length and alphabetically)
         matching_paths.sort(
             key=lambda relative: self._relative_path_sort_key(relative, include_terms)
         )
 
-        # Apply offset and limit
+        return matching_paths[:limit]
-        start = min(offset, len(matching_paths))
-        end = min(start + limit, len(matching_paths))
-        return matching_paths[start:end]

py/services/batch_import_service.py

@@ -1,593 +0,0 @@
-"""Batch import service for importing multiple images as recipes."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import time
-import uuid
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Set
-
-from aiohttp import web
-
-from .recipes import (
-    RecipeAnalysisService,
-    RecipePersistenceService,
-    RecipeValidationError,
-    RecipeDownloadError,
-    RecipeNotFoundError,
-)
-
-
-class ImportItemType(Enum):
-    """Type of import item."""
-
-    URL = "url"
-    LOCAL_PATH = "local_path"
-
-
-class ImportStatus(Enum):
-    """Status of an individual import item."""
-
-    PENDING = "pending"
-    PROCESSING = "processing"
-    SUCCESS = "success"
-    FAILED = "failed"
-    SKIPPED = "skipped"
-
-
-@dataclass
-class BatchImportItem:
-    """Represents a single item to import."""
-
-    id: str
-    source: str
-    item_type: ImportItemType
-    status: ImportStatus = ImportStatus.PENDING
-    error_message: Optional[str] = None
-    recipe_name: Optional[str] = None
-    recipe_id: Optional[str] = None
-    duration: float = 0.0
-
-
-@dataclass
-class BatchImportProgress:
-    """Tracks progress of a batch import operation."""
-
-    operation_id: str
-    total: int
-    completed: int = 0
-    success: int = 0
-    failed: int = 0
-    skipped: int = 0
-    current_item: str = ""
-    status: str = "pending"
-    started_at: float = field(default_factory=time.time)
-    finished_at: Optional[float] = None
-    items: List[BatchImportItem] = field(default_factory=list)
-    tags: List[str] = field(default_factory=list)
-    skip_no_metadata: bool = False
-    skip_duplicates: bool = False
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "operation_id": self.operation_id,
-            "total": self.total,
-            "completed": self.completed,
-            "success": self.success,
-            "failed": self.failed,
-            "skipped": self.skipped,
-            "current_item": self.current_item,
-            "status": self.status,
-            "started_at": self.started_at,
-            "finished_at": self.finished_at,
-            "progress_percent": round((self.completed / self.total) * 100, 1)
-            if self.total > 0
-            else 0,
-            "items": [
-                {
-                    "id": item.id,
-                    "source": item.source,
-                    "item_type": item.item_type.value,
-                    "status": item.status.value,
-                    "error_message": item.error_message,
-                    "recipe_name": item.recipe_name,
-                    "recipe_id": item.recipe_id,
-                    "duration": item.duration,
-                }
-                for item in self.items
-            ],
-        }
-
-
-class AdaptiveConcurrencyController:
-    """Adjusts concurrency based on task performance."""
-
-    def __init__(
-        self,
-        min_concurrency: int = 1,
-        max_concurrency: int = 5,
-        initial_concurrency: int = 3,
-    ) -> None:
-        self.min_concurrency = min_concurrency
-        self.max_concurrency = max_concurrency
-        self.current_concurrency = initial_concurrency
-        self._task_durations: List[float] = []
-        self._recent_errors = 0
-        self._recent_successes = 0
-
-    def record_result(self, duration: float, success: bool) -> None:
-        self._task_durations.append(duration)
-        if len(self._task_durations) > 10:
-            self._task_durations.pop(0)
-
-        if success:
-            self._recent_successes += 1
-            if duration < 1.0 and self.current_concurrency < self.max_concurrency:
-                self.current_concurrency = min(
-                    self.current_concurrency + 1, self.max_concurrency
-                )
-            elif duration > 10.0 and self.current_concurrency > self.min_concurrency:
-                self.current_concurrency = max(
-                    self.current_concurrency - 1, self.min_concurrency
-                )
-        else:
-            self._recent_errors += 1
-            if self.current_concurrency > self.min_concurrency:
-                self.current_concurrency = max(
-                    self.current_concurrency - 1, self.min_concurrency
-                )
-
-    def reset_counters(self) -> None:
-        self._recent_errors = 0
-        self._recent_successes = 0
-
-    def get_semaphore(self) -> asyncio.Semaphore:
-        return asyncio.Semaphore(self.current_concurrency)
-
-
-class BatchImportService:
-    """Service for batch importing images as recipes."""
-
-    SUPPORTED_EXTENSIONS: Set[str] = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"}
-
-    def __init__(
-        self,
-        *,
-        analysis_service: RecipeAnalysisService,
-        persistence_service: RecipePersistenceService,
-        ws_manager: Any,
-        logger: logging.Logger,
-    ) -> None:
-        self._analysis_service = analysis_service
-        self._persistence_service = persistence_service
-        self._ws_manager = ws_manager
-        self._logger = logger
-        self._active_operations: Dict[str, BatchImportProgress] = {}
-        self._cancellation_flags: Dict[str, bool] = {}
-        self._concurrency_controller = AdaptiveConcurrencyController()
-
-    def is_import_running(self, operation_id: Optional[str] = None) -> bool:
-        if operation_id:
-            progress = self._active_operations.get(operation_id)
-            return progress is not None and progress.status in ("pending", "running")
-        return any(
-            p.status in ("pending", "running") for p in self._active_operations.values()
-        )
-
-    def get_progress(self, operation_id: str) -> Optional[BatchImportProgress]:
-        return self._active_operations.get(operation_id)
-
-    def cancel_import(self, operation_id: str) -> bool:
-        if operation_id in self._active_operations:
-            self._cancellation_flags[operation_id] = True
-            return True
-        return False
-
-    def _validate_url(self, url: str) -> bool:
-        import re
-
-        url_pattern = re.compile(
-            r"^https?://"
-            r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|"
-            r"localhost|"
-            r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"
-            r"(?::\d+)?"
-            r"(?:/?|[/?]\S+)$",
-            re.IGNORECASE,
-        )
-        return url_pattern.match(url) is not None
-
-    def _validate_local_path(self, path: str) -> bool:
-        try:
-            normalized = os.path.normpath(path)
-            if not os.path.isabs(normalized):
-                return False
-            if ".." in normalized:
-                return False
-            return True
-        except Exception:
-            return False
-
-    def _is_duplicate_source(
-        self,
-        source: str,
-        item_type: ImportItemType,
-        recipe_scanner: Any,
-    ) -> bool:
-        try:
-            cache = recipe_scanner.get_cached_data_sync()
-            if not cache:
-                return False
-
-            for recipe in getattr(cache, "raw_data", []):
-                source_path = recipe.get("source_path")
-                if source_path and source_path == source:
-                    return True
-            return False
-        except Exception:
-            self._logger.warning("Failed to check for duplicates", exc_info=True)
-            return False
-
-    async def start_batch_import(
-        self,
-        *,
-        recipe_scanner_getter: Callable[[], Any],
-        civitai_client_getter: Callable[[], Any],
-        items: List[Dict[str, str]],
-        tags: Optional[List[str]] = None,
-        skip_no_metadata: bool = False,
-        skip_duplicates: bool = False,
-    ) -> str:
-        operation_id = str(uuid.uuid4())
-
-        import_items = []
-        for idx, item in enumerate(items):
-            source = item.get("source", "")
-            item_type_str = item.get("type", "url")
-
-            if item_type_str == "url" or source.startswith(("http://", "https://")):
-                item_type = ImportItemType.URL
-            else:
-                item_type = ImportItemType.LOCAL_PATH
-
-            batch_import_item = BatchImportItem(
-                id=f"{operation_id}_{idx}",
-                source=source,
-                item_type=item_type,
-            )
-            import_items.append(batch_import_item)
-
-        progress = BatchImportProgress(
-            operation_id=operation_id,
-            total=len(import_items),
-            items=import_items,
-            tags=tags or [],
-            skip_no_metadata=skip_no_metadata,
-            skip_duplicates=skip_duplicates,
-        )
-
-        self._active_operations[operation_id] = progress
-        self._cancellation_flags[operation_id] = False
-
-        asyncio.create_task(
-            self._run_batch_import(
-                operation_id=operation_id,
-                recipe_scanner_getter=recipe_scanner_getter,
-                civitai_client_getter=civitai_client_getter,
-            )
-        )
-
-        return operation_id
-
-    async def start_directory_import(
-        self,
-        *,
-        recipe_scanner_getter: Callable[[], Any],
-        civitai_client_getter: Callable[[], Any],
-        directory: str,
-        recursive: bool = True,
-        tags: Optional[List[str]] = None,
-        skip_no_metadata: bool = False,
-        skip_duplicates: bool = False,
-    ) -> str:
-        image_paths = await self._discover_images(directory, recursive)
-
-        items = [{"source": path, "type": "local_path"} for path in image_paths]
-
-        return await self.start_batch_import(
-            recipe_scanner_getter=recipe_scanner_getter,
-            civitai_client_getter=civitai_client_getter,
-            items=items,
-            tags=tags,
-            skip_no_metadata=skip_no_metadata,
-            skip_duplicates=skip_duplicates,
-        )
-
-    async def _discover_images(
-        self,
-        directory: str,
-        recursive: bool = True,
-    ) -> List[str]:
-        if not os.path.isdir(directory):
-            raise RecipeValidationError(f"Directory not found: {directory}")
-
-        image_paths: List[str] = []
-
-        if recursive:
-            for root, _, files in os.walk(directory):
-                for filename in files:
-                    if self._is_supported_image(filename):
-                        image_paths.append(os.path.join(root, filename))
-        else:
-            for filename in os.listdir(directory):
-                filepath = os.path.join(directory, filename)
-                if os.path.isfile(filepath) and self._is_supported_image(filename):
-                    image_paths.append(filepath)
-
-        return sorted(image_paths)
-
-    def _is_supported_image(self, filename: str) -> bool:
-        ext = os.path.splitext(filename)[1].lower()
-        return ext in self.SUPPORTED_EXTENSIONS
-
-    async def _run_batch_import(
-        self,
-        *,
-        operation_id: str,
-        recipe_scanner_getter: Callable[[], Any],
-        civitai_client_getter: Callable[[], Any],
-    ) -> None:
-        progress = self._active_operations.get(operation_id)
-        if not progress:
-            return
-
-        progress.status = "running"
-        await self._broadcast_progress(progress)
-
-        self._concurrency_controller = AdaptiveConcurrencyController()
-
-        async def process_item(item: BatchImportItem) -> None:
-            if self._cancellation_flags.get(operation_id, False):
-                return
-
-            progress.current_item = (
-                os.path.basename(item.source)
-                if item.item_type == ImportItemType.LOCAL_PATH
-                else item.source[:50]
-            )
-            item.status = ImportStatus.PROCESSING
-            await self._broadcast_progress(progress)
-
-            start_time = time.time()
-            try:
-                result = await self._import_single_item(
-                    item=item,
-                    recipe_scanner_getter=recipe_scanner_getter,
-                    civitai_client_getter=civitai_client_getter,
-                    tags=progress.tags,
-                    skip_no_metadata=progress.skip_no_metadata,
-                    skip_duplicates=progress.skip_duplicates,
-                    semaphore=self._concurrency_controller.get_semaphore(),
-                )
-
-                duration = time.time() - start_time
-                item.duration = duration
-                self._concurrency_controller.record_result(
-                    duration, result.get("success", False)
-                )
-
-                if result.get("success"):
-                    item.status = ImportStatus.SUCCESS
-                    item.recipe_name = result.get("recipe_name")
-                    item.recipe_id = result.get("recipe_id")
-                    progress.success += 1
-                elif result.get("skipped"):
-                    item.status = ImportStatus.SKIPPED
-                    item.error_message = result.get("error")
-                    progress.skipped += 1
-                else:
-                    item.status = ImportStatus.FAILED
-                    item.error_message = result.get("error")
-                    progress.failed += 1
-
-            except Exception as e:
-                self._logger.error(f"Error importing {item.source}: {e}")
-                item.status = ImportStatus.FAILED
-                item.error_message = str(e)
-                item.duration = time.time() - start_time
-                progress.failed += 1
-                self._concurrency_controller.record_result(item.duration, False)
-
-            progress.completed += 1
-            await self._broadcast_progress(progress)
-
-        tasks = [process_item(item) for item in progress.items]
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-        if self._cancellation_flags.get(operation_id, False):
-            progress.status = "cancelled"
-        else:
-            progress.status = "completed"
-
-        progress.finished_at = time.time()
-        progress.current_item = ""
-        await self._broadcast_progress(progress)
-
-        await asyncio.sleep(5)
-        self._cleanup_operation(operation_id)
-
-    async def _import_single_item(
-        self,
-        *,
-        item: BatchImportItem,
-        recipe_scanner_getter: Callable[[], Any],
-        civitai_client_getter: Callable[[], Any],
-        tags: List[str],
-        skip_no_metadata: bool,
-        skip_duplicates: bool,
-        semaphore: asyncio.Semaphore,
-    ) -> Dict[str, Any]:
-        async with semaphore:
-            recipe_scanner = recipe_scanner_getter()
-            if recipe_scanner is None:
-                return {"success": False, "error": "Recipe scanner unavailable"}
-
-            try:
-                if item.item_type == ImportItemType.URL:
-                    if not self._validate_url(item.source):
-                        return {
-                            "success": False,
-                            "error": f"Invalid URL format: {item.source}",
-                        }
-
-                    if skip_duplicates:
-                        if self._is_duplicate_source(
-                            item.source, item.item_type, recipe_scanner
-                        ):
-                            return {
-                                "success": False,
-                                "skipped": True,
-                                "error": "Duplicate source URL",
-                            }
-
-                    civitai_client = civitai_client_getter()
-                    analysis_result = await self._analysis_service.analyze_remote_image(
-                        url=item.source,
-                        recipe_scanner=recipe_scanner,
-                        civitai_client=civitai_client,
-                    )
-                else:
-                    if not self._validate_local_path(item.source):
-                        return {
-                            "success": False,
-                            "error": f"Invalid or unsafe path: {item.source}",
-                        }
-
-                    if not os.path.exists(item.source):
-                        return {
-                            "success": False,
-                            "error": f"File not found: {item.source}",
-                        }
-
-                    if skip_duplicates:
-                        if self._is_duplicate_source(
-                            item.source, item.item_type, recipe_scanner
-                        ):
-                            return {
-                                "success": False,
-                                "skipped": True,
-                                "error": "Duplicate source path",
-                            }
-
-                    analysis_result = await self._analysis_service.analyze_local_image(
-                        file_path=item.source,
-                        recipe_scanner=recipe_scanner,
-                    )
-
-                payload = analysis_result.payload
-
-                if payload.get("error"):
-                    if skip_no_metadata and "No metadata" in payload.get("error", ""):
-                        return {
-                            "success": False,
-                            "skipped": True,
-                            "error": payload["error"],
-                        }
-                    return {"success": False, "error": payload["error"]}
-
-                loras = payload.get("loras", [])
-                if not loras:
-                    if skip_no_metadata:
-                        return {
-                            "success": False,
-                            "skipped": True,
-                            "error": "No LoRAs found in image",
-                        }
-                    # When skip_no_metadata is False, allow importing images without LoRAs
-                    # Continue with empty loras list
-
-                recipe_name = self._generate_recipe_name(item, payload)
-                all_tags = list(set(tags + (payload.get("tags", []) or [])))
-
-                metadata = {
-                    "base_model": payload.get("base_model", ""),
-                    "loras": loras,
-                    "gen_params": payload.get("gen_params", {}),
-                    "source_path": item.source,
-                }
-
-                if payload.get("checkpoint"):
-                    metadata["checkpoint"] = payload["checkpoint"]
-
-                image_bytes = None
-                image_base64 = payload.get("image_base64")
-
-                if item.item_type == ImportItemType.LOCAL_PATH:
-                    with open(item.source, "rb") as f:
-                        image_bytes = f.read()
-                    image_base64 = None
-
-                save_result = await self._persistence_service.save_recipe(
-                    recipe_scanner=recipe_scanner,
-                    image_bytes=image_bytes,
-                    image_base64=image_base64,
-                    name=recipe_name,
-                    tags=all_tags,
-                    metadata=metadata,
-                    extension=payload.get("extension"),
-                )
-
-                if save_result.status == 200:
-                    return {
-                        "success": True,
-                        "recipe_name": recipe_name,
-                        "recipe_id": save_result.payload.get("id"),
-                    }
-                else:
-                    return {
-                        "success": False,
-                        "error": save_result.payload.get(
-                            "error", "Failed to save recipe"
-                        ),
-                    }
-
-            except RecipeValidationError as e:
-                return {"success": False, "error": str(e)}
-            except RecipeDownloadError as e:
-                return {"success": False, "error": str(e)}
-            except RecipeNotFoundError as e:
-                return {"success": False, "skipped": True, "error": str(e)}
-            except Exception as e:
-                self._logger.error(
-                    f"Unexpected error importing {item.source}: {e}", exc_info=True
-                )
-                return {"success": False, "error": str(e)}
-
-    def _generate_recipe_name(
-        self, item: BatchImportItem, payload: Dict[str, Any]
-    ) -> str:
-        if item.item_type == ImportItemType.LOCAL_PATH:
-            base_name = os.path.splitext(os.path.basename(item.source))[0]
-            return base_name[:100]
-        else:
-            loras = payload.get("loras", [])
-            if loras:
-                first_lora = loras[0].get("name", "Recipe")
-                return f"Import - {first_lora}"[:100]
-            return f"Imported Recipe {item.id[:8]}"
-
-    async def _broadcast_progress(self, progress: BatchImportProgress) -> None:
-        await self._ws_manager.broadcast(
-            {
-                "type": "batch_import_progress",
-                **progress.to_dict(),
-            }
-        )
-
-    def _cleanup_operation(self, operation_id: str) -> None:
-        if operation_id in self._cancellation_flags:
-            del self._cancellation_flags[operation_id]

py/services/cache_entry_validator.py

@@ -58,7 +58,6 @@ class CacheEntryValidator:
         'preview_nsfw_level': (0, False),
         'notes': ('', False),
         'usage_tips': ('', False),
-        'hash_status': ('completed', False),
     }
 
     @classmethod
@@ -91,31 +90,13 @@ class CacheEntryValidator:
 
         errors: List[str] = []
         repaired = False
-        
-        # If auto_repair is on, we work on a copy. If not, we still need a safe way to check fields.
         working_entry = dict(entry) if auto_repair else entry
 
-        # Determine effective hash_status for validation logic
-        hash_status = entry.get('hash_status')
-        if hash_status is None:
-            if auto_repair:
-                working_entry['hash_status'] = 'completed'
-                repaired = True
-            hash_status = 'completed'
-
         for field_name, (default_value, is_required) in cls.CORE_FIELDS.items():
-            # Get current value from the original entry to avoid side effects during validation
+            value = working_entry.get(field_name)
-            value = entry.get(field_name)
 
             # Check if field is missing or None
             if value is None:
-                # Special case: sha256 can be None/empty if hash_status is pending
-                if field_name == 'sha256' and hash_status == 'pending':
-                    if auto_repair:
-                        working_entry[field_name] = ''
-                        repaired = True
-                    continue
-
                 if is_required:
                     errors.append(f"Required field '{field_name}' is missing or None")
                 if auto_repair:
@@ -126,10 +107,6 @@ class CacheEntryValidator:
             # Validate field type and value
             field_error = cls._validate_field(field_name, value, default_value)
             if field_error:
-                # Special case: allow empty string for sha256 if pending
-                if field_name == 'sha256' and hash_status == 'pending' and value == '':
-                    continue
-
                 errors.append(field_error)
                 if auto_repair:
                     working_entry[field_name] = cls._get_default_copy(default_value)
@@ -148,32 +125,23 @@ class CacheEntryValidator:
             )
 
         # Special validation: sha256 must not be empty for required field
-        # BUT allow empty sha256 when hash_status is pending (lazy hash calculation)
         sha256 = working_entry.get('sha256', '')
-        # Use the effective hash_status we determined earlier
         if not sha256 or (isinstance(sha256, str) and not sha256.strip()):
-            # Allow empty sha256 for lazy hash calculation (checkpoints)
+            errors.append("Required field 'sha256' is empty")
-            if hash_status != 'pending':
+            # Cannot repair empty sha256 - entry is invalid
-                errors.append("Required field 'sha256' is empty")
+            return ValidationResult(
-                # Cannot repair empty sha256 - entry is invalid
+                is_valid=False,
-                return ValidationResult(
+                repaired=repaired,
-                    is_valid=False,
+                errors=errors,
-                    repaired=repaired,
+                entry=working_entry if auto_repair else None
-                    errors=errors,
+            )
-                    entry=working_entry if auto_repair else None
-                )
 
         # Normalize sha256 to lowercase if needed
         if isinstance(sha256, str):
             normalized_sha = sha256.lower().strip()
             if normalized_sha != sha256:
-                if auto_repair:
+                working_entry['sha256'] = normalized_sha
-                    working_entry['sha256'] = normalized_sha
+                repaired = True
-                    repaired = True
-                else:
-                    # If not auto-repairing, we don't consider case difference as a "critical error" 
-                    # that invalidates the entry, but we also don't mark it repaired.
-                    pass
 
         # Determine if entry is valid
         # Entry is valid if no critical required field errors remain after repair

py/services/checkpoint_scanner.py

@@ -1,360 +1,37 @@
-import asyncio
-import json
 import logging
-import os
-from datetime import datetime
 from typing import Any, Dict, List, Optional
 
 from ..utils.models import CheckpointMetadata
-from ..utils.file_utils import find_preview_file, normalize_path
-from ..utils.metadata_manager import MetadataManager
 from ..config import config
 from .model_scanner import ModelScanner
 from .model_hash_index import ModelHashIndex
 
 logger = logging.getLogger(__name__)
 
-
 class CheckpointScanner(ModelScanner):
     """Service for scanning and managing checkpoint files"""
-
+    
     def __init__(self):
         # Define supported file extensions
-        file_extensions = {
+        file_extensions = {'.ckpt', '.pt', '.pt2', '.bin', '.pth', '.safetensors', '.pkl', '.sft', '.gguf'}
-            ".ckpt",
-            ".pt",
-            ".pt2",
-            ".bin",
-            ".pth",
-            ".safetensors",
-            ".pkl",
-            ".sft",
-            ".gguf",
-        }
         super().__init__(
             model_type="checkpoint",
             model_class=CheckpointMetadata,
             file_extensions=file_extensions,
-            hash_index=ModelHashIndex(),
+            hash_index=ModelHashIndex()
         )
-        if not hasattr(self, "_hash_calculation_lock"):
-            self._hash_calculation_lock = asyncio.Lock()
-            self._hash_calculation_tasks: dict[str, asyncio.Task[Optional[str]]] = {}
-
-    async def _create_default_metadata(
-        self, file_path: str
-    ) -> Optional[CheckpointMetadata]:
-        """Create default metadata for checkpoint without calculating hash (lazy hash).
-
-        Checkpoints are typically large (10GB+), so we skip hash calculation during initial
-        scanning to improve startup performance. Hash will be calculated on-demand when
-        fetching metadata from Civitai.
-        """
-        try:
-            real_path = os.path.realpath(file_path)
-            if not os.path.exists(real_path):
-                logger.error(f"File not found: {file_path}")
-                return None
-
-            base_name = os.path.splitext(os.path.basename(file_path))[0]
-            dir_path = os.path.dirname(file_path)
-
-            # Find preview image
-            preview_url = find_preview_file(base_name, dir_path)
-
-            # Create metadata WITHOUT calculating hash
-            metadata = CheckpointMetadata(
-                file_name=base_name,
-                model_name=base_name,
-                file_path=normalize_path(file_path),
-                size=os.path.getsize(real_path),
-                modified=datetime.now().timestamp(),
-                sha256="",  # Empty hash - will be calculated on-demand
-                base_model="Unknown",
-                preview_url=normalize_path(preview_url),
-                tags=[],
-                modelDescription="",
-                sub_type="checkpoint",
-                from_civitai=False,  # Mark as local model since no hash yet
-                hash_status="pending",  # Mark hash as pending
-            )
-
-            # Save the created metadata
-            logger.info(f"Creating checkpoint metadata (hash pending) for {file_path}")
-            await MetadataManager.save_metadata(file_path, metadata)
-
-            return metadata
-
-        except Exception as e:
-            logger.error(
-                f"Error creating default checkpoint metadata for {file_path}: {e}"
-            )
-            return None
-
-    async def calculate_hash_for_model(self, file_path: str) -> Optional[str]:
-        """Calculate hash for a checkpoint on-demand with per-file singleflight.
-
-        Args:
-            file_path: Path to the model file
-
-        Returns:
-            SHA256 hash string, or None if calculation failed
-        """
-        try:
-            real_path = os.path.realpath(file_path)
-            if not os.path.exists(real_path):
-                logger.error(f"File not found for hash calculation: {file_path}")
-                return None
-
-            metadata, _ = await MetadataManager.load_metadata(
-                file_path, self.model_class
-            )
-            if (
-                metadata is not None
-                and metadata.hash_status == "completed"
-                and metadata.sha256
-            ):
-                return metadata.sha256
-
-            async with self._hash_calculation_lock:
-                metadata, _ = await MetadataManager.load_metadata(
-                    file_path, self.model_class
-                )
-                if (
-                    metadata is not None
-                    and metadata.hash_status == "completed"
-                    and metadata.sha256
-                ):
-                    return metadata.sha256
-
-                task = self._hash_calculation_tasks.get(real_path)
-                if task is None:
-                    task = asyncio.create_task(
-                        self._run_hash_calculation_task(file_path, real_path)
-                    )
-                    self._hash_calculation_tasks[real_path] = task
-
-            return await asyncio.shield(task)
-
-        except Exception as e:
-            logger.error(f"Error calculating hash for {file_path}: {e}")
-            return None
-
-    async def _run_hash_calculation_task(
-        self, file_path: str, real_path: str
-    ) -> Optional[str]:
-        """Run a hash calculation task and remove it from the in-flight map."""
-        try:
-            return await self._calculate_hash_for_model_uncached(file_path, real_path)
-        finally:
-            task = asyncio.current_task()
-            async with self._hash_calculation_lock:
-                if self._hash_calculation_tasks.get(real_path) is task:
-                    del self._hash_calculation_tasks[real_path]
-
-    async def _calculate_hash_for_model_uncached(
-        self, file_path: str, real_path: str
-    ) -> Optional[str]:
-        """Calculate hash for a checkpoint without checking in-flight tasks."""
-        from ..utils.file_utils import calculate_sha256
-
-        try:
-            # Load current metadata
-            metadata, should_skip = await MetadataManager.load_metadata(
-                file_path, self.model_class
-            )
-            if metadata is None:
-                if should_skip:
-                    logger.error(f"Invalid metadata found for {file_path}")
-                    return None
-                created_metadata = await self._create_default_metadata(file_path)
-                if created_metadata is None:
-                    logger.error(f"No metadata found for {file_path}")
-                    return None
-                metadata = created_metadata
-
-            # Check if hash is already calculated
-            if metadata.hash_status == "completed" and metadata.sha256:
-                return metadata.sha256
-
-            # Update status to calculating
-            metadata.hash_status = "calculating"
-            await MetadataManager.save_metadata(file_path, metadata)
-
-            # Calculate hash
-            logger.info(f"Calculating hash for checkpoint: {file_path}")
-            sha256 = await calculate_sha256(real_path)
-
-            # Update metadata with hash
-            metadata.sha256 = sha256
-            metadata.hash_status = "completed"
-            await MetadataManager.save_metadata(file_path, metadata)
-
-            # Update hash index
-            self._hash_index.add_entry(sha256.lower(), file_path)
-
-            logger.info(f"Hash calculated for checkpoint: {file_path}")
-            return sha256
-
-        except Exception as e:
-            logger.error(f"Error calculating hash for {file_path}: {e}")
-            # Update status to failed
-            try:
-                metadata, _ = await MetadataManager.load_metadata(
-                    file_path, self.model_class
-                )
-                if metadata:
-                    metadata.hash_status = "failed"
-                    await MetadataManager.save_metadata(file_path, metadata)
-            except Exception:
-                pass
-            return None
-
-    async def calculate_all_pending_hashes(
-        self, progress_callback=None
-    ) -> Dict[str, int]:
-        """Calculate hashes for all checkpoints with pending hash status.
-
-        If cache is not initialized, scans filesystem directly for metadata files
-        with hash_status != 'completed'.
-
-        Args:
-            progress_callback: Optional callback(progress, total, current_file)
-
-        Returns:
-            Dict with 'completed', 'failed', 'total' counts
-        """
-        # Try to get from cache first
-        cache = await self.get_cached_data()
-
-        if cache and cache.raw_data:
-            # Use cache if available
-            pending_models = [
-                item
-                for item in cache.raw_data
-                if item.get("hash_status") != "completed" or not item.get("sha256")
-            ]
-        else:
-            # Cache not initialized, scan filesystem directly
-            pending_models = await self._find_pending_models_from_filesystem()
-
-        if not pending_models:
-            return {"completed": 0, "failed": 0, "total": 0}
-
-        total = len(pending_models)
-        completed = 0
-        failed = 0
-
-        for i, model_data in enumerate(pending_models):
-            file_path = model_data.get("file_path")
-            if not file_path:
-                continue
-
-            try:
-                sha256 = await self.calculate_hash_for_model(file_path)
-                if sha256:
-                    completed += 1
-                else:
-                    failed += 1
-            except Exception as e:
-                logger.error(f"Error calculating hash for {file_path}: {e}")
-                failed += 1
-
-            if progress_callback:
-                try:
-                    await progress_callback(i + 1, total, file_path)
-                except Exception:
-                    pass
-
-        return {"completed": completed, "failed": failed, "total": total}
-
-    async def _find_pending_models_from_filesystem(self) -> List[Dict[str, Any]]:
-        """Scan filesystem for checkpoint metadata files with pending hash status."""
-        pending_models = []
-
-        for root_path in self.get_model_roots():
-            if not os.path.exists(root_path):
-                continue
-
-            for dirpath, _dirnames, filenames in os.walk(root_path):
-                for filename in filenames:
-                    if not filename.endswith(".metadata.json"):
-                        continue
-
-                    metadata_path = os.path.join(dirpath, filename)
-                    try:
-                        with open(metadata_path, "r", encoding="utf-8") as f:
-                            data = json.load(f)
-
-                        # Check if hash is pending
-                        hash_status = data.get("hash_status", "completed")
-                        sha256 = data.get("sha256", "")
-
-                        if hash_status != "completed" or not sha256:
-                            # Find corresponding model file
-                            model_name = filename.replace(".metadata.json", "")
-                            model_path = None
-
-                            # Look for model file with matching name
-                            for ext in self.file_extensions:
-                                potential_path = os.path.join(dirpath, model_name + ext)
-                                if os.path.exists(potential_path):
-                                    model_path = potential_path
-                                    break
-
-                            if model_path:
-                                pending_models.append(
-                                    {
-                                        "file_path": model_path.replace(os.sep, "/"),
-                                        "hash_status": hash_status,
-                                        "sha256": sha256,
-                                        **{
-                                            k: v
-                                            for k, v in data.items()
-                                            if k
-                                            not in [
-                                                "file_path",
-                                                "hash_status",
-                                                "sha256",
-                                            ]
-                                        },
-                                    }
-                                )
-                    except (json.JSONDecodeError, Exception) as e:
-                        logger.debug(
-                            f"Error reading metadata file {metadata_path}: {e}"
-                        )
-                        continue
-
-        return pending_models
 
     def _resolve_sub_type(self, root_path: Optional[str]) -> Optional[str]:
-        """Resolve the sub-type based on the root path.
+        """Resolve the sub-type based on the root path."""
-
-        Checks both standard ComfyUI paths and LoRA Manager's extra folder paths.
-        """
         if not root_path:
             return None
 
-        # Check standard ComfyUI checkpoint paths
         if config.checkpoints_roots and root_path in config.checkpoints_roots:
             return "checkpoint"
 
-        # Check extra checkpoint paths
-        if (
-            config.extra_checkpoints_roots
-            and root_path in config.extra_checkpoints_roots
-        ):
-            return "checkpoint"
-
-        # Check standard ComfyUI unet paths
         if config.unet_roots and root_path in config.unet_roots:
             return "diffusion_model"
 
-        # Check extra unet paths
-        if config.extra_unet_roots and root_path in config.extra_unet_roots:
-            return "diffusion_model"
-
         return None
 
     def adjust_metadata(self, metadata, file_path, root_path):
@@ -374,16 +51,5 @@ class CheckpointScanner(ModelScanner):
         return entry
 
     def get_model_roots(self) -> List[str]:
-        """Get checkpoint root directories (including extra paths)"""
+        """Get checkpoint root directories"""
-        roots: List[str] = []
+        return config.base_models_roots
-        roots.extend(config.base_models_roots or [])
-        roots.extend(config.extra_checkpoints_roots or [])
-        roots.extend(config.extra_unet_roots or [])
-        # Remove duplicates while preserving order
-        seen: set = set()
-        unique_roots: List[str] = []
-        for root in roots:
-            if root not in seen:
-                seen.add(root)
-                unique_roots.append(root)
-        return unique_roots

py/services/checkpoint_service.py

@@ -3,7 +3,6 @@ import logging
 from typing import Dict
 
 from .base_model_service import BaseModelService
-from .auto_tag_service import extract_auto_tags
 from ..utils.models import CheckpointMetadata
 from ..config import config
 
@@ -43,11 +42,8 @@ class CheckpointService(BaseModelService):
             "notes": checkpoint_data.get("notes", ""),
             "sub_type": sub_type,
             "favorite": checkpoint_data.get("favorite", False),
-            "exclude": bool(checkpoint_data.get("exclude", False)),
             "update_available": bool(checkpoint_data.get("update_available", False)),
-            "skip_metadata_refresh": bool(checkpoint_data.get("skip_metadata_refresh", False)),
+            "civitai": self.filter_civitai_data(checkpoint_data.get("civitai", {}), minimal=True)
-            "civitai": self.filter_civitai_data(checkpoint_data.get("civitai", {}), minimal=True),
-            "auto_tags": checkpoint_data.get("auto_tags") or extract_auto_tags(checkpoint_data),
         }
     
     def find_duplicate_hashes(self) -> Dict:

py/services/civarchive_client.py

@@ -186,22 +186,6 @@ class CivArchiveClient:
         if "metadata" in file_data:
             transformed["metadata"] = file_data["metadata"]
 
-        # Infer metadata.format from filename extension
-        name = transformed.get("name")
-        if name and isinstance(name, str):
-            lower_name = name.lower()
-            if lower_name.endswith(".safetensors"):
-                inferred_format = "SafeTensor"
-            elif lower_name.endswith(".ckpt"):
-                inferred_format = "PickleTensor"
-            else:
-                inferred_format = None
-            if inferred_format:
-                if "metadata" not in transformed:
-                    transformed["metadata"] = {}
-                if isinstance(transformed["metadata"], dict):
-                    transformed["metadata"].setdefault("format", inferred_format)
-
         if file_data.get("modelVersionId") is not None:
             transformed["modelVersionId"] = file_data.get("modelVersionId")
         elif file_data.get("model_version_id") is not None:
@@ -229,20 +213,6 @@ class CivArchiveClient:
         for file_data in candidates:
             if isinstance(file_data, dict):
                 transformed_files.append(self._transform_file_entry(file_data))
-
-        # Sort: .safetensors first, .ckpt second, others last
-        # so the backend fallback (no file_params) prefers safetensors
-        def _sort_key(f: Dict) -> int:
-            fname = f.get("name") or ""
-            if isinstance(fname, str):
-                lower = fname.lower()
-                if lower.endswith(".safetensors"):
-                    return 0
-                elif lower.endswith(".ckpt"):
-                    return 1
-            return 2
-
-        transformed_files.sort(key=_sort_key)
         return transformed_files
 
     def _transform_version(

py/services/civitai_base_model_service.py

@@ -1,436 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import re
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Set, Tuple
-
-from ..utils.constants import SUPPORTED_DOWNLOAD_SKIP_BASE_MODELS
-from .downloader import get_downloader
-
-logger = logging.getLogger(__name__)
-
-
-class CivitaiBaseModelService:
-    """Service for fetching and managing Civitai base models.
-
-    This service provides:
-    - Fetching base models from Civitai API
-    - Caching with TTL (7 days default)
-    - Merging hardcoded and remote base models
-    - Generating abbreviations for new/unknown models
-    """
-
-    _instance: Optional[CivitaiBaseModelService] = None
-    _lock = asyncio.Lock()
-
-    # Default TTL for cache in seconds (7 days)
-    DEFAULT_CACHE_TTL = 7 * 24 * 60 * 60
-
-    # Civitai API endpoint for enums
-    CIVITAI_ENUMS_URL = "https://civitai.red/api/v1/enums"
-
-    @classmethod
-    async def get_instance(cls) -> CivitaiBaseModelService:
-        """Get singleton instance of the service."""
-        async with cls._lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    def __init__(self):
-        """Initialize the service."""
-        if hasattr(self, "_initialized"):
-            return
-        self._initialized = True
-
-        # Cache storage
-        self._cache: Optional[Dict[str, Any]] = None
-        self._cache_timestamp: Optional[datetime] = None
-        self._cache_ttl = self.DEFAULT_CACHE_TTL
-
-        # Hardcoded models for fallback
-        self._hardcoded_models = set(SUPPORTED_DOWNLOAD_SKIP_BASE_MODELS)
-
-        logger.info("CivitaiBaseModelService initialized")
-
-    async def get_base_models(self, force_refresh: bool = False) -> Dict[str, Any]:
-        """Get merged base models (hardcoded + remote).
-
-        Args:
-            force_refresh: If True, fetch from API regardless of cache state.
-
-        Returns:
-            Dictionary containing:
-            - models: List of merged base model names
-            - source: 'cache', 'api', or 'fallback'
-            - last_updated: ISO timestamp of last successful API fetch
-            - hardcoded_count: Number of hardcoded models
-            - remote_count: Number of remote models
-            - merged_count: Total unique models
-        """
-        # Check if cache is valid
-        if not force_refresh and self._is_cache_valid():
-            logger.debug("Returning cached base models")
-            return self._build_response("cache")
-
-        # Try to fetch from API
-        try:
-            remote_models = await self._fetch_from_civitai()
-            if remote_models:
-                self._update_cache(remote_models)
-                return self._build_response("api")
-        except Exception as e:
-            logger.error(f"Failed to fetch base models from Civitai: {e}")
-
-        # Fallback to hardcoded models
-        return self._build_response("fallback")
-
-    async def refresh_cache(self) -> Dict[str, Any]:
-        """Force refresh the cache from Civitai API.
-
-        Returns:
-            Response dict same as get_base_models()
-        """
-        return await self.get_base_models(force_refresh=True)
-
-    def get_cache_status(self) -> Dict[str, Any]:
-        """Get current cache status.
-
-        Returns:
-            Dictionary containing:
-            - has_cache: Whether cache exists
-            - last_updated: ISO timestamp or None
-            - is_expired: Whether cache is expired
-            - ttl_seconds: TTL in seconds
-            - age_seconds: Age of cache in seconds (if exists)
-        """
-        if self._cache is None or self._cache_timestamp is None:
-            return {
-                "has_cache": False,
-                "last_updated": None,
-                "is_expired": True,
-                "ttl_seconds": self._cache_ttl,
-                "age_seconds": None,
-            }
-
-        age = (datetime.now(timezone.utc) - self._cache_timestamp).total_seconds()
-        return {
-            "has_cache": True,
-            "last_updated": self._cache_timestamp.isoformat(),
-            "is_expired": age > self._cache_ttl,
-            "ttl_seconds": self._cache_ttl,
-            "age_seconds": int(age),
-        }
-
-    def generate_abbreviation(self, model_name: str) -> str:
-        """Generate abbreviation for a base model name.
-
-        Algorithm:
-        1. Extract version patterns (e.g., "2.5" from "Wan Video 2.5")
-        2. Extract main acronym (e.g., "SD" from "SD 1.5")
-        3. Handle special cases (Flux, Wan, etc.)
-        4. Fallback to first letters of words (max 4 chars)
-
-        Args:
-            model_name: Full base model name
-
-        Returns:
-            Generated abbreviation (max 4 characters)
-        """
-        if not model_name or not isinstance(model_name, str):
-            return "OTH"
-
-        name = model_name.strip()
-        if not name:
-            return "OTH"
-
-        # Check if it's already in hardcoded abbreviations
-        # This is a simplified check - in practice you'd have a mapping
-        lower_name = name.lower()
-
-        # Special cases
-        special_cases = {
-            "sd 1.4": "SD1",
-            "sd 1.5": "SD1",
-            "sd 1.5 lcm": "SD1",
-            "sd 1.5 hyper": "SD1",
-            "sd 2.0": "SD2",
-            "sd 2.1": "SD2",
-            "sd 3": "SD3",
-            "sd 3.5": "SD3",
-            "sd 3.5 medium": "SD3",
-            "sd 3.5 large": "SD3",
-            "sd 3.5 large turbo": "SD3",
-            "sdxl 1.0": "XL",
-            "sdxl lightning": "XL",
-            "sdxl hyper": "XL",
-            "flux.1 d": "F1D",
-            "flux.1 s": "F1S",
-            "flux.1 krea": "F1KR",
-            "flux.1 kontext": "F1KX",
-            "flux.2 d": "F2D",
-            "flux.2 klein 9b": "FK9",
-            "flux.2 klein 9b-base": "FK9B",
-            "flux.2 klein 4b": "FK4",
-            "flux.2 klein 4b-base": "FK4B",
-            "auraflow": "AF",
-            "chroma": "CHR",
-            "pixart a": "PXA",
-            "pixart e": "PXE",
-            "hunyuan 1": "HY",
-            "hunyuan video": "HYV",
-            "lumina": "L",
-            "kolors": "KLR",
-            "noobai": "NAI",
-            "illustrious": "IL",
-            "pony": "PONY",
-            "pony v7": "PNY7",
-            "hidream": "HID",
-            "qwen": "QWEN",
-            "zimageturbo": "ZIT",
-            "zimagebase": "ZIB",
-            "anima": "ANI",
-            "ernie": "ERNI",
-            "ernie turbo": "ETRB",
-            "nucleus": "NUCL",
-            "svd": "SVD",
-            "ltxv": "LTXV",
-            "ltxv2": "LTV2",
-            "ltxv 2.3": "LTX",
-            "cogvideox": "CVX",
-            "mochi": "MCHI",
-            "wan video": "WAN",
-            "wan video 1.3b t2v": "WAN",
-            "wan video 14b t2v": "WAN",
-            "wan video 14b i2v 480p": "WAN",
-            "wan video 14b i2v 720p": "WAN",
-            "wan video 2.2 ti2v-5b": "WAN",
-            "wan video 2.2 t2v-a14b": "WAN",
-            "wan video 2.2 i2v-a14b": "WAN",
-            "wan video 2.5 t2v": "WAN",
-            "wan video 2.5 i2v": "WAN",
-        }
-
-        if lower_name in special_cases:
-            return special_cases[lower_name]
-
-        # Try to extract acronym from version pattern
-        # e.g., "Model Name 2.5" -> "MN25"
-        version_match = re.search(r"(\d+(?:\.\d+)?)", name)
-        version = version_match.group(1) if version_match else ""
-
-        # Remove version and common words
-        words = re.sub(r"\d+(?:\.\d+)?", "", name)
-        words = re.sub(
-            r"\b(model|video|diffusion|checkpoint|textualinversion)\b",
-            "",
-            words,
-            flags=re.I,
-        )
-        words = words.strip()
-
-        # Get first letters of remaining words
-        tokens = re.findall(r"[A-Za-z]+", words)
-        if tokens:
-            # Build abbreviation from first letters
-            abbrev = "".join(token[0].upper() for token in tokens)
-            # Add version if present
-            if version:
-                # Clean version (remove dots for abbreviation)
-                version_clean = version.replace(".", "")
-                abbrev = abbrev[: 4 - len(version_clean)] + version_clean
-            return abbrev[:4]
-
-        # Final fallback: just take first 4 alphanumeric chars
-        alphanumeric = re.sub(r"[^A-Za-z0-9]", "", name)
-        if alphanumeric:
-            return alphanumeric[:4].upper()
-
-        return "OTH"
-
-    async def _fetch_from_civitai(self) -> Optional[Set[str]]:
-        """Fetch base models from Civitai API.
-
-        Returns:
-            Set of base model names, or None if failed
-        """
-        try:
-            downloader = await get_downloader()
-            success, result = await downloader.make_request(
-                "GET",
-                self.CIVITAI_ENUMS_URL,
-                use_auth=False,  # enums endpoint doesn't require auth
-            )
-
-            if not success:
-                logger.warning(f"Failed to fetch enums from Civitai: {result}")
-                return None
-
-            if isinstance(result, str):
-                data = json.loads(result)
-            else:
-                data = result
-
-            # Extract base models from response
-            base_models = set()
-
-            # Use ActiveBaseModel if available (recommended active models)
-            if "ActiveBaseModel" in data:
-                base_models.update(data["ActiveBaseModel"])
-                logger.info(f"Fetched {len(base_models)} models from ActiveBaseModel")
-            # Fallback to full BaseModel list
-            elif "BaseModel" in data:
-                base_models.update(data["BaseModel"])
-                logger.info(f"Fetched {len(base_models)} models from BaseModel")
-            else:
-                logger.warning("No base model data found in Civitai response")
-                return None
-
-            return base_models
-
-        except Exception as e:
-            logger.error(f"Error fetching from Civitai: {e}")
-            return None
-
-    def _update_cache(self, remote_models: Set[str]) -> None:
-        """Update internal cache with fetched models.
-
-        Args:
-            remote_models: Set of base model names from API
-        """
-        self._cache = {
-            "remote_models": sorted(remote_models),
-            "hardcoded_models": sorted(self._hardcoded_models),
-        }
-        self._cache_timestamp = datetime.now(timezone.utc)
-        logger.info(f"Cache updated with {len(remote_models)} remote models")
-
-    def _is_cache_valid(self) -> bool:
-        """Check if current cache is valid (not expired).
-
-        Returns:
-            True if cache exists and is not expired
-        """
-        if self._cache is None or self._cache_timestamp is None:
-            return False
-
-        age = (datetime.now(timezone.utc) - self._cache_timestamp).total_seconds()
-        return age <= self._cache_ttl
-
-    def _build_response(self, source: str) -> Dict[str, Any]:
-        """Build response dictionary.
-
-        Args:
-            source: 'cache', 'api', or 'fallback'
-
-        Returns:
-            Response dictionary
-        """
-        if source == "fallback" or self._cache is None:
-            # Use only hardcoded models
-            merged = sorted(self._hardcoded_models)
-            return {
-                "models": merged,
-                "source": source,
-                "last_updated": None,
-                "hardcoded_count": len(self._hardcoded_models),
-                "remote_count": 0,
-                "merged_count": len(merged),
-            }
-
-        # Merge hardcoded and remote models
-        remote_set = set(self._cache.get("remote_models", []))
-        merged = sorted(self._hardcoded_models | remote_set)
-
-        return {
-            "models": merged,
-            "source": source,
-            "last_updated": self._cache_timestamp.isoformat()
-            if self._cache_timestamp
-            else None,
-            "hardcoded_count": len(self._hardcoded_models),
-            "remote_count": len(remote_set),
-            "merged_count": len(merged),
-        }
-
-    def get_model_categories(self) -> Dict[str, List[str]]:
-        """Get categorized base models.
-
-        Returns:
-            Dictionary mapping category names to lists of model names
-        """
-        # Define category patterns
-        categories = {
-            "Stable Diffusion 1.x": ["SD 1.4", "SD 1.5", "SD 1.5 LCM", "SD 1.5 Hyper"],
-            "Stable Diffusion 2.x": ["SD 2.0", "SD 2.1"],
-            "Stable Diffusion 3.x": [
-                "SD 3",
-                "SD 3.5",
-                "SD 3.5 Medium",
-                "SD 3.5 Large",
-                "SD 3.5 Large Turbo",
-            ],
-            "SDXL": ["SDXL 1.0", "SDXL Lightning", "SDXL Hyper"],
-            "Flux Models": [
-                "Flux.1 D",
-                "Flux.1 S",
-                "Flux.1 Krea",
-                "Flux.1 Kontext",
-                "Flux.2 D",
-                "Flux.2 Klein 9B",
-                "Flux.2 Klein 9B-base",
-                "Flux.2 Klein 4B",
-                "Flux.2 Klein 4B-base",
-            ],
-            "Video Models": [
-                "SVD",
-                "LTXV",
-                "LTXV2",
-                "LTXV 2.3",
-                "CogVideoX",
-                "Mochi",
-                "Hunyuan Video",
-                "Wan Video",
-                "Wan Video 1.3B t2v",
-                "Wan Video 14B t2v",
-                "Wan Video 14B i2v 480p",
-                "Wan Video 14B i2v 720p",
-                "Wan Video 2.2 TI2V-5B",
-                "Wan Video 2.2 T2V-A14B",
-                "Wan Video 2.2 I2V-A14B",
-                "Wan Video 2.5 T2V",
-                "Wan Video 2.5 I2V",
-            ],
-            "Other Models": [
-                "Illustrious",
-                "Pony",
-                "Pony V7",
-                "HiDream",
-                "Qwen",
-                "AuraFlow",
-                "Chroma",
-                "ZImageTurbo",
-                "ZImageBase",
-                "PixArt a",
-                "PixArt E",
-                "Hunyuan 1",
-                "Lumina",
-                "Kolors",
-                "NoobAI",
-                "Anima",
-                "Ernie",
-                "Ernie Turbo",
-                "Nucleus",
-            ],
-        }
-
-        return categories
-
-
-# Convenience function for getting the singleton instance
-async def get_civitai_base_model_service() -> CivitaiBaseModelService:
-    """Get the singleton instance of CivitaiBaseModelService."""
-    return await CivitaiBaseModelService.get_instance()

py/services/civitai_client.py

@@ -2,61 +2,38 @@ import asyncio
 import copy
 import logging
 import os
-from collections import OrderedDict
 from typing import Any, Optional, Dict, Tuple, List, Sequence
-from .connectivity_guard import (
+from .model_metadata_provider import CivitaiModelMetadataProvider, ModelMetadataProviderManager
-    OFFLINE_FRIENDLY_MESSAGE,
-    is_expected_offline_error,
-    is_offline_cooldown_error,
-)
-from .model_metadata_provider import (
-    CivitaiModelMetadataProvider,
-    ModelMetadataProviderManager,
-)
 from .downloader import get_downloader
 from .errors import RateLimitError, ResourceNotFoundError
 from ..utils.civitai_utils import resolve_license_payload
 
 logger = logging.getLogger(__name__)
 
-
 class CivitaiClient:
     _instance = None
     _lock = asyncio.Lock()
-
+    
     @classmethod
     async def get_instance(cls):
         """Get singleton instance of CivitaiClient"""
         async with cls._lock:
             if cls._instance is None:
                 cls._instance = cls()
-
+                
                 # Register this client as a metadata provider
                 provider_manager = await ModelMetadataProviderManager.get_instance()
-                provider_manager.register_provider(
+                provider_manager.register_provider('civitai', CivitaiModelMetadataProvider(cls._instance), True)
-                    "civitai", CivitaiModelMetadataProvider(cls._instance), True
+                
-                )
-
             return cls._instance
 
     def __init__(self):
         # Check if already initialized for singleton pattern
-        if hasattr(self, "_initialized"):
+        if hasattr(self, '_initialized'):
             return
         self._initialized = True
-
+        
-        self.base_url = "https://civitai.red/api/v1"
+        self.base_url = "https://civitai.com/api/v1"
-        # In-memory cache to avoid redundant get_model_version_info calls
-        # within the same import/scan flow. Only successful results are cached.
-        # Uses OrderedDict with LRU eviction at MAX_CACHE_ENTRIES to prevent
-        # unbounded growth in long-running server processes.
-        self._version_info_cache: OrderedDict[
-            str, Tuple[Optional[Dict], Optional[str]]
-        ] = OrderedDict()
-        self._MAX_CACHE_ENTRIES = 500
-
-    def _build_image_info_url(self, image_id: str) -> str:
-        return f"{self.base_url}/images?imageId={image_id}&nsfw=X"
 
     async def _make_request(
         self,
@@ -66,57 +43,20 @@ class CivitaiClient:
         use_auth: bool = False,
         **kwargs,
     ) -> Tuple[bool, Dict | str]:
-        """Wrapper around downloader.make_request that surfaces rate limits,
+        """Wrapper around downloader.make_request that surfaces rate limits."""
-        with retry for transient server errors (5xx, Cloudflare 524, network flakiness)."""
 
-        max_retries = 3
+        downloader = await get_downloader()
-        for attempt in range(max_retries):
+        success, result = await downloader.make_request(
-            downloader = await get_downloader()
+            method,
-            success, result = await downloader.make_request(
+            url,
-                method,
+            use_auth=use_auth,
-                url,
+            **kwargs,
-                use_auth=use_auth,
+        )
-                **kwargs,
+        if not success and isinstance(result, RateLimitError):
-            )
+            if result.provider is None:
-            if success:
+                result.provider = "civitai_api"
-                return True, result
+            raise result
-
+        return success, result
-            if isinstance(result, RateLimitError):
-                if result.provider is None:
-                    result.provider = "civitai_api"
-                raise result
-
-            if is_offline_cooldown_error(result):
-                return False, OFFLINE_FRIENDLY_MESSAGE
-
-            # Transient server error — retry with exponential backoff
-            if self._is_transient_server_error(str(result)):
-                if attempt < max_retries - 1:
-                    wait = 2**attempt  # 1s, 2s, 4s
-                    logger.info(
-                        "Transient error on %s %s, retrying in %ds "
-                        "(attempt %d/%d): %s",
-                        method,
-                        url,
-                        wait,
-                        attempt + 1,
-                        max_retries,
-                        result,
-                    )
-                    await asyncio.sleep(wait)
-                    continue
-                logger.warning(
-                    "All %d retries exhausted for %s %s: %s",
-                    max_retries,
-                    method,
-                    url,
-                    result,
-                )
-                return False, result
-
-            return False, result
-
-        return False, "Unexpected error in _make_request"
 
     @staticmethod
     def _remove_comfy_metadata(model_version: Optional[Dict]) -> None:
@@ -135,10 +75,8 @@ class CivitaiClient:
             meta = image.get("meta")
             if isinstance(meta, dict) and "comfy" in meta:
                 meta.pop("comfy", None)
-
+    
-    async def download_file(
+    async def download_file(self, url: str, save_dir: str, default_filename: str, progress_callback=None) -> Tuple[bool, str]:
-        self, url: str, save_dir: str, default_filename: str, progress_callback=None
-    ) -> Tuple[bool, str]:
         """Download file with resumable downloads and retry mechanism
 
         Args:
@@ -152,50 +90,41 @@ class CivitaiClient:
         """
         downloader = await get_downloader()
         save_path = os.path.join(save_dir, default_filename)
-
+        
         # Use unified downloader with CivitAI authentication
         success, result = await downloader.download_file(
             url=url,
             save_path=save_path,
             progress_callback=progress_callback,
             use_auth=True,  # Enable CivitAI authentication
-            allow_resume=True,
+            allow_resume=True
         )
-
+        
         return success, result
 
-    async def get_model_by_hash(
+    async def get_model_by_hash(self, model_hash: str) -> Tuple[Optional[Dict], Optional[str]]:
-        self, model_hash: str
-    ) -> Tuple[Optional[Dict], Optional[str]]:
         try:
             success, version = await self._make_request(
-                "GET",
+                'GET',
                 f"{self.base_url}/model-versions/by-hash/{model_hash}",
-                use_auth=True,
+                use_auth=True
             )
             if not success:
                 message = str(version)
-                if is_expected_offline_error(message):
-                    return None, OFFLINE_FRIENDLY_MESSAGE
                 if "not found" in message.lower():
                     return None, "Model not found"
 
-                logger.error(
+                logger.error("Failed to fetch model info for %s: %s", model_hash[:10], message)
-                    "Failed to fetch model info for %s: %s", model_hash[:10], message
-                )
                 return None, message
 
-            if isinstance(version, dict):
+            model_id = version.get('modelId')
-                model_id = version.get("modelId")
+            if model_id:
-                if model_id:
+                model_data = await self._fetch_model_data(model_id)
-                    model_data = await self._fetch_model_data(model_id)
+                if model_data:
-                    if model_data:
+                    self._enrich_version_with_model_data(version, model_data)
-                        self._enrich_version_with_model_data(version, model_data)
 
-                self._remove_comfy_metadata(version)
+            self._remove_comfy_metadata(version)
-                return version, None
+            return version, None
-            else:
-                return None, "Invalid response format"
         except RateLimitError:
             raise
         except Exception as exc:
@@ -207,22 +136,19 @@ class CivitaiClient:
             downloader = await get_downloader()
             success, content, headers = await downloader.download_to_memory(
                 image_url,
-                use_auth=False,  # Preview images don't need auth
+                use_auth=False  # Preview images don't need auth
             )
             if success:
                 # Ensure directory exists
                 os.makedirs(os.path.dirname(save_path), exist_ok=True)
-                with open(save_path, "wb") as f:
+                with open(save_path, 'wb') as f:
                     f.write(content)
                 return True
             return False
         except Exception as e:
-            if is_expected_offline_error(str(e)):
-                logger.debug("Preview download skipped due to offline state.")
-                return False
             logger.error(f"Download Error: {str(e)}")
             return False
-
+            
     @staticmethod
     def _extract_error_message(payload: Any) -> str:
         """Return a human-readable error message from an API payload."""
@@ -245,58 +171,25 @@ class CivitaiClient:
 
         return _from_value(payload)
 
-    @staticmethod
-    def _is_transient_server_error(message: str) -> bool:
-        """Return True when the message indicates a transient upstream failure.
-
-        Recognises Cloudflare 524, generic 5xx, and connectivity-level flakiness
-        that should not be treated as a permanent failure.
-        """
-        normalized = message.lower()
-        if "status 5" in normalized or "status 524" in normalized:
-            return True
-        if any(
-            keyword in normalized
-            for keyword in (
-                "connection refused",
-                "connection reset",
-                "temporary failure",
-                "name resolution",
-                "connection closed",
-            )
-        ):
-            return True
-        return False
-
     async def get_model_versions(self, model_id: str) -> Optional[Dict]:
         """Get all versions of a model with local availability info"""
         try:
             success, result = await self._make_request(
-                "GET",
+                'GET',
                 f"{self.base_url}/models/{model_id}",
-                use_auth=True,
+                use_auth=True
             )
             if success:
                 # Also return model type along with versions
                 return {
-                    "modelVersions": result.get("modelVersions", []),
+                    'modelVersions': result.get('modelVersions', []),
-                    "type": result.get("type", ""),
+                    'type': result.get('type', ''),
-                    "name": result.get("name", ""),
+                    'name': result.get('name', '')
                 }
             message = self._extract_error_message(result)
-            if message and "not found" in message.lower():
+            if message and 'not found' in message.lower():
                 raise ResourceNotFoundError(f"Resource not found for model {model_id}")
-            if is_expected_offline_error(message):
-                logger.info("Civitai request skipped: %s", OFFLINE_FRIENDLY_MESSAGE)
-                return None
             if message:
-                if self._is_transient_server_error(message):
-                    logger.info(
-                        "Transient server error for model %s: %s",
-                        model_id,
-                        message,
-                    )
-                    return None
                 raise RuntimeError(message)
             return None
         except RateLimitError:
@@ -328,15 +221,15 @@ class CivitaiClient:
         try:
             query = ",".join(normalized_ids)
             success, result = await self._make_request(
-                "GET",
+                'GET',
                 f"{self.base_url}/models",
                 use_auth=True,
-                params={"ids": query, "nsfw": "true"},
+                params={'ids': query},
             )
             if not success:
                 return None
 
-            items = result.get("items") if isinstance(result, dict) else None
+            items = result.get('items') if isinstance(result, dict) else None
             if not isinstance(items, list):
                 return {}
 
@@ -344,19 +237,19 @@ class CivitaiClient:
             for item in items:
                 if not isinstance(item, dict):
                     continue
-                model_id = item.get("id")
+                model_id = item.get('id')
                 try:
                     normalized_id = int(model_id)
                 except (TypeError, ValueError):
                     continue
                 payload[normalized_id] = {
-                    "modelVersions": item.get("modelVersions", []),
+                    'modelVersions': item.get('modelVersions', []),
-                    "type": item.get("type", ""),
+                    'type': item.get('type', ''),
-                    "name": item.get("name", ""),
+                    'name': item.get('name', ''),
-                    "allowNoCredit": item.get("allowNoCredit"),
+                    'allowNoCredit': item.get('allowNoCredit'),
-                    "allowCommercialUse": item.get("allowCommercialUse"),
+                    'allowCommercialUse': item.get('allowCommercialUse'),
-                    "allowDerivatives": item.get("allowDerivatives"),
+                    'allowDerivatives': item.get('allowDerivatives'),
-                    "allowDifferentLicense": item.get("allowDifferentLicense"),
+                    'allowDifferentLicense': item.get('allowDifferentLicense'),
                 }
             return payload
         except RateLimitError:
@@ -364,10 +257,8 @@ class CivitaiClient:
         except Exception as exc:
             logger.error(f"Error fetching model versions in bulk: {exc}")
             return None
-
+            
-    async def get_model_version(
+    async def get_model_version(self, model_id: int = None, version_id: int = None) -> Optional[Dict]:
-        self, model_id: int = None, version_id: int = None
-    ) -> Optional[Dict]:
         """Get specific model version with additional metadata."""
         try:
             if model_id is None and version_id is not None:
@@ -390,7 +281,7 @@ class CivitaiClient:
         if version is None:
             return None
 
-        model_id = version.get("modelId")
+        model_id = version.get('modelId')
         if not model_id:
             logger.error(f"No modelId found in version {version_id}")
             return None
@@ -402,42 +293,17 @@ class CivitaiClient:
         self._remove_comfy_metadata(version)
         return version
 
-    async def _get_version_with_model_id(
+    async def _get_version_with_model_id(self, model_id: int, version_id: Optional[int]) -> Optional[Dict]:
-        self, model_id: int, version_id: Optional[int]
-    ) -> Optional[Dict]:
         model_data = await self._fetch_model_data(model_id)
         if not model_data:
             return None
 
         target_version = self._select_target_version(model_data, model_id, version_id)
-
-        # If modelVersions is empty (e.g. CivitAI cache lag for newly published
-        # models) but a specific version_id is known, fall back to fetching the
-        # version directly via the individual model-versions endpoint, then
-        # enrich it with the model-level data we already have.
-        if target_version is None and version_id is not None:
-            logger.info(
-                "modelVersions empty for model %s; falling back to direct "
-                "version lookup for %s",
-                model_id,
-                version_id,
-            )
-            version = await self._fetch_version_by_id(version_id)
-            if version:
-                self._enrich_version_with_model_data(version, model_data)
-                self._remove_comfy_metadata(version)
-                return version
-            return None
-
         if target_version is None:
             return None
 
-        target_version_id = target_version.get("id")
+        target_version_id = target_version.get('id')
-        version = (
+        version = await self._fetch_version_by_id(target_version_id) if target_version_id else None
-            await self._fetch_version_by_id(target_version_id)
-            if target_version_id
-            else None
-        )
 
         if version is None:
             model_hash = self._extract_primary_model_hash(target_version)
@@ -449,9 +315,7 @@ class CivitaiClient:
                 )
 
         if version is None:
-            version = self._build_version_from_model_data(
+            version = self._build_version_from_model_data(target_version, model_id, model_data)
-                target_version, model_id, model_data
-            )
 
         self._enrich_version_with_model_data(version, model_data)
         self._remove_comfy_metadata(version)
@@ -459,14 +323,12 @@ class CivitaiClient:
 
     async def _fetch_model_data(self, model_id: int) -> Optional[Dict]:
         success, data = await self._make_request(
-            "GET",
+            'GET',
             f"{self.base_url}/models/{model_id}",
-            use_auth=True,
+            use_auth=True
         )
         if success:
             return data
-        if is_expected_offline_error(data):
-            return None
         logger.warning(f"Failed to fetch model data for model {model_id}")
         return None
 
@@ -475,14 +337,12 @@ class CivitaiClient:
             return None
 
         success, version = await self._make_request(
-            "GET",
+            'GET',
             f"{self.base_url}/model-versions/{version_id}",
-            use_auth=True,
+            use_auth=True
         )
         if success:
             return version
-        if is_expected_offline_error(version):
-            return None
 
         logger.warning(f"Failed to fetch version by id {version_id}")
         return None
@@ -492,29 +352,26 @@ class CivitaiClient:
             return None
 
         success, version = await self._make_request(
-            "GET",
+            'GET',
             f"{self.base_url}/model-versions/by-hash/{model_hash}",
-            use_auth=True,
+            use_auth=True
         )
         if success:
             return version
-        if is_expected_offline_error(version):
-            return None
 
         logger.warning(f"Failed to fetch version by hash {model_hash}")
         return None
 
-    def _select_target_version(
+    def _select_target_version(self, model_data: Dict, model_id: int, version_id: Optional[int]) -> Optional[Dict]:
-        self, model_data: Dict, model_id: int, version_id: Optional[int]
+        model_versions = model_data.get('modelVersions', [])
-    ) -> Optional[Dict]:
-        model_versions = model_data.get("modelVersions", [])
         if not model_versions:
             logger.warning(f"No model versions found for model {model_id}")
             return None
 
         if version_id is not None:
             target_version = next(
-                (item for item in model_versions if item.get("id") == version_id), None
+                (item for item in model_versions if item.get('id') == version_id),
+                None
             )
             if target_version is None:
                 logger.warning(
@@ -526,87 +383,72 @@ class CivitaiClient:
         return model_versions[0]
 
     def _extract_primary_model_hash(self, version_entry: Dict) -> Optional[str]:
-        for file_info in version_entry.get("files", []):
+        for file_info in version_entry.get('files', []):
-            if file_info.get("type") == "Model" and file_info.get("primary"):
+            if file_info.get('type') == 'Model' and file_info.get('primary'):
-                hashes = file_info.get("hashes", {})
+                hashes = file_info.get('hashes', {})
-                model_hash = hashes.get("SHA256")
+                model_hash = hashes.get('SHA256')
                 if model_hash:
                     return model_hash
         return None
 
-    def _build_version_from_model_data(
+    def _build_version_from_model_data(self, version_entry: Dict, model_id: int, model_data: Dict) -> Dict:
-        self, version_entry: Dict, model_id: int, model_data: Dict
-    ) -> Dict:
         version = copy.deepcopy(version_entry)
-        version.pop("index", None)
+        version.pop('index', None)
-        version["modelId"] = model_id
+        version['modelId'] = model_id
-        version["model"] = {
+        version['model'] = {
-            "name": model_data.get("name"),
+            'name': model_data.get('name'),
-            "type": model_data.get("type"),
+            'type': model_data.get('type'),
-            "nsfw": model_data.get("nsfw"),
+            'nsfw': model_data.get('nsfw'),
-            "poi": model_data.get("poi"),
+            'poi': model_data.get('poi')
         }
         return version
 
     def _enrich_version_with_model_data(self, version: Dict, model_data: Dict) -> None:
-        model_info = version.get("model")
+        model_info = version.get('model')
         if not isinstance(model_info, dict):
             model_info = {}
-            version["model"] = model_info
+            version['model'] = model_info
 
-        model_info["description"] = model_data.get("description")
+        model_info['description'] = model_data.get("description")
-        model_info["tags"] = model_data.get("tags", [])
+        model_info['tags'] = model_data.get("tags", [])
-        version["creator"] = model_data.get("creator")
+        version['creator'] = model_data.get("creator")
 
         license_payload = resolve_license_payload(model_data)
         for field, value in license_payload.items():
             model_info[field] = value
 
-    async def get_model_version_info(
+    async def get_model_version_info(self, version_id: str) -> Tuple[Optional[Dict], Optional[str]]:
-        self, version_id: str
-    ) -> Tuple[Optional[Dict], Optional[str]]:
         """Fetch model version metadata from Civitai
-
+        
         Args:
             version_id: The Civitai model version ID
-
+            
         Returns:
             Tuple[Optional[Dict], Optional[str]]: A tuple containing:
                 - The model version data or None if not found
                 - An error message if there was an error, or None on success
         """
-        # In-memory cache avoids redundant API calls within the same
-        # import/scan flow (e.g. _resolve_base_model_from_checkpoint
-        # followed by _resolve_and_populate_checkpoint with the same id).
-        if version_id in self._version_info_cache:
-            logger.debug("Cache hit for model version info: %s", version_id)
-            self._version_info_cache.move_to_end(version_id)  # LRU bump
-            return self._version_info_cache[version_id]
-
         try:
             url = f"{self.base_url}/model-versions/{version_id}"
-
+            
-            logger.debug("Resolving Civitai model version info: %s", url)
+            logger.debug(f"Resolving DNS for model version info: {url}")
-            success, result = await self._make_request("GET", url, use_auth=True)
+            success, result = await self._make_request(
-
+                'GET',
+                url,
+                use_auth=True
+            )
+            
             if success:
-                logger.debug("Successfully fetched model version info for: %s", version_id)
+                logger.debug(f"Successfully fetched model version info for: {version_id}")
                 self._remove_comfy_metadata(result)
-                self._version_info_cache[version_id] = (result, None)
-                self._version_info_cache.move_to_end(version_id)
-                # Evict oldest entry when over capacity
-                if len(self._version_info_cache) > self._MAX_CACHE_ENTRIES:
-                    self._version_info_cache.popitem(last=False)
                 return result, None
-
+            
             # Handle specific error cases
-            if is_expected_offline_error(result):
-                return None, OFFLINE_FRIENDLY_MESSAGE
             if "not found" in str(result):
                 error_msg = f"Model not found"
                 logger.warning(f"Model version not found: {version_id} - {error_msg}")
                 return None, error_msg
-
+            
             # Other error cases
             logger.error(f"Failed to fetch model info for {version_id}: {result}")
             return None, str(result)
@@ -617,149 +459,55 @@ class CivitaiClient:
             logger.error(error_msg)
             return None, error_msg
 
-    async def get_image_info(
+    async def get_image_info(self, image_id: str) -> Optional[Dict]:
-        self, image_id: str, source_url: str | None = None
-    ) -> Optional[Dict]:
         """Fetch image information from Civitai API
 
         Args:
             image_id: The Civitai image ID
-            source_url: Original image page URL. Accepted for caller compatibility;
+            
-                API requests always target ``civitai.red``.
-
         Returns:
             Optional[Dict]: The image data or None if not found
         """
         try:
-            requested_id = int(image_id)
+            url = f"{self.base_url}/images?imageId={image_id}&nsfw=X"
-            url = self._build_image_info_url(image_id)
+            
-            success, result = await self._make_request("GET", url, use_auth=True)
+            logger.debug(f"Fetching image info for ID: {image_id}")
-
+            success, result = await self._make_request(
-            if not success:
+                'GET',
-                if is_expected_offline_error(result):
+                url,
-                    return None
+                use_auth=True
-                if self._is_transient_server_error(str(result)):
+            )
-                    logger.info(
+            
-                        "Transient server error fetching image info for ID %s: %s",
+            if success:
-                        image_id,
+                if result and "items" in result and len(result["items"]) > 0:
-                        result,
+                    logger.debug(f"Successfully fetched image info for ID: {image_id}")
-                    )
+                    return result["items"][0]
-                    return None
+                logger.warning(f"No image found with ID: {image_id}")
-                logger.error(
-                    "Failed to fetch image info for ID %s from civitai.red: %s",
-                    image_id,
-                    result,
-                )
                 return None
-
+            
-            if result and "items" in result and isinstance(result["items"], list):
+            logger.error(f"Failed to fetch image info for ID: {image_id}: {result}")
-                items = result["items"]
-
-                for item in items:
-                    if isinstance(item, dict) and item.get("id") == requested_id:
-                        logger.debug(
-                            "Successfully fetched image info for ID %s from civitai.red",
-                            image_id,
-                        )
-                        return item
-
-                returned_ids = [
-                    item.get("id")
-                    for item in items
-                    if isinstance(item, dict) and "id" in item
-                ]
-
-                logger.warning(
-                    "CivitAI API returned no matching image for requested ID %s from civitai.red. Returned %d item(s) with IDs: %s. This may indicate the image was deleted, hidden, or there is a database lag.",
-                    image_id,
-                    len(items),
-                    returned_ids,
-                )
-                return None
-
-            logger.warning("No image found with ID: %s", image_id)
             return None
         except RateLimitError:
             raise
-        except ValueError as e:
-            error_msg = f"Invalid image ID format: {image_id}"
-            logger.error(error_msg)
-            return None
         except Exception as e:
             error_msg = f"Error fetching image info: {e}"
             logger.error(error_msg)
             return None
 
-    async def get_model_versions_by_hashes(
-        self, hashes: List[str]
-    ) -> Optional[List[Dict]]:
-        """Fetch full version details for up to 100 SHA256 hashes via the batch endpoint.
-
-        Uses POST /api/v1/model-versions/by-hash which returns full version
-        details including ``usageControl`` and ``earlyAccessEndsAt`` that are
-        not available from the model-level API.
-
-        Args:
-            hashes: List of SHA256 hashes (max 100 per batch; auto-split).
-
-        Returns:
-            List of version dicts or None on failure.
-        """
-        if not hashes:
-            return []
-
-        BATCH_SIZE = 100
-        all_versions: List[Dict] = []
-
-        for start in range(0, len(hashes), BATCH_SIZE):
-            batch = hashes[start : start + BATCH_SIZE]
-            try:
-                success, result = await self._make_request(
-                    "POST",
-                    f"{self.base_url}/model-versions/by-hash",
-                    use_auth=True,
-                    json=batch,
-                )
-                if not success:
-                    logger.warning(
-                        "Batch by-hash request failed for %d hashes: %s",
-                        len(batch),
-                        result,
-                    )
-                    continue
-
-                if isinstance(result, list):
-                    all_versions.extend(result)
-                else:
-                    logger.debug(
-                        "Unexpected by-hash response type: %s", type(result)
-                    )
-            except RateLimitError:
-                raise
-            except Exception as exc:  # pragma: no cover - defensive logging
-                logger.error(
-                    "Error fetching model versions by hashes: %s", exc
-                )
-
-        return all_versions if all_versions else None
-
     async def get_user_models(self, username: str) -> Optional[List[Dict]]:
         """Fetch all models for a specific Civitai user."""
         if not username:
             return None
 
         try:
+            url = f"{self.base_url}/models?username={username}"
             success, result = await self._make_request(
-                "GET",
+                'GET',
-                f"{self.base_url}/models",
+                url,
-                use_auth=True,
+                use_auth=True
-                params={"username": username, "nsfw": "true"},
             )
 
             if not success:
-                if is_expected_offline_error(result):
-                    logger.info("User model fetch skipped: %s", OFFLINE_FRIENDLY_MESSAGE)
-                    return None
                 logger.error("Failed to fetch models for %s: %s", username, result)
                 return None
 

py/services/connectivity_guard.py

@@ -1,204 +0,0 @@
-"""In-memory connectivity guard to suppress repeated network retries when offline."""
-
-from __future__ import annotations
-
-import asyncio
-import errno
-import logging
-import socket
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Any
-
-import aiohttp
-
-logger = logging.getLogger(__name__)
-
-OFFLINE_COOLDOWN_ERROR = "offline_cooldown"
-OFFLINE_FRIENDLY_MESSAGE = "Network offline, will retry automatically later"
-
-
-def is_offline_cooldown_error(value: Any) -> bool:
-    """Return True when a response payload represents guard short-circuit."""
-    return isinstance(value, str) and value == OFFLINE_COOLDOWN_ERROR
-
-
-def is_expected_offline_error(value: Any) -> bool:
-    """Return True when payload is an expected offline-related result."""
-    if is_offline_cooldown_error(value):
-        return True
-    if not isinstance(value, str):
-        return False
-    normalized = value.lower()
-    return "network offline" in normalized or "offline" in normalized
-
-
-class ConnectivityGuard:
-    """Tracks network failures and gates outbound requests during cooldown."""
-
-    _instance: "ConnectivityGuard | None" = None
-    _instance_lock = asyncio.Lock()
-
-    @classmethod
-    async def get_instance(cls) -> "ConnectivityGuard":
-        async with cls._instance_lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    def __init__(self) -> None:
-        if hasattr(self, "_initialized"):
-            return
-        self._initialized = True
-        self._default_destination = "__global__"
-        self._destination_states: dict[str, _DestinationState] = {
-            self._default_destination: _DestinationState()
-        }
-        self.base_backoff_seconds = 30
-        self.max_backoff_seconds = 300
-        self.failure_threshold = 3
-
-    @property
-    def online(self) -> bool:
-        return self._state_for_destination(None).online
-
-    @online.setter
-    def online(self, value: bool) -> None:
-        self._state_for_destination(None).online = value
-
-    @property
-    def failure_count(self) -> int:
-        return self._state_for_destination(None).failure_count
-
-    @failure_count.setter
-    def failure_count(self, value: int) -> None:
-        self._state_for_destination(None).failure_count = value
-
-    @property
-    def cooldown_until(self) -> datetime | None:
-        return self._state_for_destination(None).cooldown_until
-
-    @cooldown_until.setter
-    def cooldown_until(self, value: datetime | None) -> None:
-        self._state_for_destination(None).cooldown_until = value
-
-    def _now(self) -> datetime:
-        return datetime.now()
-
-    def _normalize_destination(self, destination: str | None) -> str:
-        if destination is None or not destination.strip():
-            return self._default_destination
-        return destination.lower().strip()
-
-    def _state_for_destination(self, destination: str | None) -> "_DestinationState":
-        destination_key = self._normalize_destination(destination)
-        if destination_key not in self._destination_states:
-            self._destination_states[destination_key] = _DestinationState()
-        return self._destination_states[destination_key]
-
-    def in_cooldown(self, destination: str | None = None) -> bool:
-        state = self._state_for_destination(destination)
-        if state.cooldown_until is None:
-            return False
-        return self._now() < state.cooldown_until
-
-    def cooldown_remaining_seconds(self, destination: str | None = None) -> float:
-        state = self._state_for_destination(destination)
-        if state.cooldown_until is None:
-            return 0.0
-        return max(0.0, (state.cooldown_until - self._now()).total_seconds())
-
-    def should_block_request(self, destination: str | None = None) -> bool:
-        return self.in_cooldown(destination)
-
-    def register_success(self, destination: str | None = None) -> None:
-        destination_key = self._normalize_destination(destination)
-        state = self._state_for_destination(destination_key)
-        was_offline = (not state.online) or state.cooldown_until is not None
-        state.online = True
-        state.failure_count = 0
-        state.cooldown_until = None
-        if was_offline:
-            logger.info(
-                "Connectivity restored for destination '%s'; requests resumed.",
-                destination_key,
-            )
-
-    def register_network_failure(
-        self, exc: Exception, destination: str | None = None
-    ) -> None:
-        destination_key = self._normalize_destination(destination)
-        state = self._state_for_destination(destination_key)
-        state.online = False
-        state.failure_count += 1
-
-        if state.failure_count < self.failure_threshold:
-            logger.debug(
-                "Network failure tracked for destination '%s' (%d/%d): %s",
-                destination_key,
-                state.failure_count,
-                self.failure_threshold,
-                exc,
-            )
-            return
-
-        retry_step = state.failure_count - self.failure_threshold
-        backoff = min(
-            self.max_backoff_seconds,
-            self.base_backoff_seconds * (2**retry_step),
-        )
-        should_log_warning = not self.in_cooldown(destination_key)
-        state.cooldown_until = self._now() + timedelta(seconds=backoff)
-
-        if should_log_warning:
-            logger.warning(
-                "Connectivity offline for destination '%s'; enter cooldown for %ss after %d network failures.",
-                destination_key,
-                int(backoff),
-                state.failure_count,
-            )
-        else:
-            logger.debug(
-                "Cooldown still active for destination '%s'; failure_count=%d, backoff=%ss.",
-                destination_key,
-                state.failure_count,
-                int(backoff),
-            )
-
-    @staticmethod
-    def is_network_unreachable_error(exc: Exception) -> bool:
-        """Return whether the exception should count as connectivity failure."""
-        if isinstance(exc, asyncio.CancelledError):
-            return False
-
-        if isinstance(
-            exc,
-            (
-                asyncio.TimeoutError,
-                TimeoutError,
-                ConnectionRefusedError,
-                socket.gaierror,
-                aiohttp.ServerTimeoutError,
-                aiohttp.ConnectionTimeoutError,
-                aiohttp.ClientConnectorError,
-                aiohttp.ClientConnectionError,
-            ),
-        ):
-            return True
-
-        if isinstance(exc, OSError) and exc.errno in {
-            errno.ENETUNREACH,
-            errno.EHOSTUNREACH,
-            errno.ETIMEDOUT,
-            errno.ECONNREFUSED,
-        }:
-            return True
-
-        return False
-
-
-@dataclass
-class _DestinationState:
-    online: bool = True
-    failure_count: int = 0
-    cooldown_until: datetime | None = None

py/services/custom_words_service.py

@@ -7,13 +7,11 @@ with category filtering and enriched results including post counts.
 from __future__ import annotations
 
 import logging
-import re
 from typing import List, Dict, Any, Optional
 
 logger = logging.getLogger(__name__)
 
 
-_EMBEDDED_COMMAND_PATTERN = re.compile(r"\s/\w")
 class CustomWordsService:
     """Service for autocomplete via TagFTSIndex.
 
@@ -51,7 +49,6 @@ class CustomWordsService:
         if self._tag_index is None:
             try:
                 from .tag_fts_index import get_tag_fts_index
-
                 self._tag_index = get_tag_fts_index()
             except Exception as e:
                 logger.warning(f"Failed to initialize TagFTSIndex: {e}")
@@ -62,16 +59,14 @@ class CustomWordsService:
         self,
         search_term: str,
         limit: int = 20,
-        offset: int = 0,
         categories: Optional[List[int]] = None,
-        enriched: bool = False,
+        enriched: bool = False
     ) -> List[Dict[str, Any]]:
         """Search tags using TagFTSIndex with category filtering.
 
         Args:
             search_term: The search term to match against.
             limit: Maximum number of results to return.
-            offset: Number of results to skip.
             categories: Optional list of category IDs to filter by.
             enriched: If True, always return enriched results with category
                        and post_count (default behavior now).
@@ -79,28 +74,10 @@ class CustomWordsService:
         Returns:
             List of dicts with tag_name, category, and post_count.
         """
-        normalized_search = search_term.strip()
-        if not normalized_search:
-            return []
-
-        # Prompt widgets should only send the active token, but guard against
-        # accidental full-prompt queries reaching the FTS path.
-        if (
-            "__" in normalized_search
-            or "," in normalized_search
-            or ">" in normalized_search
-            or "\n" in normalized_search
-            or "\r" in normalized_search
-            or _EMBEDDED_COMMAND_PATTERN.search(normalized_search)
-        ):
-            logger.debug("Skipping prompt-like custom words query: %s", normalized_search)
-            return []
-
         tag_index = self._get_tag_index()
         if tag_index is not None:
-            return tag_index.search(
+            results = tag_index.search(search_term, categories=categories, limit=limit)
-                normalized_search, categories=categories, limit=limit, offset=offset
+            return results
-            )
 
         logger.debug("TagFTSIndex not available, returning empty results")
         return []