Add/update custom_nodes

.gitattributes

@@ -53,3 +53,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+custom_nodes/ComfyUI-KJNodes/fonts/FreeMono.ttf filter=lfs diff=lfs merge=lfs -text
+custom_nodes/ComfyUI-KJNodes/fonts/FreeMonoBoldOblique.otf filter=lfs diff=lfs merge=lfs -text
+custom_nodes/ComfyUI-KJNodes/fonts/TTNorms-Black.otf filter=lfs diff=lfs merge=lfs -text

custom_nodes/Civicomfy/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

custom_nodes/Civicomfy/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'MoonGoblinDev' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

custom_nodes/Civicomfy/.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+download_history.json
+.DS_Store
+/Old Reference
+CLAUDE.md
+web/.DS_Store
+/tests

custom_nodes/Civicomfy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MoonGoblin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

custom_nodes/Civicomfy/README.md

@@ -0,0 +1,52 @@
+# Civicomfy - Civitai Model Downloader for ComfyUI
+
+Civicomfy seamlessly integrates Civitai's vast model repository directly into ComfyUI, allowing you to search, download, and organize AI models without leaving your workflow.
+
+## Features
+
+- **Integrated Model Search**: Search Civitai's extensive library directly from ComfyUI
+- **One-Click Downloads**: Download models with associated metadata and thumbnails
+- **Automatic Organization**: Models are automatically saved to their appropriate directories
+- **Clean UI**: Clean, intuitive interface that complements ComfyUI's aesthetic
+
+## Installation
+
+Git clone
+```bash
+cd ComfyUI/custom_nodes
+git clone https://github.com/MoonGoblinDev/Civicomfy.git
+```
+
+Comfy-CLI
+```bash
+comfy node registry-install civicomfy
+```
+
+ComfyUI Manager
+
+<img width="813" alt="Screenshot 2025-04-08 at 11 42 46" src="https://github.com/user-attachments/assets/5d4f5261-88f6-4aa0-9c66-d1811bb49e09" />
+
+## Usage
+
+1. Start ComfyUI with Civicomfy installed
+2. Access the Civicomfy panel from the Civicomfy menu button at the right top area.
+3. Search for models
+4. Click the download button on any model to save it to your local installation
+5. Models become immediately available in ComfyUI nodes
+
+## Configuration
+
+- Enter your Civitai API Token in the setting
+
+## Screenshots
+<img width="911" alt="Screenshot 2025-04-08 at 11 24 40" src="https://github.com/user-attachments/assets/b9be0c32-729d-490e-be61-2dc072cd9b15" />
+<img width="911" alt="Screenshot 2025-04-08 at 11 23 17" src="https://github.com/user-attachments/assets/cb747c22-afd0-4baf-a9a2-39c70fb11e46" />
+<img width="911" alt="Screenshot 2025-04-08 at 11 25 15" src="https://github.com/user-attachments/assets/02b6d841-a0fa-484c-91a4-4095a7554c3f" />
+<img width="911" alt="Screenshot 2025-04-08 at 11 25 24" src="https://github.com/user-attachments/assets/20fcfcb5-3345-4a72-89fe-ee9c50626ebc" />
+
+
+
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

custom_nodes/Civicomfy/__init__.py

@@ -0,0 +1,110 @@
+# ================================================
+# File: __init__.py
+# ================================================
+
+import os
+
+# Define paths relative to this __init__.py file
+EXTENSION_ROOT = os.path.dirname(os.path.realpath(__file__))
+WEB_PATH = os.path.join(EXTENSION_ROOT, "web")
+JS_PATH = os.path.join(WEB_PATH, "js")
+# CSS_PATH definition removed as it was unused and pointed to a non-existent directory.
+JS_FILENAME = "civitaiDownloader.js"
+CSS_FILENAME = "civitaiDownloader.css"
+JS_FILE_PATH = os.path.join(JS_PATH, JS_FILENAME)
+CSS_FILE_PATH = os.path.join(JS_PATH, CSS_FILENAME) 
+
+# --- Import Core Components ---
+# Import configurations and utility functions first
+# Ensure config and helpers don't have side effects unsuitable for just checking files
+try:
+    from .config import WEB_DIRECTORY as config_WEB_DIRECTORY
+    # Import downloader manager (creates the instance)
+    from .downloader import manager as download_manager
+    # Import server routes (registers the routes)
+    from .server import routes
+    imports_successful = True
+    print("[Civicomfy] Core modules imported successfully.")
+except ImportError as e:
+    imports_successful = False
+    print("*"*80)
+    print(f"[Civicomfy] ERROR: Failed to import core modules: {e}")
+    print("Please ensure the file structure is correct and all required files exist.")
+    print("Extension will likely not function correctly.")
+    print("*"*80)
+except Exception as e:
+    imports_successful = False
+    # Catch other potential init errors during import
+    import traceback
+    print("*"*80)
+    print(f"[Civicomfy] ERROR: An unexpected error occurred during module import:")
+    traceback.print_exc()
+    print("Extension will likely not function correctly.")
+    print("*"*80)
+
+# --- Check for Frontend Files ---
+frontend_files_ok = True
+if not os.path.exists(CSS_FILE_PATH):
+    print("*"*80)
+    print(f"[Civicomfy] WARNING: Frontend CSS file not found!")
+    print(f"                         Expected at: {CSS_FILE_PATH}")
+    print("                         The downloader UI may not display correctly.")
+    print(f"                         Please ensure '{CSS_FILENAME}' is placed in the '{os.path.basename(JS_PATH)}' directory inside 'web'.") # Corrected path hint
+    print("*"*80)
+    frontend_files_ok = False
+
+if not os.path.exists(JS_FILE_PATH):
+    print("*"*80)
+    print(f"[Civicomfy] WARNING: Frontend JavaScript file not found!")
+    print(f"                         Expected at: {JS_FILE_PATH}")
+    print("                         The downloader UI functionality will be missing.")
+    print(f"                         Please ensure '{JS_FILENAME}' is placed in the '{os.path.basename(JS_PATH)}' directory inside 'web'.") # Corrected path hint
+    print("*"*80)
+    frontend_files_ok = False
+
+# --- ComfyUI Registration ---
+if imports_successful:
+    # Standard ComfyUI extension variables
+    # No custom nodes defined in this extension
+    NODE_CLASS_MAPPINGS = {}
+    NODE_DISPLAY_NAME_MAPPINGS = {}
+
+    # Define the web directory for ComfyUI to serve
+    # The key is the path component in the URL: /extensions/Civicomfy/...
+    # The value is the directory path relative to this __init__.py file
+    WEB_DIRECTORY = "./web" # This tells ComfyUI to serve the ./web folder relative to this file
+
+    # --- Startup Messages ---
+    print("-" * 30)
+    print("--- Civicomfy Custom Extension Loaded ---")
+    print(f"- Serving frontend files from: {os.path.abspath(WEB_PATH)} (Relative: {WEB_DIRECTORY})")
+    # Download manager and routes are initialized/registered upon import
+    print(f"- Download Manager Initialized: {'Yes' if 'download_manager' in locals() else 'No! Import failed.'}")
+    print(f"- API Endpoints Registered: {'Yes' if 'routes' in locals() else 'No! Import failed.'}")
+    if frontend_files_ok:
+         print("- Frontend files found.")
+    else:
+         print("- WARNING: Frontend files missing (see warnings above). UI may not work.")
+    print("- Look for 'Civicomfy' button in the ComfyUI menu.")
+    print("-" * 30)
+
+    # Ensure default model-type directories exist at startup
+    try:
+        from .utils.helpers import get_model_dir
+        from .config import MODEL_TYPE_DIRS
+        created = []
+        for key in MODEL_TYPE_DIRS.keys():
+            path = get_model_dir(key)
+            created.append((key, path))
+        print("[Civicomfy] Verified model type directories:")
+        for k, p in created:
+            print(f"  - {k}: {p}")
+    except Exception as e:
+        print(f"[Civicomfy] Warning: Failed ensuring model directories at startup: {e}")
+
+else:
+    # If imports failed, don't register anything with ComfyUI
+    print("[Civicomfy] Initialization failed due to import errors. Extension inactive.")
+    NODE_CLASS_MAPPINGS = {}
+    NODE_DISPLAY_NAME_MAPPINGS = {}
+    WEB_DIRECTORY = None # Do not serve web directory if backend failed

custom_nodes/Civicomfy/api/civitai.py

@@ -0,0 +1,255 @@
+# ================================================
+# File: api/civitai.py
+# ================================================
+import requests
+import json
+from typing import List, Optional, Dict, Any, Union
+
+class CivitaiAPI:
+    """Simple wrapper for interacting with the Civitai API v1."""
+    BASE_URL = "https://civitai.com/api/v1"
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+        self.base_headers = {'Content-Type': 'application/json'}
+        if api_key:
+            self.base_headers["Authorization"] = f"Bearer {api_key}"
+            print("[Civitai API] Using API Key.")
+        else:
+            print("[Civitai API] No API Key provided.")
+
+    def _get_request_headers(self, method: str, has_json_data: bool) -> Dict[str, str]:
+        """Returns headers for a specific request."""
+        headers = self.base_headers.copy()
+        # Don't send content-type for GET/HEAD if no json_data
+        if method.upper() in ["GET", "HEAD"] and not has_json_data:
+            headers.pop('Content-Type', None)
+        return headers
+
+    def _request(self, method: str, endpoint: str, params: Optional[Dict] = None,
+                 json_data: Optional[Dict] = None, stream: bool = False,
+                 allow_redirects: bool = True, timeout: int = 30) -> Union[Dict[str, Any], requests.Response, None]:
+        """Makes a request to the Civitai API and handles basic errors."""
+        url = f"{self.BASE_URL}/{endpoint.lstrip('/')}"
+        request_headers = self._get_request_headers(method, json_data is not None)
+
+        try:
+            response = requests.request(
+                method,
+                url,
+                headers=request_headers,
+                params=params,
+                json=json_data,
+                stream=stream,
+                allow_redirects=allow_redirects,
+                timeout=timeout
+            )
+            response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+
+            if stream:
+                return response  # Return the response object for streaming
+
+            # Handle No Content response (e.g., 204)
+            if response.status_code == 204 or not response.content:
+                return None
+
+            return response.json()
+
+        except requests.exceptions.HTTPError as http_err:
+            error_detail = None
+            status_code = http_err.response.status_code
+            try:
+                error_detail = http_err.response.json()
+            except json.JSONDecodeError:
+                error_detail = http_err.response.text[:200] # First 200 chars
+            print(f"Civitai API HTTP Error ({method} {url}): Status {status_code}, Response: {error_detail}")
+            # Return a structured error dictionary
+            return {"error": f"HTTP Error: {status_code}", "details": error_detail, "status_code": status_code}
+
+        except requests.exceptions.RequestException as req_err:
+            print(f"Civitai API Request Error ({method} {url}): {req_err}")
+            return {"error": str(req_err), "details": None, "status_code": None}
+
+        except json.JSONDecodeError as json_err:
+            print(f"Civitai API Error: Failed to decode JSON response from {url}: {json_err}")
+            # Include response text if possible and not streaming
+            response_text = response.text[:200] if not stream and hasattr(response, 'text') else "N/A"
+            return {"error": "Invalid JSON response", "details": response_text, "status_code": response.status_code if hasattr(response, 'status_code') else None}
+
+    def get_model_info(self, model_id: int) -> Optional[Dict[str, Any]]:
+        """Gets information about a model by its ID. (GET /models/{id})"""
+        endpoint = f"/models/{model_id}"
+        result = self._request("GET", endpoint)
+        # Check if the result is an error dictionary
+        if isinstance(result, dict) and "error" in result:
+            return result # Propagate error dict
+        return result # Return model info dict or None
+
+    def get_model_version_info(self, version_id: int) -> Optional[Dict[str, Any]]:
+        """Gets information about a specific model version by its ID. (GET /model-versions/{id})"""
+        endpoint = f"/model-versions/{version_id}"
+        result = self._request("GET", endpoint)
+        if isinstance(result, dict) and "error" in result:
+            return result
+        return result
+
+    def search_models(self, query: str, types: Optional[List[str]] = None,
+                      sort: str = 'Highest Rated', period: str = 'AllTime',
+                      limit: int = 20, page: int = 1,
+                      nsfw: Optional[bool] = None) -> Optional[Dict[str, Any]]:
+        """Searches for models on Civitai. (GET /models)"""
+        endpoint = "/models"
+        params = {
+            "limit": max(1, min(100, limit)), # Ensure limit is reasonable
+            "page": max(1, page),
+            "query": query,
+            "sort": sort,
+            "period": period
+        }
+        if types:
+            # `requests` handles lists by appending multiple key=value pairs,
+            # which matches the expectation for 'array' type in the API doc.
+             params["types"] = types
+        if nsfw is not None:
+            params["nsfw"] = str(nsfw).lower() # API expects string "true" or "false"
+
+        result = self._request("GET", endpoint, params=params)
+        if isinstance(result, dict) and "error" in result:
+            return result
+        # Ensure structure is as expected before returning
+        if isinstance(result, dict) and "items" in result and "metadata" in result:
+             return result
+        else:
+             print(f"Warning: Unexpected search result format: {result}")
+             # Return a consistent empty structure on unexpected format
+             return {"items": [], "metadata": {"totalItems": 0, "currentPage": page, "pageSize": limit, "totalPages": 0}}
+        
+    def search_models_meili(self, query: str, types: Optional[List[str]] = None,
+                            base_models: Optional[List[str]] = None,
+                            sort: str = 'metrics.downloadCount:desc', # Default to Most Downloaded
+                            limit: int = 20, page: int = 1,
+                            nsfw: Optional[bool] = None) -> Optional[Dict[str, Any]]:
+        """Searches models using the Civitai Meilisearch endpoint."""
+        meili_url = "https://search.civitai.com/multi-search"
+        headers = {'Content-Type': 'application/json'}
+        headers['Authorization'] = f'Bearer 8c46eb2508e21db1e9828a97968d91ab1ca1caa5f70a00e88a2ba1e286603b61' #Nothing harmful, everyone have the same meilisearch bearer token. I checked with 3 accounts
+
+        offset = max(0, (page - 1) * limit)
+
+        # Map simple sort terms to Meilisearch syntax
+        sort_mapping = {
+            "Relevancy": "id:desc",
+            "Most Downloaded": "metrics.downloadCount:desc",
+            "Highest Rated": "metrics.thumbsUpCount:desc", 
+            "Most Liked": "metrics.favoriteCount:desc", 
+            "Most Discussed": "metrics.commentCount:desc", 
+            "Most Collected": "metrics.collectedCount:desc", 
+            "Most Buzz": "metrics.tippedAmountCount:desc", 
+            "Newest": "createdAt:desc", 
+        }
+        meili_sort = [sort_mapping.get(sort, "metrics.downloadCount:desc")]
+        
+        
+        # --- Build Filters ---
+        # Meilisearch uses an array of filter groups. Filters within a group are OR'd, groups are AND'd.
+        filter_groups = []
+
+        # Type Filter Group (OR logic)
+        if types and isinstance(types, list) and len(types) > 0:
+             # Map internal type keys/display names to API type names if needed,
+             # but the provided example uses direct type names like "LORA". Let's assume frontend sends correct names.
+             # Ensure proper quoting for string values in the filter.
+             type_filters = [f'"type"="{t}"' for t in types]
+             filter_groups.append(type_filters)
+
+        # Base Model Filter Group (OR logic)
+        if base_models and isinstance(base_models, list) and len(base_models) > 0:
+            base_model_filters = [f'"version.baseModel"="{bm}"' for bm in base_models]
+            filter_groups.append(base_model_filters)
+
+        # NSFW Filter (applied as AND) - Meili typically uses boolean facets or numeric levels
+        # Let's filter by 'nsfwLevel' being acceptable (1=None, 2=Mild, 4=Mature) if NSFW is false or None.
+        # If NSFW is true, we don't add this filter (allow all levels).
+        # This might need adjustment based on exact Meili setup and desired behavior.
+        # An alternative is filtering on the 'nsfw' boolean field if it exists directly.
+        if nsfw is None or nsfw is False:
+             # Example: Allow levels 1, 2, 4 (adjust as needed)
+             # Meili syntax for multiple values: nsfwLevel IN [1, 2, 4]
+             filter_groups.append("nsfwLevel IN [1, 2, 4]") # Filter applied directly as AND
+             # Or maybe filter on the boolean `nsfw` field if it's indexed:
+             # filter_groups.append("nsfw = false")
+
+        # Availability Filter (Public)
+        filter_groups.append("availability = Public") # Filter applied directly as AND
+
+        # --- Construct Request Body ---
+        payload = {
+            "queries": [
+                {
+                    "q": query if query else "", # Send empty string "" if no query
+                    "indexUid": "models_v9",
+                    "facets": [ # Keep facets requested by frontend if needed for analytics/refinement UI
+                        "category.name",
+                        "checkpointType",
+                        "fileFormats",
+                        "lastVersionAtUnix",
+                        "tags.name",
+                        "type",
+                        "user.username",
+                        "version.baseModel",
+                        "nsfwLevel"
+                    ],
+                    "attributesToHighlight": [], # Keep empty if not using highlighting
+                    "highlightPreTag": "__ais-highlight__",
+                    "highlightPostTag": "__/ais-highlight__",
+                    "limit": max(1, min(100, limit)), # Ensure reasonable limit
+                    "offset": offset,
+                    "filter": filter_groups
+                }
+            ]
+        }
+        if(sort != "Relevancy"):
+            payload["queries"][0]["sort"] = meili_sort
+        
+
+        try:
+            # print(f"DEBUG: Meili Search Payload: {json.dumps(payload, indent=2)}") # Debugging payload
+            response = requests.post(meili_url, headers=headers, json=payload, timeout=25) # Use reasonable timeout
+            response.raise_for_status()
+
+            results_data = response.json()
+            # print(f"DEBUG: Meili Search Response: {json.dumps(results_data, indent=2)}") # Debugging response
+
+            # Basic validation of response structure
+            if not results_data or not isinstance(results_data.get('results'), list) or not results_data['results']:
+                 print(f"Warning: Meili search returned unexpected structure or empty results list: {results_data}")
+                 # Return empty structure consistent with expected format downstream
+                 return {"hits": [], "limit": limit, "offset": offset, "estimatedTotalHits": 0}
+
+            # Return the content of the first result (assuming single query)
+            first_result = results_data['results'][0]
+            if isinstance(first_result, dict) and "hits" in first_result:
+                 # Return the relevant part of the response
+                 return first_result # Includes hits, processingTimeMs, limit, offset, estimatedTotalHits etc.
+            else:
+                  print(f"Warning: Meili search first result structure invalid: {first_result}")
+                  return {"hits": [], "limit": limit, "offset": offset, "estimatedTotalHits": 0}
+
+        except requests.exceptions.HTTPError as http_err:
+            error_detail = None
+            status_code = http_err.response.status_code
+            try:
+                error_detail = http_err.response.json()
+            except json.JSONDecodeError:
+                error_detail = http_err.response.text[:200]
+            print(f"Civitai Meili Search HTTP Error ({meili_url}): Status {status_code}, Response: {error_detail}")
+            return {"error": f"Meili HTTP Error: {status_code}", "details": error_detail, "status_code": status_code}
+
+        except requests.exceptions.RequestException as req_err:
+            print(f"Civitai Meili Search Request Error ({meili_url}): {req_err}")
+            return {"error": str(req_err), "details": None, "status_code": None}
+
+        except json.JSONDecodeError as json_err:
+            print(f"Civitai Meili Search Error: Failed to decode JSON response from {meili_url}: {json_err}")
+            response_text = response.text[:200] if hasattr(response, 'text') else "N/A"
+            return {"error": "Invalid JSON response from Meili", "details": response_text, "status_code": response.status_code if hasattr(response, 'status_code') else None}

custom_nodes/Civicomfy/config.py

@@ -0,0 +1,94 @@
+# ================================================
+# File: config.py
+# ================================================
+import os
+import folder_paths # Use ComfyUI's folder_paths
+
+# --- Configuration ---
+MAX_CONCURRENT_DOWNLOADS = 3
+DEFAULT_CHUNK_SIZE = 1024 * 1024  # 1MB
+DEFAULT_CONNECTIONS = 4
+DOWNLOAD_HISTORY_LIMIT = 100
+DOWNLOAD_TIMEOUT = 60 # Timeout for individual download chunks/requests (seconds)
+HEAD_REQUEST_TIMEOUT = 25 # Timeout for initial HEAD request (seconds)
+METADATA_DOWNLOAD_TIMEOUT = 20 # Timeout for downloading thumbnail (seconds)
+
+# --- Paths ---
+# The root directory of *this specific plugin/extension*
+# Calculated based on the location of this config.py file
+PLUGIN_ROOT = os.path.dirname(os.path.realpath(__file__))
+
+# Construct web paths relative to the plugin's root directory
+WEB_DIRECTORY = os.path.join(PLUGIN_ROOT, "web")
+JAVASCRIPT_PATH = os.path.join(WEB_DIRECTORY, "js")
+CSS_PATH = os.path.join(WEB_DIRECTORY, "css")
+# Corrected path construction to avoid issues with leading slashes
+PLACEHOLDER_IMAGE_PATH = os.path.join(WEB_DIRECTORY, "images", "placeholder.jpeg")
+
+# Get ComfyUI directories using folder_paths
+COMFYUI_ROOT_DIR = folder_paths.base_path
+# MODELS_DIR removed; resolve per-type via folder_paths
+
+# --- Model Types ---
+# Maps the internal key (lowercase) to a tuple: (display_name, folder_paths_type)
+# The folder_paths_type is used by ComfyUI's folder_paths.get_directory_by_type().
+MODEL_TYPE_DIRS = {
+    "checkpoint": ("Checkpoint", "checkpoints"),
+    "diffusionmodels": ("Diffusion Models", "diffusers"),
+    "unet": ("Unet", "unet"),
+    "lora": ("Lora", "loras"),
+    "locon": ("LoCon", "loras"),
+    "lycoris": ("LyCORIS", "loras"),
+    "vae": ("VAE", "vae"),
+    "embedding": ("Embedding", "embeddings"),
+    "hypernetwork": ("Hypernetwork", "hypernetworks"),
+    "controlnet": ("ControlNet", "controlnet"),
+    "upscaler": ("Upscaler", "upscale_models"),
+    "motionmodule": ("Motion Module", "motion_models"),
+    "poses": ("Poses", "poses"),
+    "wildcards": ("Wildcards", "wildcards"),
+    # 'other' will save to a dedicated folder inside the Civicomfy extension directory
+    "other": ("Other", None)
+}
+
+# Civitai API specific type mapping (for search filters)
+# Maps internal key (lowercase) to Civitai API 'types' parameter value
+CIVITAI_API_TYPE_MAP = {
+    "checkpoint": "Checkpoint",
+    "lora": "LORA",
+    "locon": "LoCon",
+    "lycoris": "LORA", # Civitai might group LyCORIS under LORA search type
+    "vae": "VAE",
+    "embedding": "TextualInversion",
+    "hypernetwork": "Hypernetwork",
+    "controlnet": "Controlnet",
+    "motionmodule": "MotionModule",
+    "poses": "Poses",
+    "wildcards": "Wildcards",
+    "upscaler": "Upscaler", 
+    "unet": "UNET",
+    "diffusionmodels": "Checkpoint", # No specific type, map to checkpoint
+}
+
+AVAILABLE_MEILI_BASE_MODELS = [
+    "AuraFlow", "CogVideoX", "Flux.1 D", "Flux.1 S", "Hunyuan 1", "Hunyuan Video",
+    "Illustrious", "Kolors", "LTXV", "Lumina", "Mochi", "NoobAI", "ODOR", "Other",
+    "PixArt E", "PixArt a", "Playground v2", "Pony", "SD 1.4", "SD 1.5",
+    "SD 1.5 Hyper", "SD 1.5 LCM", "SD 2.0", "SD 2.0 768", "SD 2.1", "SD 2.1 768",
+    "SD 2.1 Unclip", "SD 3", "SD 3.5", "SD 3.5 Large", "SD 3.5 Large Turbo",
+    "SD 3.5 Medium", "SDXL 0.9", "SDXL 1.0", "SDXL 1.0 LCM", "SDXL Distilled",
+    "SDXL Hyper", "SDXL Lightning", "SDXL Turbo", "SVD", "SVD XT", "Stable Cascade",
+    "Wan Video"
+]
+
+# --- Filename Suffixes ---
+METADATA_SUFFIX = ".cminfo.json"
+PREVIEW_SUFFIX = ".preview.jpeg" # Keep as requested, even if source is png/webp
+
+# --- Log Initial Paths for Verification ---
+print("-" * 30)
+print("[Civicomfy Config Initialized]")
+print(f"  - Plugin Root: {PLUGIN_ROOT}")
+print(f"  - Web Directory: {WEB_DIRECTORY}")
+print(f"  - ComfyUI Base Path: {COMFYUI_ROOT_DIR}")
+print("-" * 30)

custom_nodes/Civicomfy/downloader/chunk_downloader.py

@@ -0,0 +1,574 @@
+# ================================================
+# File: downloader/chunk_downloader.py 
+# Multi-connection somehow still not working
+# ================================================
+
+import requests
+import threading
+import time
+import shutil
+from pathlib import Path
+import os
+from typing import Optional, Dict, Tuple, Union, TYPE_CHECKING
+
+# Import manager type hint without circular dependency during type checking
+if TYPE_CHECKING:
+    from .manager import DownloadManager
+
+# Import config values
+from ..config import DEFAULT_CHUNK_SIZE, DOWNLOAD_TIMEOUT, HEAD_REQUEST_TIMEOUT
+
+class ChunkDownloader:
+    """Handles downloading files in chunks using multiple connections or fallback."""
+    # Constants
+    STATUS_UPDATE_INTERVAL = 0.5
+    HEAD_REQUEST_TIMEOUT = HEAD_REQUEST_TIMEOUT
+    DOWNLOAD_TIMEOUT = DOWNLOAD_TIMEOUT
+    MIN_SIZE_FOR_MULTI_MB = 100  # Minimum file size for multi-connection download
+
+    def __init__(self, url: str, output_path: str, num_connections: int = 4,
+                 chunk_size: int = DEFAULT_CHUNK_SIZE, manager: 'DownloadManager' = None,
+                 download_id: str = None, api_key: Optional[str] = None,
+                 known_size: Optional[int] = None):
+        # URLs
+        self.initial_url = url
+        self.url = url
+        
+        # Paths
+        self.output_path = Path(output_path)
+        self.temp_dir = self.output_path.parent / f".{self.output_path.name}.parts_{download_id or int(time.time())}"
+        
+        # Download configuration
+        self.num_connections = max(1, num_connections)
+        self.chunk_size = chunk_size
+        self.manager = manager
+        self.download_id = download_id
+        self.api_key = api_key
+        self.known_size = known_size if known_size and known_size > 0 else None
+        
+        # Download state
+        self.total_size = self.known_size or 0
+        self.downloaded = 0
+        self.connection_type = "N/A"
+        self.error = None
+        
+        # Thread management
+        self.threads = []
+        self.lock = threading.Lock()
+        self.cancel_event = threading.Event()
+        self.part_files = []
+        
+        # Performance tracking
+        self._start_time = 0
+        self._last_update_time = 0
+        self._last_downloaded_bytes = 0
+        self._speed = 0
+
+    def _get_request_headers(self, add_range: Optional[str] = None) -> Dict[str, str]:
+        """Constructs request headers with optional auth and range."""
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if add_range:
+            headers['Range'] = add_range
+        return headers
+
+    @property
+    def is_cancelled(self) -> bool:
+        """Check if download has been cancelled."""
+        return self.cancel_event.is_set()
+
+    def cancel(self):
+        """Signal the download to cancel."""
+        if not self.is_cancelled:
+            print(f"[Downloader {self.download_id or 'N/A'}] Cancellation requested by user.")
+            self.cancel_event.set()
+            self.error = "Download cancelled by user"
+            if self.manager and self.download_id:
+                self.manager._update_download_status(self.download_id, status="cancelled", error=self.error)
+
+    def _cleanup_temp(self, success: bool):
+        """Remove temporary directory and potentially the output file."""
+        # Clean up temp directory
+        if self.temp_dir.exists():
+            try:
+                shutil.rmtree(self.temp_dir)
+            except Exception as e:
+                print(f"[Downloader {self.download_id}] Warning: Could not remove temp directory {self.temp_dir}: {e}")
+
+        # Remove output file if download failed
+        if not success and self.output_path.exists():
+            try:
+                self.output_path.unlink()
+                print(f"[Downloader {self.download_id}] Removed incomplete/failed output file: {self.output_path}")
+            except Exception as e:
+                print(f"[Downloader {self.download_id}] Warning: Could not remove incomplete output file {self.output_path}: {e}")
+
+    def _get_range_support_and_url(self) -> Tuple[str, bool]:
+        """Check for range support and get final URL after redirects."""
+        final_url = self.initial_url
+        supports_ranges = False
+        
+        try:
+            request_headers = self._get_request_headers()
+            
+            print(f"[Downloader {self.download_id}] Checking range support/redirects for: {self.initial_url} (Timeout: {self.HEAD_REQUEST_TIMEOUT}s)")
+            response = requests.head(
+                self.initial_url,
+                allow_redirects=True,
+                timeout=self.HEAD_REQUEST_TIMEOUT,
+                headers=request_headers
+            )
+            response.raise_for_status()
+
+            # Update URL after redirects
+            final_url = response.url
+            self.url = final_url
+
+            # Check range support
+            accept_ranges = response.headers.get('accept-ranges', 'none').lower()
+            supports_ranges = accept_ranges == 'bytes'
+
+            # Get file size if not already known
+            if self.total_size <= 0:
+                head_size = int(response.headers.get('Content-Length', 0))
+                if head_size > 0:
+                    self.total_size = head_size
+                    print(f"[Downloader {self.download_id}] Got file size from HEAD: {self.total_size} bytes")
+            
+            print(f"[Downloader {self.download_id}] HEAD Check OK - Final URL: {final_url}, Range Support: {supports_ranges}")
+            return final_url, supports_ranges
+            
+        except requests.exceptions.Timeout:
+            print(f"[Downloader {self.download_id}] Warning: HEAD request timed out. Proceeding with Single connection.")
+            return self.initial_url, False
+            
+        except requests.exceptions.RequestException as e:
+            http_error_details = ""
+            if hasattr(e, 'response') and e.response is not None:
+                status_code = e.response.status_code
+                http_error_details = f" (Status Code: {status_code})"
+            print(f"[Downloader {self.download_id}] Warning: HEAD request failed{http_error_details}. Proceeding with Single connection.")
+            return self.initial_url, False
+            
+        except Exception as e:
+            print(f"[Downloader {self.download_id}] Warning: Unexpected error during HEAD request: {e}. Proceeding with Single connection.")
+            return self.initial_url, False
+
+    def _update_progress(self, chunk_len: int):
+        """Thread-safe update of download progress and speed calculation."""
+        with self.lock:
+            self.downloaded += chunk_len
+            current_time = time.monotonic()
+            time_diff = current_time - self._last_update_time
+
+            # Update speed and notify manager periodically
+            if time_diff >= self.STATUS_UPDATE_INTERVAL or self.downloaded == self.total_size:
+                progress = min((self.downloaded / self.total_size) * 100, 100.0) if self.total_size > 0 else 0
+
+                # Calculate speed
+                if time_diff > 0:
+                    bytes_diff = self.downloaded - self._last_downloaded_bytes
+                    self._speed = bytes_diff / time_diff
+
+                self._last_update_time = current_time
+                self._last_downloaded_bytes = self.downloaded
+
+                if self.manager and self.download_id:
+                    self.manager._update_download_status(
+                        self.download_id,
+                        progress=progress,
+                        speed=self._speed,
+                        status="downloading"
+                    )
+
+    def download_segment(self, segment_index: int, start_byte: int, end_byte: int):
+        """Downloads a specific segment of the file."""
+        part_file_path = self.temp_dir / f"part_{segment_index}"
+        request_headers = self._get_request_headers(add_range=f'bytes={start_byte}-{end_byte}')
+        retries = 3
+        
+        for current_try in range(retries):
+            if self.is_cancelled:
+                print(f"[Downloader {self.download_id}] Segment {segment_index} cancelled before request (Try {current_try+1}).")
+                # Ensure error is set if not already
+                if not self.error: self.error = "Cancelled during segment download"
+                return 
+                
+            response = None
+            try:
+                response = requests.get(self.url, headers=request_headers, stream=True, timeout=self.DOWNLOAD_TIMEOUT)
+                response.raise_for_status()
+
+                bytes_written_this_segment = 0
+                with open(part_file_path, 'wb') as f:
+                    for chunk in response.iter_content(self.chunk_size):
+                        if self.is_cancelled:
+                            print(f"[Downloader {self.download_id}] Segment {segment_index} cancelled mid-stream.")
+                            # Ensure error is set if not already
+                            if not self.error: self.error = "Cancelled during segment download"
+                            
+                            
+                        if chunk:
+                            bytes_written = f.write(chunk)
+                            bytes_written_this_segment += bytes_written
+                            self._update_progress(bytes_written)
+
+                # Verify segment size
+                expected_size = (end_byte - start_byte) + 1
+                if bytes_written_this_segment != expected_size:
+                    if response:
+                        response.close()
+                    raise ValueError(f"Size mismatch. Expected {expected_size}, got {bytes_written_this_segment}")
+
+                return  # Success
+
+            
+            except (requests.exceptions.RequestException, ValueError) as e:
+                # Handle HTTP status codes
+                status_code = None
+                error_msg_detail = f"{e}"
+                
+                if isinstance(e, requests.exceptions.RequestException) and hasattr(e, 'response') and e.response is not None:
+                    status_code = e.response.status_code
+                    if status_code == 401: 
+                        error_msg_detail += " (Unauthorized)"
+                    elif status_code == 403: 
+                        error_msg_detail += " (Forbidden)"
+                    elif status_code == 416:
+                        error_msg_detail += " (Range Not Satisfiable)"
+                        self.error = f"Segment {segment_index} failed: {error_msg_detail}"
+                        self.cancel()
+                        return
+
+                print(f"[Downloader {self.download_id}] Warning: Segment {segment_index} failed (Try {current_try+1}/{retries}): {error_msg_detail}")
+                
+                if current_try >= retries - 1:  # Last attempt failed
+                    self.error = f"Segment {segment_index} failed after {retries} attempts: {error_msg_detail}"
+                    self.cancel()
+                    return
+                    
+                # Exponential backoff before retry
+                time.sleep(min(2 ** current_try, 10))
+                
+            except Exception as e:
+                self.error = f"Segment {segment_index} critical error: {e}"
+                print(f"[Downloader {self.download_id}] Error: {self.error}")
+                self.cancel()
+                return
+                
+            finally:
+                if response:
+                    response.close()
+
+    def merge_parts(self) -> bool:
+        """Merges all downloaded part files into the final output file."""
+        print(f"[Downloader {self.download_id}] Merging {len(self.part_files)} parts for {self.output_path.name}...")
+        
+        # Check if we have parts to merge
+        if not self.part_files:
+            if self.is_cancelled:
+                self.error = self.error or "Cancelled before any parts downloaded."
+            elif not self.error:
+                self.error = "No part files were created to merge."
+            print(f"[Downloader {self.download_id}] Error during merge: {self.error}")
+            return False
+            
+        try:
+            # Sort part files numerically
+            sorted_part_files = sorted(self.part_files, key=lambda p: int(p.name.split('_')[-1]))
+
+            with open(self.output_path, 'wb') as outfile:
+                for part_file in sorted_part_files:
+                    # Check if part exists
+                    if not part_file.exists():
+                        if self.is_cancelled:
+                            self.error = self.error or "Cancelled during download, a part file is missing."
+                        elif not self.error:
+                            self.error = f"Merge failed, required part file is missing: {part_file}."
+                        print(f"[Downloader {self.download_id}] Warning: Aborting merge. Missing part: {part_file.name}.")
+                        return False
+
+                    # Copy part data to output file
+                    try:
+                        with open(part_file, 'rb') as infile:
+                            shutil.copyfileobj(infile, outfile, length=1024*1024*2)  # 2MB buffer
+                    except Exception as copy_e:
+                        self.error = f"Error copying data from part {part_file.name} during merge: {copy_e}"
+                        print(f"[Downloader {self.download_id}] Error: {self.error}")
+                        return False
+
+            print(f"[Downloader {self.download_id}] Merging complete.")
+            
+            # Verify final file size
+            final_size = self.output_path.stat().st_size
+            if self.total_size > 0 and abs(final_size - self.total_size) > 1:
+                self.error = f"Merged size ({final_size}) differs significantly from expected ({self.total_size}). File may be corrupt."
+                print(f"[Downloader {self.download_id}] Error: {self.error}")
+                return False
+            elif self.total_size > 0 and final_size != self.total_size:
+                print(f"[Downloader {self.download_id}] Warning: Final merged size ({final_size}) differs slightly from expected ({self.total_size}).")
+
+            return True
+
+        except Exception as e:
+            self.error = f"Failed to merge parts: {e}"
+            print(f"[Downloader {self.download_id}] Error: {self.error}")
+            return False
+
+    def fallback_download(self) -> bool:
+        """Fallback to standard single-connection download."""
+        self.connection_type = "Single"
+        if self.manager and self.download_id:
+            self.manager._update_download_status(self.download_id, connection_type=self.connection_type, status="downloading")
+
+        print(f"[Downloader {self.download_id}] Using standard single-connection download for {self.output_path.name}...")
+        
+        self._start_time = self._start_time or time.monotonic()
+        self._last_update_time = self._start_time
+        self._last_downloaded_bytes = 0
+        self.downloaded = 0
+        
+        response = None
+        
+        try:
+            request_headers = self._get_request_headers()
+            response = requests.get(self.url, stream=True, timeout=self.DOWNLOAD_TIMEOUT, 
+                                    allow_redirects=True, headers=request_headers)
+            response.raise_for_status()
+
+            # Update URL after potential redirects
+            final_get_url = response.url
+            if final_get_url != self.url:
+                print(f"[Downloader {self.download_id}] URL redirected during GET to: {final_get_url}")
+                self.url = final_get_url
+
+            # Get/confirm file size
+            if self.total_size <= 0:
+                get_size = int(response.headers.get('Content-Length', 0))
+                if get_size > 0:
+                    self.total_size = get_size
+                    print(f"[Downloader {self.download_id}] Obtained file size via fallback GET: {self.total_size}")
+                else:
+                    print(f"[Downloader {self.download_id}] Warning: File size unknown. Progress may be inaccurate.")
+
+            # Ensure output directory exists
+            self.output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(self.output_path, 'wb') as f:
+                for chunk in response.iter_content(self.chunk_size):
+                    if self.is_cancelled:
+                        print(f"[Downloader {self.download_id}] Fallback download cancelled.")
+                        return False
+                    if chunk:
+                        bytes_written = f.write(chunk)
+                        self._update_progress(bytes_written)
+
+                    
+
+            # Verify download size if known
+            if self.total_size > 0 and self.downloaded != self.total_size and not self.error:
+                print(f"[Downloader {self.download_id}] Warning: Size mismatch. Expected {self.total_size}, got {self.downloaded}.")
+
+            print(f"[Downloader {self.download_id}] Fallback download completed.")
+            return not self.error
+
+        except requests.exceptions.RequestException as e:
+            error_msg_detail = f"{e}"
+            if hasattr(e, 'response') and e.response is not None:
+                status_code = e.response.status_code
+                if status_code == 401: 
+                    error_msg_detail += " (Unauthorized - Check API Key?)"
+                elif status_code == 403: 
+                    error_msg_detail += " (Forbidden - Permissions Issue?)"
+            
+            if not self.error:
+                self.error = f"Fallback download failed: {error_msg_detail}"
+            print(f"[Downloader {self.download_id}] Error during fallback download: {self.error}")
+            return False
+            
+        except Exception as e:
+            if not self.error:
+                self.error = f"Fallback download failed: {e}"
+            print(f"[Downloader {self.download_id}] Error during fallback download: {self.error}")
+            return False
+            
+        finally:
+            if response:
+                response.close()
+
+    def download(self) -> bool:
+        """Main download method that chooses between multi-connection or fallback approach."""
+        self._start_time = time.monotonic()
+        self.downloaded = 0
+        self.error = None
+        self.threads = []
+        self.part_files = []
+        success = False
+
+        # Clean up any existing temp directory
+        if self.temp_dir.exists():
+            print(f"[Downloader {self.download_id}] Warning: Removing leftover temp directory: {self.temp_dir}")
+            self._cleanup_temp(success=False)
+
+        # Check range support and get final URL
+        final_url, supports_ranges = self._get_range_support_and_url()
+        
+        # Decide on download strategy
+        use_multi_connection = False
+        if supports_ranges and self.num_connections > 1 and self.total_size > 0:
+            if self.total_size > self.MIN_SIZE_FOR_MULTI_MB * 1024 * 1024:
+                use_multi_connection = True
+            else:
+                print(f"[Downloader {self.download_id}] File size ({self.total_size / (1024*1024):.2f} MB) below threshold for multi-connection.")
+        
+        expected_final_size = self.total_size
+
+        try:
+            if use_multi_connection:
+                # Multi-connection download approach
+                success = self._do_multi_connection_download()
+            else:
+                # Single connection fallback
+                reason = "Range requests not supported" if not supports_ranges else \
+                         "Single connection requested" if self.num_connections <= 1 else \
+                         "File size unknown or too small"
+                print(f"[Downloader {self.download_id}] ({reason}). Using fallback single-connection download.")
+                success = self.fallback_download()
+                expected_final_size = self.total_size
+                
+                if not success and not self.error:
+                    self.error = "Single connection download failed."
+
+        except KeyboardInterrupt:
+            print(f"[Downloader {self.download_id}] Interrupted! Signalling cancellation.")
+            self.cancel()
+            if not self.error: 
+                self.error = "Download interrupted by user."
+            success = False
+            
+        except Exception as e:
+            import traceback
+            print(f"--- Critical Error in Download {self.download_id} ('{self.output_path.name}') ---")
+            traceback.print_exc()
+            print("--- End Error ---")
+            
+            if not self.error:
+                self.error = f"Unexpected download error: {str(e)}"
+            
+            success = False
+            if not self.is_cancelled: 
+                self.cancel()
+
+        finally:
+            # Cleanup and final status update
+            self._cleanup_temp(success=success and not self.is_cancelled and not self.error)
+
+            if self.manager and self.download_id:
+                final_status = "completed" if success else ("cancelled" if self.is_cancelled else "failed")
+                final_progress = 100.0 if success else ((self.downloaded / self.total_size * 100) if self.total_size > 0 else 0)
+                
+                self.manager._update_download_status(
+                    self.download_id,
+                    status=final_status,
+                    progress=min(100.0, final_progress),
+                    speed=0,
+                    error=self.error,
+                    connection_type=self.connection_type
+                )
+
+        return success and not self.error and not self.is_cancelled
+
+    def _do_multi_connection_download(self) -> bool:
+        """Handle multi-connection download process."""
+        self.connection_type = f"Multi ({self.num_connections})"
+        if self.manager and self.download_id:
+            self.manager._update_download_status(self.download_id, connection_type=self.connection_type, status="downloading")
+
+        print(f"[Downloader {self.download_id}] Starting multi-connection download for {self.output_path.name} "
+              f"({self.total_size / (1024 * 1024):.2f} MB) using {self.num_connections} connections.")
+
+        # Create temp directory
+        try:
+            if self.temp_dir.exists(): 
+                shutil.rmtree(self.temp_dir)
+            self.temp_dir.mkdir(parents=True)
+        except Exception as e:
+            self.error = f"Failed to create temp directory: {e}"
+            print(f"[Downloader {self.download_id}] Error: {self.error}")
+            return False
+
+        # Calculate segments
+        segment_size = self.total_size // self.num_connections
+        
+        # Handle small files with many connections
+        if segment_size == 0 and self.total_size > 0:
+            segment_size = self.total_size // min(self.num_connections, self.total_size) if self.total_size >= self.num_connections else self.total_size
+            if segment_size == 0:
+                segment_size = self.total_size
+                self.num_connections = 1
+                print(f"[Downloader {self.download_id}] Warning: Forcing single connection for very small file.")
+                return self.fallback_download()
+
+        # Create segments
+        segments = []
+        current_byte = 0
+        for i in range(self.num_connections):
+            if current_byte >= self.total_size: 
+                break
+                
+            start_byte = current_byte
+            end_byte = min(current_byte + segment_size - 1, self.total_size - 1)
+            
+            # Ensure last segment goes to the end
+            if i == self.num_connections - 1:
+                end_byte = self.total_size - 1
+
+            # Ensure segment is valid
+            if start_byte <= end_byte < self.total_size:
+                segments.append((i, start_byte, end_byte))
+                self.part_files.append(self.temp_dir / f"part_{i}")
+            else:
+                print(f"[Downloader {self.download_id}] Warning: Skipping invalid segment {i}, start={start_byte}, end={end_byte}")
+            
+            current_byte = end_byte + 1
+
+        if not segments:
+            self.error = f"No valid download segments calculated (Total Size: {self.total_size})."
+            print(f"[Downloader {self.download_id}] Error: {self.error}")
+            return False
+
+        # Start download threads
+        for index, start, end in segments:
+            if self.is_cancelled: 
+                break
+            thread = threading.Thread(target=self.download_segment, args=(index, start, end), daemon=True)
+            self.threads.append(thread)
+            thread.start()
+
+        # Wait for threads to complete
+        active_threads = list(self.threads)
+        while active_threads and not self.is_cancelled:
+            joined_threads = []
+            for t in active_threads:
+                t.join(timeout=0.2)
+                if not t.is_alive():
+                    joined_threads.append(t)
+            
+            active_threads = [t for t in active_threads if t not in joined_threads]
+
+        # Handle download completion
+        if self.is_cancelled:
+            print(f"[Downloader {self.download_id}] Download stopped (cancelled).")
+            self.error = self.error or "Download cancelled."
+            return False
+        elif self.error:
+            print(f"[Downloader {self.download_id}] Download stopped (error): {self.error}")
+            return False
+        elif self.total_size > 0 and self.downloaded != self.total_size:
+            self.error = f"Multi-download size mismatch. Expected {self.total_size}, got {self.downloaded}."
+            print(f"[Downloader {self.download_id}] Error: {self.error}")
+            return False
+
+        # Merge parts
+        return self.merge_parts()

custom_nodes/Civicomfy/downloader/manager.py

@@ -0,0 +1,929 @@
+# ================================================
+# File: downloader/manager.py
+# ================================================
+import threading
+import time
+import datetime
+import os
+import json                     
+import requests
+import subprocess
+import platform
+import sys
+from typing import List, Dict, Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .chunk_downloader import ChunkDownloader
+
+from ..config import (
+    MAX_CONCURRENT_DOWNLOADS, DOWNLOAD_HISTORY_LIMIT, DEFAULT_CONNECTIONS,
+    METADATA_SUFFIX, PREVIEW_SUFFIX, METADATA_DOWNLOAD_TIMEOUT, PLUGIN_ROOT 
+)
+try:
+    from folder_paths import get_directory_by_type, get_valid_path, base_path
+    COMFY_PATHS_AVAILABLE = True
+except ImportError:
+    print("[Civicomfy Manager] Warning: ComfyUI folder_paths not available. Path validation/opening might be limited.")
+    COMFY_PATHS_AVAILABLE = False
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+
+# --- Define History File Path ---
+# Place it in the root of the extension directory
+HISTORY_FILE_PATH = os.path.join(PLUGIN_ROOT, "download_history.json")
+
+class DownloadManager:
+    """Manages a queue of downloads, running them concurrently and saving metadata."""
+
+    def __init__(self, max_concurrent: int = MAX_CONCURRENT_DOWNLOADS):
+        self.queue: List[Dict[str, Any]] = []
+        self.active_downloads: Dict[str, Dict[str, Any]] = {} # {download_id: download_info}
+        # History now stores more complete dictionaries for retry functionality
+        self.history: List[Dict[str, Any]] = []
+        self.lock: threading.Lock = threading.Lock()
+        self.max_concurrent: int = max(1, max_concurrent)
+        self.running: bool = True
+        self._load_history_from_file()
+        self._process_thread: threading.Thread = threading.Thread(target=self._process_queue, daemon=True)
+        print(f"Civitai Download Manager starting (Max Concurrent: {self.max_concurrent}).")
+        self._process_thread.start()
+
+    # --- add_to_queue remains largely the same, ensuring all necessary fields are initialized ---
+    def add_to_queue(self, download_info: Dict[str, Any]) -> str:
+        """Adds a download task to the queue."""
+        with self.lock:
+            # Generate a unique ID
+            timestamp = int(time.time() * 1000)
+            file_hint = os.path.basename(download_info.get('output_path', 'file'))[:10]
+            unique_num = sum(1 for item in self.queue if file_hint in item.get("id", "") or any(file_hint in h.get("id","") for h in self.history)) # Check history too
+            download_id = f"dl_{timestamp}_{unique_num}_{file_hint}"
+
+            # Set initial status and info
+            download_info["id"] = download_id
+            download_info["status"] = "queued"
+            download_info["added_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+            download_info["progress"] = 0
+            download_info["speed"] = 0
+            download_info["error"] = None
+            download_info["start_time"] = None
+            download_info["end_time"] = None
+            download_info["connection_type"] = "N/A"
+
+            # --- Ensure all fields potentially needed for retry exist ---
+            # (Most were likely already filled by the calling route, but double-check)
+            required_for_retry = [
+                'url', 'output_path', 'num_connections', 'api_key', 'known_size',
+                'civitai_model_info', 'civitai_version_info', 'civitai_primary_file',
+                'thumbnail', 'filename', 'model_url_or_id', 'model_version_id', 'model_type',
+                'custom_filename', 'force_redownload' # Add force_redownload too
+            ]
+            for key in required_for_retry:
+                if key not in download_info:
+                    # Add default or None if missing. More robust handling might be needed
+                    # depending on how routes.py prepares the dict.
+                    if key in ['civitai_model_info', 'civitai_version_info', 'civitai_primary_file']:
+                        download_info[key] = {}
+                    elif key == 'num_connections':
+                        download_info[key] = DEFAULT_CONNECTIONS
+                    elif key == 'force_redownload':
+                        download_info[key] = False # Default for new downloads
+                    else:
+                        download_info[key] = None
+                    print(f"[Manager Warning] Queued item '{download_id}' missing '{key}', added default.")
+
+            self.queue.append(download_info)
+            print(f"[Manager] Queued: {download_info.get('filename', 'N/A')} (ID: {download_id}, Size: {download_info.get('known_size', 'Unknown')})")
+            return download_id
+
+    # --- cancel_download remains the same ---
+    def cancel_download(self, download_id: str) -> bool:
+        """Requests cancellation of a queued or active download."""
+        # ... (no changes needed here) ...
+        print(f"[Manager] Received cancellation request for: {download_id}") # Moved print earlier
+        downloader_to_cancel: Optional['ChunkDownloader'] = None
+        found_in_active = False
+
+        with self.lock:
+            # 1. Check queue first (can be fully handled under lock)
+            for i, item in enumerate(self.queue):
+                if item["id"] == download_id:
+                    cancelled_info = self.queue.pop(i)
+                    cancelled_info["status"] = "cancelled"
+                    cancelled_info["end_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+                    cancelled_info["error"] = "Cancelled from queue"
+                    self._add_to_history(cancelled_info) # _add_to_history is safe under lock
+                    print(f"[Manager] Cancelled queued download: {download_id}")
+                    return True # Cancelled from queue, we are done
+
+            # 2. Check active downloads - Find the instance *under lock*
+            if download_id in self.active_downloads:
+                found_in_active = True
+                active_info = self.active_downloads[download_id]
+                downloader_to_cancel = active_info.get("downloader_instance")
+                current_status = active_info.get("status")
+
+                # If downloader instance doesn't exist yet (status 'starting')
+                # or if already terminal, handle it here under lock
+                if not downloader_to_cancel and current_status == "starting":
+                    print(f"[Manager] Marking 'starting' download as cancelled: {download_id}")
+                    # Mark as cancelled, it won't start or will be caught by wrapper
+                    active_info["status"] = "cancelled"
+                    if not active_info.get("end_time"):
+                        active_info["end_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+                    active_info["error"] = "Cancelled before download thread fully started"
+                    # Don't assign downloader_to_cancel, let process_queue clean it up
+                    downloader_to_cancel = None # Explicitly clear
+                    # Indicate we handled it (or attempted to)
+                    return True # Exit, processed within lock
+                elif current_status in ["completed", "failed", "cancelled"]:
+                    print(f"[Manager] Download {download_id} is already in terminal state '{current_status}'. Cannot cancel.")
+                    # Indicate we don't need to proceed further outside the lock
+                    downloader_to_cancel = None # Explicitly clear
+                    return False # Already finished/cancelled
+
+                # If we found an instance and it's potentially running,
+                # store it to call cancel *after* releasing the lock.
+                print(f"[Manager] Found active downloader instance for {download_id}. Will signal outside lock.")
+
+            # Lock is released automatically here when exiting 'with'
+
+        # 3. Signal the downloader instance *outside* the lock
+        if downloader_to_cancel:
+            try:
+                # Check if already cancelled (to avoid duplicate logs/actions) - This check is thread-safe
+                if not downloader_to_cancel.is_cancelled:
+                    print(f"[Manager] Calling downloader.cancel() for {download_id}")
+                    downloader_to_cancel.cancel() # This can now call _update_download_status safely
+                    print(f"[Manager] Signalled downloader.cancel() for {download_id}")
+                    # Let the download thread's final status update handle moving to history
+                    return True # Signal sent
+                else:
+                    print(f"[Manager] Active download {download_id} was already cancelling.")
+                    return True # Already in cancelling state is considered a success here
+            except Exception as e:
+                print(f"[Manager] Error calling downloader.cancel() for {download_id}: {e}")
+                # Update status to failed maybe? Or just log.
+                # Use _update_download_status directly here as we are outside the lock
+                self._update_download_status(download_id, status="failed", error=f"Error during cancel signaling: {e}")
+                return False # Failed to signal
+
+        # 4. Handle cases where it wasn't in queue and wasn't running/starting
+        if not found_in_active:
+            print(f"[Manager] Could not cancel - ID not found in queue or active: {download_id}")
+            return False # Not found
+
+        # It was found in active but was already terminal or couldn't be signalled
+        # Return value determined above
+        return False # Should have returned True earlier if successful
+
+    # --- get_status remains the same (still strips data for UI) ---
+    def get_status(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Returns the current state of the queue, active downloads, and history.
+           Strips sensitive/large data for UI efficiency."""
+        with self.lock:
+            # Fields to exclude when sending status to UI
+            exclude_fields_for_ui = [
+                'downloader_instance', 'civitai_model_info', 'civitai_version_info',
+                'api_key', # Don't send API key to frontend status
+                # Large potentially redundant fields:
+                'url', 'output_path', 'custom_filename', 'model_url_or_id',
+                # Keep 'thumbnail', 'filename', 'model_name', 'version_name' etc for display
+            ]
+
+            # Prepare active downloads list
+            active_list = [
+                {k: v for k, v in item_data.items() if k not in exclude_fields_for_ui}
+                for item_id, item_data in self.active_downloads.items()
+            ]
+
+            # Prepare history list similarly
+            history_list = [
+                {k: v for k, v in item_data.items() if k not in exclude_fields_for_ui}
+                for item_data in self.history[:DOWNLOAD_HISTORY_LIMIT]
+            ]
+
+            # Return copies
+            return {
+                "queue": [
+                    {k:v for k,v in item.items() if k not in exclude_fields_for_ui}
+                    for item in self.queue
+                ],
+                "active": active_list,
+                "history": history_list,
+            }
+
+    def _load_history_from_file(self):
+        """Loads download history from the JSON file."""
+        # No lock needed here as it's called during __init__ before the thread starts
+        if not os.path.exists(HISTORY_FILE_PATH):
+            print(f"[Manager] History file not found ({HISTORY_FILE_PATH}). Starting with empty history.")
+            self.history = []
+            return
+
+        try:
+            with open(HISTORY_FILE_PATH, 'r', encoding='utf-8') as f:
+                loaded_data = json.load(f)
+
+            if isinstance(loaded_data, list):
+                # Basic validation: Ensure items have IDs (optional but good)
+                validated_history = [item for item in loaded_data if isinstance(item, dict) and 'id' in item]
+                invalid_count = len(loaded_data) - len(validated_history)
+                if invalid_count > 0:
+                    print(f"[Manager Warning] {invalid_count} items removed from loaded history due to missing 'id'.")
+
+                # Ensure history limit
+                self.history = validated_history[:DOWNLOAD_HISTORY_LIMIT]
+                print(f"[Manager] Successfully loaded {len(self.history)} items from {HISTORY_FILE_PATH}.")
+            else:
+                print(f"[Manager Warning] History file ({HISTORY_FILE_PATH}) contained invalid data (not a list). Starting fresh.")
+                self.history = []
+                # Optionally try to delete the corrupted file?
+                # try: os.remove(HISTORY_FILE_PATH) except Exception: pass
+
+        except json.JSONDecodeError as e:
+             print(f"[Manager Error] Failed to parse history file ({HISTORY_FILE_PATH}): {e}. Starting fresh.")
+             self.history = []
+             # Optionally try to delete the corrupted file?
+        except Exception as e:
+            print(f"[Manager Error] Failed to read history file ({HISTORY_FILE_PATH}): {e}. Starting fresh.")
+            self.history = []
+
+    # --- Save History Method ---
+    def _save_history_to_file(self):
+        """Saves the current in-memory history list to the JSON file."""
+        # Assumes self.lock is HELD when this is called
+        history_to_save = self.history[:DOWNLOAD_HISTORY_LIMIT] # Ensure limit before saving
+
+        try:
+            # Ensure directory exists (should already, but belt-and-suspenders)
+            os.makedirs(os.path.dirname(HISTORY_FILE_PATH), exist_ok=True)
+
+            # Write atomically (write to temp then rename) to reduce corruption risk
+            temp_file_path = HISTORY_FILE_PATH + ".tmp"
+            with open(temp_file_path, 'w', encoding='utf-8') as f:
+                json.dump(history_to_save, f, indent=2, ensure_ascii=False) # Pretty print
+
+            os.replace(temp_file_path, HISTORY_FILE_PATH) # Atomic rename/replace
+            # print(f"[Manager] Saved {len(history_to_save)} items to history file.") # Can be noisy
+
+        except Exception as e:
+             # Log error, but don't crash the manager
+             print(f"[Manager Error] Failed to save history file ({HISTORY_FILE_PATH}): {e}")
+             # Attempt to remove temp file if it exists
+             if os.path.exists(temp_file_path):
+                  try: os.remove(temp_file_path)
+                  except Exception: pass
+
+    # --- Updated _add_to_history Method ---
+    def _add_to_history(self, download_info: Dict[str, Any]):
+        """Adds a completed/failed/cancelled item to history (internal).
+           Stores most original parameters needed for potential retry.
+           NOW ALSO TRIGGERS SAVING HISTORY TO FILE."""
+        # --- (Keep existing logic to prepare info_copy) ---
+        info_copy = {
+            k: v for k, v in download_info.items()
+            if k not in ['downloader_instance']
+        }
+        if "end_time" not in info_copy or info_copy["end_time"] is None:
+             info_copy["end_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        if "status" not in info_copy:
+             info_copy["status"] = "unknown"
+        if info_copy["status"] != "completed" and not info_copy.get("error"):
+            info_copy["error"] = f"Finished with status '{info_copy['status']}' but no error recorded."
+
+        # --- Update in-memory history ---
+        self.history.insert(0, info_copy) # Prepend
+        # Trim in-memory list (save will also respect limit)
+        if len(self.history) > DOWNLOAD_HISTORY_LIMIT:
+            self.history = self.history[:DOWNLOAD_HISTORY_LIMIT]
+
+        # --- Trigger Save to File (still under lock) ---
+        self._save_history_to_file() # <--- Added call
+
+    # --- Updated clear_history Method ---
+    def clear_history(self) -> Dict[str, Any]:
+        """Clears the download history (in-memory and the JSON file)."""
+        cleared_count = 0
+        file_deleted = False
+        error_msg = None
+
+        try:
+            with self.lock:
+                cleared_count = len(self.history)
+                if cleared_count > 0:
+                    print(f"[Manager] Clearing {cleared_count} items from in-memory history.")
+                    self.history = [] # Clear memory list first
+
+                    # Attempt to delete the history file
+                    if os.path.exists(HISTORY_FILE_PATH):
+                        try:
+                            os.remove(HISTORY_FILE_PATH)
+                            file_deleted = True
+                            print(f"[Manager] Deleted history file: {HISTORY_FILE_PATH}")
+                        except OSError as e:
+                            error_msg = f"Failed to delete history file {HISTORY_FILE_PATH}: {e}"
+                            print(f"[Manager Error] {error_msg}")
+                    else:
+                        print(f"[Manager] History file ({HISTORY_FILE_PATH}) did not exist, nothing to delete.")
+                        file_deleted = True # Consider success if file wasn't there anyway
+
+                else:
+                    print("[Manager] History clear request received, but history was already empty.")
+                    # Should we still check/delete the file just in case? Yes.
+                    if os.path.exists(HISTORY_FILE_PATH):
+                        try:
+                            os.remove(HISTORY_FILE_PATH)
+                            file_deleted = True
+                            print(f"[Manager] Deleted potentially orphaned history file: {HISTORY_FILE_PATH}")
+                        except OSError as e:
+                             error_msg = f"Failed to delete potentially orphaned history file {HISTORY_FILE_PATH}: {e}"
+                             print(f"[Manager Error] {error_msg}")
+                    else:
+                        file_deleted = True # Success if clear requested and neither memory/file had anything
+
+            if error_msg:
+                 return {"success": False, "error": f"History cleared from memory, but could not delete file: {error_msg}"}
+            elif cleared_count > 0:
+                 return {"success": True, "message": f"Cleared {cleared_count} history items (memory and file)."}
+            else:
+                 # If count was 0 but file deletion was attempted/succeeded
+                 return {"success": True, "message": "History was already empty."}
+
+        except Exception as e:
+            print(f"[Manager] Critical error during clear_history: {e}")
+            import traceback
+            traceback.print_exc()
+            return {"success": False, "error": f"Failed to clear history due to unexpected error: {e}"}
+        
+    # --- _process_queue remains the same ---
+    def _process_queue(self):
+        """Internal thread function to manage downloads."""
+        # ... (no changes needed here) ...
+        print("[Manager] Process queue thread started.")
+        while self.running:
+            processed_something = False
+            with self.lock:
+                # 1. Check for finished/failed/cancelled active downloads to move to history
+                finished_ids = [
+                    dl_id for dl_id, info in self.active_downloads.items()
+                    if info.get("status") in ["completed", "failed", "cancelled"] # Use .get() for safety
+                ]
+                for dl_id in finished_ids:
+                    # Check if still in active_downloads before popping (might have been removed by another thread edge case?)
+                    if dl_id in self.active_downloads:
+                        finished_info = self.active_downloads.pop(dl_id)
+                        self._add_to_history(finished_info) # Will now store more data
+                        print(f"[Manager] Moved '{finished_info.get('filename', dl_id)}' to history (Status: {finished_info['status']})")
+                        processed_something = True
+                    else:
+                         print(f"[Manager] Warning: Item {dl_id} intended for history was already removed from active list.")
+
+                # 2. Start new downloads if slots available and queue has items
+                while len(self.active_downloads) < self.max_concurrent and self.queue:
+                    download_info = self.queue.pop(0)
+                    download_id = download_info["id"]
+
+                     # Double check if cancelled just before starting
+                    if download_info["status"] == "cancelled":
+                        # Ensure it has an end time before adding to history
+                        if not download_info.get("end_time"):
+                             download_info["end_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+                        self._add_to_history(download_info)
+                        print(f"[Manager] Skipping cancelled item from queue: {download_id}")
+                        processed_something = True
+                        continue
+
+                    # Update status to 'starting'
+                    download_info["status"] = "starting"
+                    download_info["start_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+                    download_info["downloader_instance"] = None # Placeholder
+
+                    # Add to active downloads BEFORE starting thread
+                    self.active_downloads[download_id] = download_info
+
+                    # Start download in a separate thread
+                    thread = threading.Thread(
+                        target=self._download_file_wrapper,
+                        args=(download_info,),
+                        daemon=True # Ensure thread exits if main program exits
+                    )
+                    thread.start()
+                    print(f"[Manager] Starting download thread for: {download_info.get('filename', 'N/A')} ({download_id})")
+                    processed_something = True
+
+            # Sleep only if nothing was processed to avoid busy-waiting
+            if not processed_something:
+                time.sleep(0.5) # Small delay before checking again
+
+        print("[Manager] Process queue thread stopped.")
+
+   # --- _update_download_status remains the same ---
+    def _update_download_status(self, download_id: str, status: Optional[str] = None,
+                                progress: Optional[float] = None, speed: Optional[float] = None,
+                                error: Optional[str] = None, connection_type: Optional[str] = None):
+        """Safely updates the status fields of an active download (thread-safe)."""
+        # ... (no changes needed here) ...
+        with self.lock:
+            if download_id in self.active_downloads:
+                item = self.active_downloads[download_id]
+                updated = False # Track if any field was actually updated
+                # Only update if value is provided
+                if status is not None and item.get("status") != status:
+                    item["status"] = status
+                    updated = True
+                    # If status becomes terminal, record end time
+                    if status in ["completed", "failed", "cancelled"] and not item.get("end_time"):
+                        item["end_time"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+                if progress is not None:
+                    # Clamp progress between 0 and 100
+                    clamped_progress = max(0.0, min(100.0, progress))
+                    # Only update if different enough to avoid excessive updates
+                    if abs(item.get("progress", 0) - clamped_progress) > 0.01:
+                         item["progress"] = clamped_progress
+                         updated = True
+                if speed is not None:
+                    clamped_speed = max(0.0, speed) # Speed cannot be negative
+                    if item.get("speed") != clamped_speed: # Update if different
+                         item["speed"] = clamped_speed
+                         updated = True
+                if error is not None and item.get("error") != error:
+                    # Update error only if it's new or different
+                    item["error"] = str(error)[:500] # Limit length
+                    updated = True
+                if connection_type is not None and connection_type != "N/A" and item.get("connection_type") != connection_type: # Only update if not N/A and different
+                    item["connection_type"] = connection_type
+                    updated = True
+
+    # --- _save_civitai_metadata remains the same ---
+    def _save_civitai_metadata(self, download_info: Dict[str, Any]):
+        """Saves the .cminfo.json file."""
+        # ... (no changes needed here) ...
+        output_path = download_info.get('output_path')
+        model_info = download_info.get('civitai_model_info', {})
+        version_info = download_info.get('civitai_version_info', {})
+        primary_file = download_info.get('civitai_primary_file', {})
+        download_id = download_info.get('id', 'unknown')
+
+        try:
+            file_meta = primary_file.get('metadata', {}) or {} # Ensure dict
+            creator_info = model_info.get('creator', {}) or {}
+            model_stats = model_info.get('stats', {}) or {}
+            version_stats = version_info.get('stats', {}) or {}
+
+            metadata = {
+                "ModelId": model_info.get('id', version_info.get('modelId')) , # Use .get() on version info too
+                "ModelName": model_info.get('name', version_info.get('model',{}).get('name')), # Nested .get()
+                "ModelDescription": model_info.get('description'),
+                "CreatorUsername": creator_info.get('username'),
+                "Nsfw": model_info.get('nsfw', version_info.get('model',{}).get('nsfw')),
+                "Poi": model_info.get('poi', version_info.get('model',{}).get('poi')),
+                "AllowNoCredit": model_info.get('allowNoCredit', True),
+                "AllowCommercialUse": str(model_info.get('allowCommercialUse', 'Unknown')), # Ensure string
+                "AllowDerivatives": model_info.get('allowDerivatives', True),
+                "AllowDifferentLicense": model_info.get('allowDifferentLicense', True),
+                "Tags": model_info.get('tags', []),
+                "ModelType": model_info.get('type'),
+                "VersionId": version_info.get('id'),
+                "VersionName": version_info.get('name'),
+                "VersionDescription": version_info.get('description'),
+                "BaseModel": version_info.get('baseModel'),
+                "BaseModelType": version_info.get('baseModelType'),
+                "EarlyAccessDeadline": version_info.get('earlyAccessDeadline'),
+                "VersionPublishedAt": version_info.get('publishedAt'),
+                "VersionUpdatedAt": version_info.get('updatedAt'),
+                "VersionStatus": version_info.get('status'),
+                "IsPrimaryFile": primary_file.get('primary', False),
+                "PrimaryFileId": primary_file.get('id'),
+                "PrimaryFileName": primary_file.get('name'),
+                "FileMetadata": {
+                    "fp": file_meta.get('fp'),
+                    "size": file_meta.get('size'),
+                    "format": file_meta.get('format', 'Unknown')
+                },
+                "ImportedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                "Hashes": primary_file.get('hashes', {}),
+                "TrainedWords": version_info.get('trainedWords', []),
+                "Stats": {
+                    "downloadCount": version_stats.get('downloadCount', model_stats.get('downloadCount', 0)),
+                    "rating": version_stats.get('rating', model_stats.get('rating', 0)),
+                    "ratingCount": version_stats.get('ratingCount', model_stats.get('ratingCount', 0)),
+                    "favoriteCount": version_stats.get('favoriteCount', model_stats.get('favoriteCount', 0)), # Correct source needed? Check API docs
+                    "commentCount": version_stats.get('commentCount', model_stats.get('commentCount', 0)), # Correct source needed? Check API docs
+                    "thumbsUpCount": version_stats.get('thumbsUpCount', 0),
+                 },
+                 "DownloadUrlUsed": download_info.get('url'),
+            }
+
+            base, _ = os.path.splitext(output_path)
+            meta_filename = base + METADATA_SUFFIX
+            meta_path = os.path.join(os.path.dirname(output_path), meta_filename)
+
+            print(f"[Manager Meta {download_id}] Saving metadata to: {meta_path}")
+            with open(meta_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+            print(f"[Manager Meta {download_id}] Metadata saved successfully.")
+
+        except Exception as e:
+            import traceback
+            print(f"[Manager Meta {download_id}] Error saving metadata file {meta_path}: {e}")
+            # traceback.print_exc() # Uncomment for full trace
+
+    # --- _download_and_save_preview remains the same ---
+    def _download_and_save_preview(self, download_info: Dict[str, Any]):
+        """Downloads and saves the .preview.jpeg file."""
+        # ... (no changes needed here) ...
+        output_path = download_info.get('output_path')
+        thumbnail_url = download_info.get('thumbnail')
+        api_key = download_info.get('api_key')
+        download_id = download_info.get('id', 'unknown')
+
+        if not output_path:
+             print(f"[Manager Preview {download_id}] Skipping preview download: Missing output path.")
+             return
+        if not thumbnail_url:
+             print(f"[Manager Preview {download_id}] Skipping preview download: No thumbnail URL provided.")
+            # Optionally try to find one in version_info images again? Might be redundant.
+             version_info = download_info.get('civitai_version_info', {})
+             if version_info and isinstance(version_info.get('images'), list) and version_info['images']:
+                  sorted_images = sorted([img for img in version_info['images'] if img and img.get("url")], key=lambda x: x.get('index', 0))
+                  img_data = next((img for img in sorted_images if img.get("type") == "image" and "/width=" in img.get("url","")), None) # Prefer image type with width param
+                  if not img_data: img_data = next((img for img in sorted_images if img.get("type") == "image"), None) # Fallback to any image type
+                  if not img_data: img_data = next((img for img in sorted_images), None) # Fallback to any image at all
+                  if img_data and img_data.get('url'):
+                       thumbnail_url = img_data['url']
+                       # Attempt to get a reasonable size (e.g. ~450px width)
+                       if "/width=" in thumbnail_url:
+                            thumbnail_url = thumbnail_url.split("/width=")[0] + "/width=450"
+                       elif "/blob/" not in thumbnail_url: # Avoid adding params to blob URLs
+                           separator = "&" if "?" in thumbnail_url else "?"
+                           thumbnail_url += f"{separator}width=450"
+                       print(f"[Manager Preview {download_id}] Found alternative thumbnail URL: {thumbnail_url}")
+                  else:
+                      print(f"[Manager Preview {download_id}] Still no thumbnail URL found in version info.")
+                      return # Exit if still no URL
+             else:
+                 return # Exit if no URL and no version info to search
+
+        base, _ = os.path.splitext(output_path)
+        preview_filename = base + PREVIEW_SUFFIX
+        preview_path = os.path.join(os.path.dirname(output_path), preview_filename)
+
+        print(f"[Manager Preview {download_id}] Downloading thumbnail from {thumbnail_url} to {preview_path}")
+        response = None
+        try:
+            headers = {}
+            if api_key: headers["Authorization"] = f"Bearer {api_key}"
+            response = requests.get(thumbnail_url, stream=True, headers=headers, timeout=METADATA_DOWNLOAD_TIMEOUT, allow_redirects=True)
+            response.raise_for_status()
+            content_type = response.headers.get('Content-Type', '').lower()
+            if not content_type.startswith('image/'):
+                 print(f"[Manager Preview {download_id}] Warning: Thumbnail URL returned non-image content type '{content_type}'. Skipping save.")
+                 return
+            with open(preview_path, 'wb') as f:
+                 for chunk in response.iter_content(chunk_size=8192): f.write(chunk)
+            print(f"[Manager Preview {download_id}] Thumbnail downloaded successfully.")
+        except requests.exceptions.RequestException as e:
+             error_msg = f"Error downloading thumbnail {thumbnail_url}: {e}"
+             if hasattr(e, 'response') and e.response is not None: error_msg += f" (Status: {e.response.status_code})"
+             print(f"[Manager Preview {download_id}] {error_msg}")
+        except Exception as e: print(f"[Manager Preview {download_id}] Error saving thumbnail {preview_path}: {e}")
+        finally:
+            if response: response.close()
+
+    # --- _download_file_wrapper remains the same ---
+    def _download_file_wrapper(self, download_info: Dict[str, Any]):
+        """Wraps the download execution, handles status updates, exceptions, and metadata saving."""
+        # ... (no changes needed here) ...
+        download_id = download_info["id"]
+        filename = download_info.get('filename', download_id)
+        from .chunk_downloader import ChunkDownloader
+        downloader = None
+        success = False
+        final_status = "failed"
+        error_msg = None
+
+        try:
+            print(f"[Downloader Wrapper {download_id}] Preparing download for '{filename}'.")
+            downloader = ChunkDownloader(
+                url=download_info["url"],
+                output_path=download_info["output_path"],
+                num_connections=download_info.get("num_connections", DEFAULT_CONNECTIONS),
+                manager=self,
+                download_id=download_id,
+                api_key=download_info.get("api_key"),
+                known_size=download_info.get("known_size")
+            )
+
+            with self.lock:
+                  if download_id not in self.active_downloads or self.active_downloads[download_id]["status"] == "cancelled":
+                       print(f"[Downloader Wrapper {download_id}] Download was cancelled before instance could be fully linked/started.")
+                       self._update_download_status(download_id, status="cancelled", error="Cancelled before start")
+                       return
+
+                  self.active_downloads[download_id]["downloader_instance"] = downloader
+
+            self._update_download_status(download_id, status="downloading")
+            print(f"[Downloader Wrapper {download_id}] Starting download process for '{filename}'.")
+            success = downloader.download() # Blocking call
+
+            error_msg = downloader.error
+
+            if success:
+                final_status = "completed"
+                print(f"[Downloader Wrapper {download_id}] Download completed successfully for '{filename}'.")
+                try:
+                    self._save_civitai_metadata(download_info)
+                    self._download_and_save_preview(download_info)
+                except Exception as meta_err:
+                     print(f"[Downloader Wrapper {download_id}] Error during post-download metadata/preview saving: {meta_err}")
+
+            elif downloader.is_cancelled:
+                final_status = "cancelled"
+                error_msg = downloader.error or "Download cancelled"
+                print(f"[Downloader Wrapper {download_id}] Download cancelled for '{filename}'. Reason: {error_msg}")
+            else:
+                final_status = "failed"
+                error_msg = downloader.error or "Download failed with unknown error"
+                print(f"[Downloader Wrapper {download_id}] Download failed for '{filename}'. Error: {error_msg}")
+
+        except Exception as e:
+            import traceback
+            print(f"--- Critical Error in Download Wrapper {download_id} ('{filename}') ---")
+            traceback.print_exc()
+            print("--- End Error ---")
+            final_status = "failed"
+            error_msg = f"Unexpected wrapper error: {str(e)}"
+            if downloader and not downloader.is_cancelled:
+                try: downloader.cancel()
+                except: pass
+
+        finally:
+            final_progress_percent = 0
+            conn_type = download_info.get("connection_type", "N/A")
+
+            if downloader:
+                 conn_type = downloader.connection_type
+                 if downloader.total_size and downloader.total_size > 0:
+                      final_progress_percent = (downloader.downloaded / downloader.total_size * 100)
+                 if final_status == "completed": final_progress_percent = 100.0
+                 final_progress_percent = min(100.0, max(0.0, final_progress_percent))
+
+            print(f"[Downloader Wrapper {download_id}] Finalizing status: {final_status}, Error: {error_msg}")
+            self._update_download_status(
+                download_id, status=final_status, progress=final_progress_percent,
+                speed=0, error=error_msg, connection_type=conn_type
+            )
+            if final_status == "completed":
+                 print(f"[Manager] Download {download_id} completed ('{filename}'). Manual ComfyUI refresh may be needed for model list.")
+
+    # --- NEW: Retry Download Method ---
+    def retry_download(self, original_download_id: str) -> Dict[str, Any]:
+        """Finds a failed/cancelled download in history and re-queues it."""
+        with self.lock:
+            # Find the original download info in history
+            original_info = next((item for item in self.history if item.get("id") == original_download_id), None)
+
+            if not original_info:
+                return {"success": False, "error": f"Original download ID '{original_download_id}' not found in history."}
+
+            original_status = original_info.get("status")
+            if original_status not in ["failed", "cancelled"]:
+                return {"success": False, "error": f"Cannot retry download with status '{original_status}'. Only 'failed' or 'cancelled' are retryable."}
+
+            # --- Prepare the new download info dictionary ---
+            # Make a deep copy to avoid modifying the history item directly
+            try:
+                retry_info = json.loads(json.dumps(original_info))
+                print(retry_info)
+            except Exception as e:
+                 return {"success": False, "error": f"Failed to copy original download data: {e}"}
+
+            # Remove fields specific to the *previous* attempt
+            retry_info.pop("id", None) # Will get a new ID
+            retry_info.pop("status", None)
+            retry_info.pop("progress", None)
+            retry_info.pop("speed", None)
+            retry_info.pop("error", None)
+            retry_info.pop("start_time", None)
+            retry_info.pop("end_time", None)
+            retry_info.pop("added_time", None)
+            retry_info.pop("connection_type", None)
+            retry_info.pop("downloader_instance", None) 
+            # --- Crucially: Set force_redownload to True for retry ---
+            # This ensures it overwrites the potentially corrupted/partial file from the previous attempt.
+            retry_info["force_redownload"] = True
+
+            # --- Validate required fields for queuing (redundant check, but safe) ---
+            required_for_retry = [
+                'url', 'output_path', 'num_connections', 'api_key', 'known_size',
+                'civitai_model_info', 'civitai_version_info', 'civitai_primary_file',
+                'thumbnail', 'filename', 'model_url_or_id', 'model_version_id', 'model_type',
+                'custom_filename', 'force_redownload'
+            ]
+            missing_keys = [key for key in required_for_retry if key not in retry_info or retry_info[key] is None and key != 'api_key' and key != 'custom_filename'] # Allow api_key/custom_filename to be None
+            #if missing_keys:
+            #    return {"success": False, "error": f"Cannot retry: Original download data is missing required fields: {', '.join(missing_keys)}"}
+
+        # --- Add the prepared info to the queue (outside the lock for add_to_queue's own lock) ---
+        # Note: add_to_queue acquires its own lock internally
+        try:
+            new_download_id = self.add_to_queue(retry_info)
+            if new_download_id: # Check if add_to_queue returned a valid ID (indicating success)
+                with self.lock:
+                    original_len = len(self.history)
+                    # Filter out the item matching the original ID
+                    self.history = [item for item in self.history if item.get("id") != original_download_id]
+                    items_removed = original_len - len(self.history)
+
+                    if items_removed == 1:
+                        print(f"[Manager] Successfully removed original download '{original_download_id}' from history.")
+                        return {
+                            "success": True,
+                            "message": f"Retry initiated. New download queued. Original removed from history.",
+                            "new_download_id": new_download_id
+                        }
+
+            else:
+                # Should have been caught by the except block, but as a failsafe
+                print(f"[Manager] Retry queueing failed for '{original_download_id}' for an unknown reason (no ID returned).")
+                return {"success": False, "error": "Failed to queue retry (unknown internal error)."}
+        
+        except Exception as e:
+             print(f"[Manager] Error requeuing download for retry (Original ID: {original_download_id}): {e}")
+             return {"success": False, "error": f"Failed to queue retry: {e}"}
+
+    # --- NEW: Open Containing Folder Method ---
+    def open_containing_folder(self, download_id: str) -> Dict[str, Any]:
+        """Opens the directory containing the specified completed download file."""
+        file_path = None
+        with self.lock:
+            # Check history first (most likely location for completed items)
+            item_info = next((item for item in self.history if item.get("id") == download_id), None)
+            # Fallback to active (less likely, but possible if called very quickly after completion)
+            if not item_info and download_id in self.active_downloads:
+                 item_info = self.active_downloads.get(download_id)
+
+            if not item_info:
+                 return {"success": False, "error": "Download ID not found."}
+
+            if item_info.get("status") != "completed":
+                 return {"success": False, "error": f"Cannot open path for download with status '{item_info.get('status')}'. Must be 'completed'."}
+
+            file_path = item_info.get("output_path") # Get the full path to the file
+
+        # --- Perform file operations outside the lock ---
+        if not file_path:
+            return {"success": False, "error": "Output path not found for this download."}
+
+        # --- Security Check: Ensure the path is within expected ComfyUI directories ---
+        # (This is a basic check, might need refinement based on your setup)
+        is_safe_path = False
+        try:
+            # Get the absolute path
+            abs_file_path = os.path.abspath(file_path)
+            folder_path = os.path.dirname(abs_file_path)
+
+            # Option 1: Check against ComfyUI's known directories (preferred)
+            if COMFY_PATHS_AVAILABLE:
+                 # Check if the folder is within any known model type directory
+                 known_types = [
+                     "checkpoints", "loras", "vae", "embeddings", "hypernetworks",
+                     "controlnet", "upscale_models", "clip_vision", "gligen", "configs",
+                     "unet", "diffusers", "motion_models", "poses", "wildcards"
+                 ]
+                 known_dirs = [os.path.abspath(get_directory_by_type(t)) for t in known_types if get_directory_by_type(t)]
+                 # Also allow output and input directories
+                 if get_directory_by_type("output"): known_dirs.append(os.path.abspath(get_directory_by_type("output")))
+                 if get_directory_by_type("input"): known_dirs.append(os.path.abspath(get_directory_by_type("input")))
+                 # Add the plugin's own 'other_models' directory as safe
+                 known_dirs.append(os.path.abspath(os.path.join(PLUGIN_ROOT, "other_models")))
+                 # Add plugin-managed custom roots as safe
+                 try:
+                     import json as _json
+                     _roots_file = os.path.join(PLUGIN_ROOT, "custom_roots.json")
+                     if os.path.exists(_roots_file):
+                         with open(_roots_file, 'r', encoding='utf-8') as _f:
+                             _data = _json.load(_f)
+                             if isinstance(_data, dict):
+                                 for _lst in _data.values():
+                                     if isinstance(_lst, list):
+                                         for _p in _lst:
+                                             if isinstance(_p, str):
+                                                 known_dirs.append(os.path.abspath(_p))
+                 except Exception as _e:
+                     print(f"[Manager OpenPath] Warning: Failed to load custom roots: {_e}")
+                 # Include all first-level subdirectories under models_dir as safe
+                 try:
+                     models_dir = getattr(__import__('folder_paths'), 'folder_paths').models_dir
+                 except Exception:
+                     models_dir = None
+                 try:
+                     if models_dir and os.path.isdir(models_dir):
+                         for _name in os.listdir(models_dir):
+                             _p = os.path.join(models_dir, _name)
+                             if os.path.isdir(_p):
+                                 known_dirs.append(os.path.abspath(_p))
+                 except Exception as _e2:
+                     print(f"[Manager OpenPath] Warning: Failed enumerating models_dir subfolders: {_e2}")
+
+                 for known_dir in known_dirs:
+                      if os.path.commonpath([known_dir, folder_path]) == known_dir:
+                           is_safe_path = True
+                           break
+            else:
+                 # Option 2: Fallback - Check if path is within the ComfyUI base directory
+                 comfy_base = os.path.abspath(base_path)
+                 if os.path.commonpath([comfy_base, folder_path]) == comfy_base:
+                      is_safe_path = True
+                      #print(f"[Manager OpenPath Warning] ComfyUI paths unavailable. Using base path check for {folder_path}")
+
+            if not is_safe_path:
+                  print(f"[Manager OpenPath Denied] Path '{folder_path}' is outside known safe ComfyUI directories.")
+                  return {"success": False, "error": "Cannot open path: Directory is outside allowed locations."}
+
+            # --- Open the directory ---
+            if not os.path.exists(folder_path):
+                 return {"success": False, "error": f"Directory does not exist: {folder_path}"}
+            if not os.path.isdir(folder_path):
+                 return {"success": False, "error": f"Path is not a directory: {folder_path}"}
+
+            try:
+                 system = platform.system()
+                 print(f"[Manager OpenPath] Attempting to open folder '{folder_path}' on {system}...")
+                 if system == "Windows":
+                      # Use startfile for better handling of spaces etc.
+                      os.startfile(folder_path)
+                 elif system == "Darwin": # macOS
+                      subprocess.check_call(["open", folder_path])
+                 elif system == "Linux":
+                      # Use xdg-open, handle potential errors if command not found
+                      try:
+                            subprocess.check_call(["xdg-open", folder_path])
+                      except FileNotFoundError:
+                            # Fallback for headless systems or if xdg-open isn't installed
+                           print(f"[Manager OpenPath] 'xdg-open' not found. Cannot automatically open folder on this Linux system.")
+                           return {"success": False, "error": "'xdg-open' command not found. Cannot open folder."}
+                 else:
+                      print(f"[Manager OpenPath] Unsupported operating system: {system}. Cannot open folder.")
+                      return {"success": False, "error": f"Unsupported OS ({system}) for opening folder."}
+
+                 print(f"[Manager OpenPath] Successfully requested folder opening for '{folder_path}'.")
+                 return {"success": True, "message": f"Opened directory: {folder_path}"}
+
+            except Exception as e:
+                 print(f"[Manager OpenPath] Failed to open directory '{folder_path}': {e}")
+                 return {"success": False, "error": f"Failed to open directory: {e}"}
+
+        except Exception as path_err:
+            # Catch errors during path validation itself
+            print(f"[Manager OpenPath] Error during path validation/retrieval for {download_id}: {path_err}")
+            return {"success": False, "error": f"Error processing path: {path_err}"}
+
+# --- Global Instance ---
+manager = DownloadManager(max_concurrent=MAX_CONCURRENT_DOWNLOADS)
+
+# --- Graceful Shutdown ---
+# (shutdown_manager remains the same)
+def shutdown_manager():
+    # ... (no changes) ...
+    print("[Manager] Shutdown requested.")
+    if manager:
+        manager.running = False
+        acquired_lock = False
+        try: acquired_lock = manager.lock.acquire(timeout=1.0)
+        except RuntimeError: pass # Lock might not be initialised if init failed
+
+        if acquired_lock:
+             try:
+                 active_ids = list(manager.active_downloads.keys())
+                 queue_ids = [item['id'] for item in manager.queue]
+                 print(f"[Manager] Requesting cancellation for {len(active_ids)} active and {len(queue_ids)} queued downloads on shutdown...")
+                 all_ids_to_cancel = active_ids + queue_ids
+                 manager.lock.release() # Release lock BEFORE calling cancel_download
+
+                 for dl_id in all_ids_to_cancel:
+                      try:
+                          # Reuse cancel_download which handles both active and queued safely
+                          manager.cancel_download(dl_id)
+                      except Exception as e:
+                           print(f"Error cancelling {dl_id} during shutdown: {e}")
+             except Exception as e:
+                 print(f"[Manager] Error accessing lists during shutdown (after lock acquired): {e}")
+                 try: manager.lock.release() # Ensure release on error
+                 except RuntimeError: pass
+             # Give threads/tasks a brief moment to react
+             time.sleep(0.5)
+        else:
+            print("[Manager] Warning: Could not acquire lock to cancel downloads during shutdown.")
+
+        # Attempt to join the manager's process thread (best effort)
+        try:
+            if manager._process_thread and manager._process_thread.is_alive():
+                 manager._process_thread.join(timeout=2.0)
+                 if manager._process_thread.is_alive():
+                      print("[Manager] Warning: Process thread did not exit cleanly within timeout.")
+        except Exception as e:
+            print(f"[Manager] Error joining manager thread during shutdown: {e}")
+    print("[Manager] Shutdown complete.")
+
+import atexit
+atexit.register(shutdown_manager)

custom_nodes/Civicomfy/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "civicomfy"
+description = "Civicomfy seamlessly integrates Civitai's vast model repository directly into ComfyUI, allowing you to search, download, and organize AI models without leaving your workflow."
+version = "1.0.9"
+license = {file = "LICENSE"}
+
+[project.urls]
+Repository = "https://github.com/MoonGoblinDev/Civicomfy"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "moongoblin"
+DisplayName = "Civicomfy"
+Icon = ""

custom_nodes/Civicomfy/server/__init__.py

@@ -0,0 +1,5 @@
+# ================================================
+# File: server/__init__.py
+# ================================================
+# Import the routes package to ensure all route decorators are executed.
+from . import routes

custom_nodes/Civicomfy/server/routes/CancelDownload.py

@@ -0,0 +1,44 @@
+# ================================================
+# File: server/routes/CancelDownload.py
+# ================================================
+import json
+from aiohttp import web
+import server # ComfyUI server instance
+from ..utils import get_request_json
+from ...downloader.manager import manager as download_manager
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/cancel")
+async def route_cancel_download(request):
+    """API Endpoint to cancel a download."""
+    try:
+        data = await get_request_json(request)
+        download_id = data.get("download_id")
+        if not download_id:
+            print("not download id " + download_id)
+            raise web.HTTPBadRequest(reason="Missing 'download_id'")
+
+        success = download_manager.cancel_download(download_id)
+        if success:
+            return web.json_response({
+                "status": "cancelled", # Or "cancellation_requested" ?
+                "message": f"Cancellation requested for download ID: {download_id}.",
+                "download_id": download_id
+            })
+        else:
+            # Might be already completed/failed/cancelled and in history, or invalid ID
+            raise web.HTTPNotFound(reason=f"Download ID {download_id} not found in active queue or running downloads.")
+
+    except web.HTTPError as http_err:
+         # Consistent error handling
+         body_detail = ""
+         try:
+              body_detail = await http_err.text() if hasattr(http_err, 'text') else http_err.body.decode('utf-8', errors='ignore') if http_err.body else ""
+              if body_detail.startswith('{') and body_detail.endswith('}'): body_detail = json.loads(body_detail)
+         except Exception: pass
+         return web.json_response({"error": http_err.reason, "details": body_detail or "No details", "status_code": http_err.status}, status=http_err.status)
+
+    except Exception as e:
+        print(f"Error cancelling download: {e}")
+        return web.json_response({"error": "Internal Server Error", "details": f"Failed to cancel download: {str(e)}", "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/ClearHistory.py

@@ -0,0 +1,32 @@
+# ================================================
+# File: server/routes/ClearHistory.py
+# ================================================
+import asyncio
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ...downloader.manager import manager as download_manager
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/clear_history")
+async def route_clear_history(request):
+    """API Endpoint to clear the download history."""
+    if not download_manager:
+        return web.json_response({"error": "Download Manager not initialized"}, status=500)
+
+    try:
+        # No request body needed for this action
+        print(f"[API Route /civitai/clear_history] Received clear history request.")
+
+        # Call manager method in thread
+        result = await asyncio.to_thread(download_manager.clear_history)
+
+        status_code = 200 if result.get("success") else 500 # Use 500 for internal clear error
+        return web.json_response(result, status=status_code)
+
+    except Exception as e:
+        import traceback
+        print(f"Error handling /civitai/clear_history request: {e}")
+        # traceback.print_exc() # Uncomment for detailed logs
+        return web.json_response({"error": "Internal Server Error", "details": f"An unexpected error occurred: {str(e)}"}, status=500)

custom_nodes/Civicomfy/server/routes/DownloadModel.py

@@ -0,0 +1,470 @@
+# ================================================
+# File: server/routes/DownloadModel.py
+# ================================================
+import os
+import json
+import traceback
+import re
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ..utils import get_request_json
+from ...downloader.manager import manager as download_manager
+from ...api.civitai import CivitaiAPI
+from ...utils.helpers import get_model_dir, parse_civitai_input, sanitize_filename, select_primary_file
+from ...config import METADATA_SUFFIX, PREVIEW_SUFFIX
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/download")
+async def route_download_model(request):
+    """API Endpoint to initiate a download."""
+    api_key = None # Define outside try block
+    model_info = None # Define here for broader scope
+    version_info = None
+    primary_file = None
+    target_model_id = None
+    target_version_id = None
+    try:
+        data = await get_request_json(request)
+
+        model_url_or_id = data.get("model_url_or_id")
+        # 'model_type' defines the target directory category (e.g., 'lora', 'checkpoint')
+        model_type_value = data.get("model_type", "checkpoint")  # Use as-is; may be a literal folder name
+        req_version_id = data.get("model_version_id") # Optional explicit version ID
+        explicit_save_root = (data.get("save_root") or "").strip()
+        custom_filename_input = data.get("custom_filename", "").strip()
+        selected_subdir = (data.get("subdir") or "").strip()
+        # Optional file selection overrides
+        req_file_id = data.get("file_id")
+        req_file_name_contains = data.get("file_name_contains", "").strip()
+        num_connections = int(data.get("num_connections", 4))
+        force_redownload = bool(data.get("force_redownload", False))
+        api_key = data.get("api_key", "") # Get API key from frontend settings
+
+        if not model_url_or_id:
+            raise web.HTTPBadRequest(reason="Missing 'model_url_or_id'")
+
+        # --- Input Parsing and Info Fetching ---
+        print(f"[Server Download] Request: {model_url_or_id}, SaveType: {model_type_value}, Version: {req_version_id}")
+        # Instantiate API with the key from the request (frontend settings)
+        api = CivitaiAPI(api_key or None) # Pass None if empty string
+        parsed_model_id, parsed_version_id = parse_civitai_input(model_url_or_id)
+
+        # Determine the target version ID (request param > URL param)
+        target_version_id = None
+        if req_version_id and str(req_version_id).isdigit(): # Check if actually a number
+            try:
+                target_version_id = int(req_version_id)
+            except (ValueError, TypeError):
+                 print(f"[Server Download] Warning: Invalid value provided for 'model_version_id': {req_version_id}. Ignoring.")
+                 # Continue, will try to find latest if no version ID parsed from URL either
+        elif parsed_version_id:
+            target_version_id = parsed_version_id
+        # else: target_version_id remains None, we'll need model_id to find latest
+
+        target_model_id = parsed_model_id
+
+        # --- Get Model/Version Info from Civitai ---
+        # Store results in broader scope vars 'model_info' and 'version_info'
+        if target_version_id:
+            # Fetch version info directly using GET /model-versions/{id}
+            print(f"[Server Download] Fetching info for Version ID: {target_version_id}")
+            version_info_result = api.get_model_version_info(target_version_id)
+            if version_info_result and "error" not in version_info_result:
+                version_info = version_info_result # Assign to broader scope variable
+                # Infer model_id from version info if we didn't have it
+                if not target_model_id and version_info.get('modelId'):
+                     target_model_id = version_info['modelId']
+                     print(f"[Server Download] Inferred Model ID {target_model_id} from Version ID {target_version_id}")
+                     # Fetch model info as well for completeness if we only had version ID initially
+                     model_info_result = api.get_model_info(target_model_id)
+                     if model_info_result and "error" not in model_info_result:
+                         model_info = model_info_result
+                     else:
+                         print(f"[Server Download] Warning: Could not fetch model info ({target_model_id}) after inferring from version.")
+                         model_info = {} # Use empty dict as placeholder
+                else:
+                    model_info_result = api.get_model_info(target_model_id)
+                    if model_info_result and "error" not in model_info_result:
+                         model_info = model_info_result
+                    else:
+                         print(f"[Server Download] Warning: Could not fetch model info ({target_model_id}) after inferring from version.")
+                         model_info = {} # Use empty dict as placeholder
+
+            else:
+                # Handle API error or not found for version ID
+                err_details = version_info_result.get('details') if isinstance(version_info_result, dict) else "Unknown API error"
+                status_code = version_info_result.get('status_code', 500) if isinstance(version_info_result, dict) else 500
+                raise web.HTTPNotFound(reason=f"Civitai API Error: Version {target_version_id} not found or API error. Details: {err_details}",
+                                       body=json.dumps({"error": f"Version {target_version_id} not found or API error", "details": err_details}))
+
+        elif target_model_id:
+             # Fetch model info (GET /models/{id}) to get the latest version
+            print(f"[Server Download] Fetching info for Model ID: {target_model_id} to find latest version.")
+            model_info_result = api.get_model_info(target_model_id)
+            if model_info_result and "error" not in model_info_result:
+                model_info = model_info_result # Assign to broader scope variable
+                versions = model_info.get("modelVersions")
+                if versions and isinstance(versions, list) and len(versions) > 0:
+                    # Find the *best* default version (often marked as 'default' or just the first 'Published')
+                    default_version_in_list = next((v for v in versions if v.get('status') == 'Published'), versions[0])
+                    if not default_version_in_list: # Should not happen if versions exist, but safety check
+                         raise web.HTTPNotFound(reason=f"Model {target_model_id} found, but has no published versions listed.")
+
+                    partial_version_info = default_version_in_list # This is the partial version info dict from the list
+                    target_version_id = partial_version_info.get('id')
+                    if not target_version_id:
+                         raise web.HTTPNotFound(reason=f"Model {target_model_id} found, but latest version has no ID.")
+
+                    print(f"[Server Download] Using latest/default Version ID {target_version_id} for Model ID {target_model_id}")
+                    # Need to re-fetch full version details as model info often lacks file download URLs or full metadata
+                    print(f"[Server Download] Fetching full details for selected Version ID: {target_version_id}")
+                    full_version_info_result = api.get_model_version_info(target_version_id)
+                    if full_version_info_result and "error" not in full_version_info_result:
+                        version_info = full_version_info_result # Overwrite with full details
+                    else:
+                        # Log error but proceed with partial data if possible (will likely fail later if files missing)
+                        err_details = full_version_info_result.get('details') if isinstance(full_version_info_result, dict) else "Unknown error getting full version"
+                        print(f"[Server Download] Warning: Could not fetch full details for version {target_version_id}. Details: {err_details}. Download might fail if file info is missing.")
+                        version_info = partial_version_info # Use the partial info from the model list
+
+                else:
+                    raise web.HTTPNotFound(reason=f"Model {target_model_id} found, but has no usable model versions listed.")
+            else:
+                # Handle API error or not found for model ID
+                err_details = model_info_result.get('details') if isinstance(model_info_result, dict) else "Unknown API error"
+                status_code = model_info_result.get('status_code', 500) if isinstance(model_info_result, dict) else 500
+                raise web.HTTPNotFound(reason=f"Civitai API Error: Model {target_model_id} not found or API error. Details: {err_details}",
+                                       body=json.dumps({"error": f"Model {target_model_id} not found or API error", "details": err_details}))
+
+        else:
+             # Neither model ID nor version ID could be determined
+            raise web.HTTPBadRequest(reason="Invalid input: Could not determine Model ID or Version ID from input.")
+
+        # --- Sanity Checks After Fetching ---
+        if not target_model_id:
+             # This case implies we started with only a version ID and failed to infer the model ID
+             raise web.HTTPInternalServerError(reason="Failed to determine the parent Model ID for the requested version.")
+        if not target_version_id or not version_info:
+             # This implies we started with a model ID but failed to find/fetch a valid version
+             raise web.HTTPInternalServerError(reason="Failed to resolve valid model version information.")
+        # Ensure model_info exists, even if empty (e.g., if started with only version_id and model fetch failed)
+        if model_info is None: model_info = {}
+
+        # --- Select File and Get Download URL ---
+        files = version_info.get("files", [])
+        if not isinstance(files, list):
+             print(f"[Server Download] Error: 'files' field is not a list in version info for {target_version_id}: {files}")
+             files = [] # Treat as empty if not a list
+
+        # Check for fallback downloadUrl at version level (less common now)
+        if not files and 'downloadUrl' in version_info and version_info['downloadUrl']:
+            print("[Server Download] Warning: No 'files' array found, attempting to use version-level 'downloadUrl'. File details will be incomplete.")
+            # Mock a file structure for consistency downstream
+            files = [{
+                "id": None, # No file ID available
+                "name": version_info.get('name', f"version_{target_version_id}_file"), # Use version name as fallback
+                "primary": True,
+                "type": "Model", # Default type
+                "sizeKB": version_info.get('fileSizeKB'), # Try to get size if available at version level
+                "downloadUrl": version_info['downloadUrl'],
+                "hashes": {}, # No hashes available
+                "metadata": {} # No metadata available
+            }]
+
+        if not files:
+             raise web.HTTPNotFound(reason=f"Version ID {target_version_id} ({version_info.get('name', 'N/A')}) has no files listed in API response.")
+
+        # If a specific file was requested by ID, honor it first
+        primary_file = None
+        if req_file_id is not None:
+            try:
+                # IDs in API are ints; accept stringified ints too
+                req_file_id_int = int(str(req_file_id).strip())
+                primary_file = next((f for f in files if isinstance(f, dict) and f.get("id") == req_file_id_int and f.get('downloadUrl')), None)
+                if not primary_file:
+                    raise web.HTTPNotFound(reason=f"File with id {req_file_id_int} not found or not downloadable in version {target_version_id}.")
+            except ValueError:
+                raise web.HTTPBadRequest(reason=f"Invalid 'file_id' value: {req_file_id}")
+
+        # If not selected by ID, try selecting by partial name match (e.g., 'fp16', 'fp8')
+        if primary_file is None and req_file_name_contains:
+            needle = req_file_name_contains.lower()
+            def name_matches(f):
+                if not isinstance(f, dict):
+                    return False
+                name = (f.get("name") or "").lower()
+                meta = (f.get("metadata") or {})
+                fmt = (meta.get("format") or "").lower()
+                size_tag = (meta.get("size") or "").lower()
+                return (needle in name) or (needle in fmt) or (needle in size_tag)
+            candidates = [f for f in files if f.get('downloadUrl') and name_matches(f)]
+            primary_file = candidates[0] if candidates else None
+
+        # If still not selected, fall back to heuristic helper
+        if primary_file is None:
+            primary_file = select_primary_file(files)
+
+        if not primary_file:
+            raise web.HTTPNotFound(reason=f"Could not find any file with a valid download URL for version {target_version_id}.")
+
+        # Ensure primary_file is a valid dictionary before accessing keys
+        if not isinstance(primary_file, dict) or not primary_file.get('downloadUrl'):
+            print(f"[Server Download] Error: Selected primary file data is invalid or missing URL: {primary_file}")
+            raise web.HTTPInternalServerError(reason=f"Selected file data is invalid for version {target_version_id}.")
+
+        print(f"[Server Download] Selected file: Name='{primary_file.get('name', 'N/A')}', Type='{primary_file.get('type', 'N/A')}', SizeKB={primary_file.get('sizeKB')}, Format={primary_file.get('metadata', {}).get('format')}, Size={primary_file.get('metadata', {}).get('size')}")
+
+        file_id = primary_file.get("id") # May not be present, but useful for logging/metadata
+
+        # *** Get the download URL directly from the file object ***
+        download_url = primary_file.get("downloadUrl")
+        print(f"[Server Download] Using Download URL: {download_url}")
+
+        # --- Determine Filename and Output Path ---
+        api_filename = primary_file.get("name", f"model_{target_model_id}_ver_{target_version_id}_file_{file_id or 'unknown'}")
+
+        # Defaults
+        final_filename = sanitize_filename(api_filename)
+        sub_path = ""
+
+        # Subdir: only use the selected existing subdir coming from UI
+        if selected_subdir:
+            norm_sub = os.path.normpath(selected_subdir.replace('\\', '/'))
+            parts = [p for p in norm_sub.split('/') if p and p not in ('.', '..')]
+            if parts:
+                sub_path = os.path.join(*[sanitize_filename(p) for p in parts])
+
+        # Filename: ignore any path separators in custom name; treat as base name only
+        if custom_filename_input:
+            safe_name = sanitize_filename(custom_filename_input)
+            base, ext = os.path.splitext(safe_name)
+            if not ext:
+                _, api_ext = os.path.splitext(api_filename)
+                ext = api_ext or ".safetensors"
+            final_filename = base + ext
+
+        # Get the target base directory for the selected model type, allow explicit root
+        if explicit_save_root:
+            # Validate the explicit root belongs to known roots for this type (ComfyUI or plugin)
+            try:
+                from ..routes.GetModelDirs import _get_all_roots_for_type
+                known_roots = _get_all_roots_for_type(model_type_value)
+                if os.path.abspath(explicit_save_root) in [os.path.abspath(p) for p in known_roots]:
+                    base_output_dir = explicit_save_root
+                else:
+                    print(f"[Server Download] Warning: Provided save_root not in known roots for type '{model_type_value}': {explicit_save_root}")
+                    base_output_dir = get_model_dir(model_type_value)
+            except Exception as e:
+                print(f"[Server Download] Warning: Failed validating explicit save_root: {e}")
+                base_output_dir = get_model_dir(model_type_value)
+        else:
+            base_output_dir = get_model_dir(model_type_value)
+        output_dir = os.path.join(base_output_dir, sub_path) if sub_path else base_output_dir
+        # Ensure directory exists (including subdirectories)
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+            print(f"[Server Download] Ensured output directory exists: {output_dir}")
+        except OSError as e:
+            raise web.HTTPInternalServerError(reason=f"Could not create subdirectory: {e}")
+        output_path = os.path.join(output_dir, final_filename)
+
+        # Construct corresponding metadata/preview paths
+        base_name, _ = os.path.splitext(final_filename)
+        meta_filename = base_name + METADATA_SUFFIX
+        preview_filename = base_name + PREVIEW_SUFFIX
+        meta_path = os.path.join(output_dir, meta_filename)
+        preview_path = os.path.join(output_dir, preview_filename)
+
+        # --- Check Existing File ---
+        # Get size from API response for comparison
+        api_size_kb = primary_file.get("sizeKB")
+        api_size_bytes = int(api_size_kb * 1024) if api_size_kb and isinstance(api_size_kb, (int, float)) else 0
+
+        file_exists = os.path.exists(output_path)
+        metadata_exists = os.path.exists(meta_path)
+        preview_exists = os.path.exists(preview_path)
+
+        if file_exists and not force_redownload:
+             local_size = os.path.getsize(output_path)
+             # Relax size check slightly (e.g., within 1KB) OR if API size is unknown (0)
+             size_matches = api_size_bytes > 0 and abs(api_size_bytes - local_size) <= 1024
+
+             if size_matches:
+                 print(f"[Server Download] File already exists and size matches: {output_path}")
+                 # If primary file exists and matches size, check if metadata/preview are missing and offer to fetch *only* those?
+                 # For now, just report exists. Enhancement: could add a button/option to "Fetch Metadata/Preview Only".
+                 if not metadata_exists:
+                     print(f"[Server Download] Info: Main file exists, but metadata file {meta_filename} is missing.")
+                 if not preview_exists:
+                      print(f"[Server Download] Info: Main file exists, but preview file {preview_filename} is missing.")
+
+                 return web.json_response({
+                     "status": "exists",
+                     "message": "File already exists with matching size.",
+                     "path": output_path,
+                     "filename": final_filename,
+                 })
+             else:
+                 # If sizes differ, report mismatch.
+                 exist_reason = f"size differs (Local: {local_size} bytes, API: {api_size_bytes} bytes)" if api_size_bytes > 0 else "local file exists but API size was unknown"
+                 print(f"[Server Download] File already exists but {exist_reason}. Path: {output_path}.")
+                 # Return a distinct status code or message?
+                 return web.json_response({
+                     "status": "exists_size_mismatch",
+                     "message": f"File already exists but {exist_reason}. Use 'Force Re-download' to overwrite.",
+                     "path": output_path,
+                     "filename": final_filename,
+                     "local_size": local_size,
+                     "api_size_kb": api_size_kb,
+                 }, status=409) # Use 409 Conflict status
+
+        # If force_redownload is true, log it
+        if file_exists and force_redownload:
+             print(f"[Server Download] Force Re-download enabled. Will overwrite existing file: {output_path}")
+
+        # --- Prepare Download Info and Queue ---
+        model_name = model_info.get('name', version_info['model']['name'])
+        version_name = version_info.get('name', 'Unknown Version')
+
+        # Extract a suitable thumbnail URL (ensure it's done robustly) and nsfw level for it
+        thumbnail_url = None
+        thumbnail_nsfw_level = None
+        images = version_info.get("images")
+        if images and isinstance(images, list) and len(images) > 0:
+             # Ensure images are dictionaries with URLs
+             valid_images = [img for img in images if isinstance(img, dict) and img.get("url")]
+             # Sort by index if available, falling back to 0
+             sorted_images = sorted(valid_images, key=lambda x: x.get('index', 0))
+            # Try to find first image of type 'image' with explicit width (often better quality previews)
+             img_data = next((img for img in sorted_images if img.get("type") == "image" and "/width=" in img["url"]), None)
+             # Fallback 1: Any image of type 'image'
+             if not img_data: img_data = next((img for img in sorted_images if img.get("type") == "image"), None)
+             # Fallback 2: Any image at all
+             if not img_data: img_data = next((img for img in sorted_images), None)
+
+             if img_data and img_data.get("url"):
+                   base_url = img_data["url"]
+                   try:
+                       lvl = img_data.get("nsfwLevel")
+                       thumbnail_nsfw_level = int(lvl) if lvl is not None else None
+                   except Exception:
+                       thumbnail_nsfw_level = None
+                   # Try to get a reasonably sized thumbnail version (e.g., width 256-450)
+                   try:
+                       # Basic heuristic: replace width param or append if not present/blob
+                       if "/width=" in base_url:
+                           thumbnail_url = re.sub(r"/width=\d+", "/width=256", base_url)
+                       elif "/blob/" in base_url: # Handle blob URLs that might not have params
+                           thumbnail_url = base_url
+                       else:
+                           separator = "&" if "?" in base_url else "?"
+                           thumbnail_url = f"{base_url}{separator}width=256"
+                       print(f"[Server Download] Generated thumbnail URL for UI: {thumbnail_url}")
+                   except Exception as thumb_e:
+                        print(f"[Server Download] Warning: Failed to generate specific thumbnail URL from {base_url}: {thumb_e}")
+                        thumbnail_url = base_url # Fallback to original URL found
+             else:
+                  print(f"[Server Download] Warning: No image with a valid URL found for thumbnail in version {target_version_id}")
+
+        # Ensure size is int or None
+        known_size_bytes = api_size_bytes if api_size_bytes > 0 else None
+
+        # --- Prepare full download_info dict ---
+        # Derive extra display attributes for UI/history
+        def _guess_precision_name(fobj):
+            try:
+                nm = (fobj.get('name') or '').lower()
+                meta = (fobj.get('metadata') or {})
+                for key in ('precision', 'dtype', 'fp'):
+                    val = (meta.get(key) or '').lower()
+                    if val:
+                        return val
+                if 'fp8' in nm or 'int8' in nm or '8bit' in nm or '8-bit' in nm:
+                    return 'fp8'
+                if 'fp16' in nm or 'bf16' in nm or '16bit' in nm or '16-bit' in nm:
+                    return 'fp16'
+                if 'fp32' in nm or '32bit' in nm or '32-bit' in nm:
+                    return 'fp32'
+            except Exception:
+                pass
+            return None
+
+        primary_meta = (primary_file.get('metadata') or {})
+        ui_file_precision = _guess_precision_name(primary_file)
+        ui_file_model_size = primary_meta.get('size')  # e.g., Pruned/Full
+        ui_file_format = primary_meta.get('format')
+        # Pass all necessary info for download, metadata, and preview saving
+        download_info = {
+            # Core download params
+            "url": download_url,
+            "output_path": output_path,
+            "num_connections": num_connections,
+            "known_size": known_size_bytes,
+            "api_key": api_key or None, # Pass API key for download auth if needed
+            # Retry/context fields
+            "model_url_or_id": model_url_or_id,
+            "model_version_id": req_version_id,
+            "custom_filename": custom_filename_input,
+            "force_redownload": force_redownload,
+            # UI Display Info
+            "filename": final_filename,
+            "model_name": model_name,
+            "version_name": version_name,
+            "thumbnail": thumbnail_url, # URL for UI thumbnail preview
+            "thumbnail_nsfw_level": thumbnail_nsfw_level,
+            "model_type": model_type_value, # The category/directory key or literal folder used for saving
+            # Extra file attributes for UI lists
+            "file_precision": ui_file_precision,
+            "file_model_size": ui_file_model_size,
+            "file_format": ui_file_format,
+            # Metadata for .cminfo.json and preview saving
+            "civitai_model_id": target_model_id,
+            "civitai_version_id": target_version_id,
+            "civitai_file_id": file_id,
+            # ---> Pass the full API response dicts <---
+            "civitai_model_info": model_info,
+            "civitai_version_info": version_info,
+            "civitai_primary_file": primary_file, # Pass the selected file object
+        }
+
+        download_id = download_manager.add_to_queue(download_info)
+
+        # Return queued status and essential details for the UI
+        return web.json_response({
+            "status": "queued",
+            "message": f"Download added to queue: '{final_filename}'",
+            "download_id": download_id,
+            "details": {
+                "filename": final_filename,
+                "model_name": model_name,
+                "version_name": version_name,
+                "thumbnail": thumbnail_url,
+                "thumbnail_nsfw_level": thumbnail_nsfw_level,
+                "path": output_path, # The intended final path
+                "size_kb": api_size_kb if api_size_kb else None # Use KB for display consistency
+            }
+        })
+
+    except web.HTTPError as http_err:
+         # Re-raise known HTTP errors (like bad request, not found, conflict)
+         print(f"[Server Download] HTTP Error: {http_err.status} {http_err.reason}")
+         # Attempt to parse JSON body for details
+         body_detail = ""
+         try:
+             # Use await text() for aiohttp Response exceptions
+             body_detail = await http_err.text() if hasattr(http_err, 'text') else http_err.body.decode('utf-8', errors='ignore') if http_err.body else ""
+             # Try parsing as JSON if it looks like it
+             if body_detail.startswith('{') and body_detail.endswith('}'):
+                  body_detail = json.loads(body_detail) # Return parsed dict
+         except Exception: pass # Ignore parsing errors, just use the raw text
+         # Return JSON response for frontend handling
+         return web.json_response({"error": http_err.reason, "details": body_detail or "No details", "status_code": http_err.status}, status=http_err.status)
+
+    except Exception as e:
+        print("--- Unhandled Error in /civitai/download ---")
+        traceback.print_exc()
+        print("--- End Error ---")
+        # Return a generic 500 Internal Server Error for unexpected issues
+        return web.json_response({"error": "Internal Server Error", "details": f"An unexpected error occurred: {str(e)}", "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/GetBaseModels.py

@@ -0,0 +1,19 @@
+# ================================================
+# File: server/routes/GetBaseModels.py
+# ================================================
+from aiohttp import web
+import server # ComfyUI server instance
+from ...config import AVAILABLE_MEILI_BASE_MODELS
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.get("/civitai/base_models")
+async def route_get_base_models(request):
+    """API Endpoint to get the known base model types for filtering."""
+    try:
+        # Return the hardcoded list for now
+        # In future, this *could* fetch dynamically if Civitai provides an endpoint
+        return web.json_response({"base_models": AVAILABLE_MEILI_BASE_MODELS})
+    except Exception as e:
+        print(f"Error getting base model types: {e}")
+        return web.json_response({"error": "Internal Server Error", "details": str(e), "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/GetModelDetails.py

@@ -0,0 +1,192 @@
+# ================================================
+# File: server/routes/GetModelDetails.py
+# ================================================
+import os
+import json
+import traceback
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ..utils import get_request_json, get_civitai_model_and_version_details
+from ...api.civitai import CivitaiAPI
+from ...config import PLACEHOLDER_IMAGE_PATH
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/get_model_details")
+async def route_get_model_details(request):
+    """API Endpoint to fetch model/version details for preview."""
+    try:
+        data = await get_request_json(request)
+        model_url_or_id = data.get("model_url_or_id")
+        req_version_id = data.get("model_version_id") # Optional explicit version ID
+        api_key = data.get("api_key", "")
+
+        if not model_url_or_id:
+            raise web.HTTPBadRequest(reason="Missing 'model_url_or_id'")
+
+        # Instantiate API
+        api = CivitaiAPI(api_key or None)
+
+        # Use the helper to get details
+        details = await get_civitai_model_and_version_details(api, model_url_or_id, req_version_id)
+        model_info = details['model_info']
+        version_info = details['version_info']
+        primary_file = details['primary_file']
+        target_model_id = details['target_model_id']
+        target_version_id = details['target_version_id']
+
+        # --- Extract Data for Frontend Preview ---
+        model_name = model_info.get('name')
+        creator_username = model_info.get('creator', {}).get('username', 'Unknown Creator')
+        model_type = model_info.get('type', 'Unknown') # Checkpoint, LORA etc.
+
+        stats = model_info.get('stats', version_info.get('stats', {})) # Ensure stats is a dict
+        download_count = stats.get('downloadCount', 0)
+        likes_count = stats.get('thumbsUpCount', 0)
+        dislikes_count = stats.get('thumbsDownCount', 0)
+        buzz_count = stats.get('tippedAmountCount', 0)
+        
+
+        # Get description from model_info (version description might be update notes)
+        # Handle potential None value for description
+        description_html = model_info.get('description')
+        if description_html is None:
+            description_html = "<p><em>No description provided.</em></p>"
+        else:
+            # Basic sanitization/check (could be more robust if needed)
+            if not isinstance(description_html, str):
+                 description_html = "<p><em>Invalid description format.</em></p>"
+            elif not description_html.strip():
+                 description_html = "<p><em>Description is empty.</em></p>"
+        
+        version_description_html = version_info.get('description')
+        if version_description_html is None:
+            version_description_html = "<p><em>No description provided.</em></p>"
+        else:
+            # Basic sanitization/check (could be more robust if needed)
+            if not isinstance(version_description_html, str):
+                 version_description_html = "<p><em>Invalid description format.</em></p>"
+            elif not version_description_html.strip():
+                 version_description_html = "<p><em>Description is empty.</em></p>"
+
+        # File details
+        def _guess_precision(file_dict):
+            try:
+                name = (file_dict.get('name') or '').lower()
+                meta = (file_dict.get('metadata') or {})
+                for key in ('precision', 'dtype', 'fp'):
+                    val = (meta.get(key) or '').lower()
+                    if val:
+                        return val
+                if 'fp8' in name or 'int8' in name or '8bit' in name or '8-bit' in name:
+                    return 'fp8'
+                if 'fp16' in name or 'bf16' in name or '16bit' in name or '16-bit' in name:
+                    return 'fp16'
+                if 'fp32' in name or '32bit' in name or '32-bit' in name:
+                    return 'fp32'
+            except Exception:
+                pass
+            return 'N/A'
+
+        file_name = primary_file.get('name', 'N/A')
+        file_size_kb = primary_file.get('sizeKB', 0)
+        _meta = (primary_file.get('metadata') or {})
+        file_format = _meta.get('format', 'N/A') # e.g., SafeTensor, PickleTensor
+        file_model_size = _meta.get('size', 'N/A') # e.g., Pruned/Full
+        file_precision = _guess_precision(primary_file)
+
+        thumbnail_url = None
+        images = version_info.get("images") # Get the images list from the version info
+        nsfw_level = None
+
+        # Check if images list exists, is a list, has items, and the first item is valid with a URL
+        if images and isinstance(images, list) and len(images) > 0 and \
+           isinstance(images[0], dict) and images[0].get("url"):
+            # Use the URL of the very first image directly
+            first_image = images[0]
+            thumbnail_url = first_image["url"]
+            try:
+                lvl = first_image.get("nsfwLevel")
+                nsfw_level = int(lvl) if lvl is not None else None
+            except Exception:
+                nsfw_level = None
+            print(f"[Get Details Route] Using first image URL as thumbnail: {thumbnail_url}")
+        else:
+            print("[Get Details Route] No valid first image found in version info, falling back to placeholder.")
+            # Fallback placeholder logic (remains the same)
+            placeholder_filename = os.path.basename(PLACEHOLDER_IMAGE_PATH) if PLACEHOLDER_IMAGE_PATH else "placeholder.jpeg"
+            thumbnail_url = f"./{placeholder_filename}" # Relative path for JS to resolve
+
+
+        # Fallback placeholder if no thumbnail found
+        if not thumbnail_url:
+             placeholder_filename = os.path.basename(PLACEHOLDER_IMAGE_PATH) if PLACEHOLDER_IMAGE_PATH else "placeholder.jpeg"
+             thumbnail_url = f"./{placeholder_filename}" # Relative path for JS
+
+        # Build minimal files listing for selection in UI/clients
+        files_list = []
+        vfiles = version_info.get("files", []) or []
+        if isinstance(vfiles, list):
+            for f in vfiles:
+                if not isinstance(f, dict):
+                    continue
+                _fmeta = (f.get("metadata") or {})
+                files_list.append({
+                    "id": f.get("id"),
+                    "name": f.get("name"),
+                    "size_kb": f.get("sizeKB"),
+                    "format": _fmeta.get("format"),
+                    "model_size": _fmeta.get("size"),
+                    "precision": _guess_precision(f),
+                    "downloadable": bool(f.get("downloadUrl")),
+                })
+
+        # --- Return curated data ---
+        return web.json_response({
+            "success": True,
+            "model_id": target_model_id,
+            "version_id": target_version_id,
+            "model_name": model_name,
+            "version_name": version_info.get('name', 'Unknown Version'),
+            "creator_username": creator_username,
+            "model_type": model_type,
+            "description_html": description_html, # Send raw HTML (frontend should handle display safely)
+            "version_description_html": version_description_html,
+            "stats": {
+                "downloads": download_count,
+                "likes": likes_count,
+                "dislikes": dislikes_count,
+                "buzz": buzz_count,
+            },
+            "file_info": {
+                "name": file_name,
+                "size_kb": file_size_kb,
+                "format": file_format,
+                "model_size": file_model_size,
+                "precision": file_precision,
+            },
+            "files": files_list,
+            "thumbnail_url": thumbnail_url,
+            "nsfw_level": nsfw_level,
+            # Optionally include basic version info like baseModel
+            "base_model": version_info.get("baseModel", "N/A"),
+            # You could add tags here too if desired: model_info.get('tags', [])
+        })
+
+    except web.HTTPError as http_err:
+        # Consistent error handling (copied from route_download_model)
+        print(f"[Server GetDetails] HTTP Error: {http_err.status} {http_err.reason}")
+        body_detail = ""
+        try:
+            body_detail = await http_err.text() if hasattr(http_err, 'text') else http_err.body.decode('utf-8', errors='ignore') if http_err.body else ""
+            if body_detail.startswith('{') and body_detail.endswith('}'): body_detail = json.loads(body_detail)
+        except Exception: pass
+        return web.json_response({"success": False, "error": http_err.reason, "details": body_detail or "No details", "status_code": http_err.status}, status=http_err.status)
+
+    except Exception as e:
+        # Consistent error handling (copied from route_download_model)
+        print("--- Unhandled Error in /civitai/get_model_details ---")
+        traceback.print_exc()
+        print("--- End Error ---")
+        return web.json_response({"success": False, "error": "Internal Server Error", "details": f"An unexpected error occurred: {str(e)}", "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/GetModelDirs.py

@@ -0,0 +1,216 @@
+# ================================================
+# File: server/routes/GetModelDirs.py
+# ================================================
+import os
+import json
+from aiohttp import web
+
+import server  # ComfyUI server instance
+from ...utils.helpers import get_model_dir, sanitize_filename
+from ...config import PLUGIN_ROOT
+import folder_paths
+
+prompt_server = server.PromptServer.instance
+
+CUSTOM_ROOTS_FILE = os.path.join(PLUGIN_ROOT, "custom_roots.json")
+
+def _load_custom_roots():
+    try:
+        if os.path.exists(CUSTOM_ROOTS_FILE):
+            with open(CUSTOM_ROOTS_FILE, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    # Normalize values to lists of strings
+                    return {k: [str(p) for p in (v or []) if isinstance(p, str)] for k, v in data.items()}
+    except Exception as e:
+        print(f"[Civicomfy] Warning: Failed to load custom roots: {e}")
+    return {}
+
+def _save_custom_roots(data):
+    try:
+        with open(CUSTOM_ROOTS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2)
+        return True
+    except Exception as e:
+        print(f"[Civicomfy] Error writing custom roots file: {e}")
+        return False
+
+def _get_all_roots_for_type(model_type: str):
+    model_type = (model_type or '').lower().strip()
+    roots = []
+    try:
+        # Preferred: ask ComfyUI for all registered directories for this type
+        get_fp = getattr(folder_paths, 'get_folder_paths', None)
+        if callable(get_fp):
+            lst = get_fp(model_type)
+            if isinstance(lst, (list, tuple)):
+                roots.extend([os.path.abspath(p) for p in lst if isinstance(p, str)])
+        else:
+            d = folder_paths.get_directory_by_type(model_type)
+            if d:
+                roots.append(os.path.abspath(d))
+    except Exception:
+        # Fallback to our main model dir for type
+        d = get_model_dir(model_type)
+        if d:
+            roots.append(os.path.abspath(d))
+
+    custom = _load_custom_roots().get(model_type, [])
+    for p in custom:
+        ap = os.path.abspath(p)
+        if ap not in roots:
+            roots.append(ap)
+    # Include all immediate subdirectories inside the main ComfyUI models folder
+    try:
+        models_dir = getattr(folder_paths, 'models_dir', None)
+        if not models_dir:
+            base = getattr(folder_paths, 'base_path', os.getcwd())
+            models_dir = os.path.join(base, 'models')
+        if os.path.isdir(models_dir):
+            for name in os.listdir(models_dir):
+                p = os.path.join(models_dir, name)
+                if os.path.isdir(p):
+                    ap = os.path.abspath(p)
+                    if ap not in roots:
+                        roots.append(ap)
+    except Exception as e:
+        print(f"[Civicomfy] Warning: Failed to enumerate models dir subfolders: {e}")
+    return roots
+
+def _list_subdirs(root_dir: str, max_entries: int = 5000):
+    """Return a sorted list of relative subdirectory paths under root_dir, including nested."""
+    rel_dirs = set()
+    root_dir = os.path.abspath(root_dir)
+    count = 0
+    for current, dirs, _files in os.walk(root_dir):
+        # Avoid following symlinks to reduce risk
+        abs_current = os.path.abspath(current)
+        try:
+            rel = os.path.relpath(abs_current, root_dir)
+        except Exception:
+            continue
+        if rel == ".":
+            rel = ""  # represent root as empty
+        rel_dirs.add(rel)
+        count += 1
+        if count >= max_entries:
+            break
+    return sorted(rel_dirs)
+
+@prompt_server.routes.get("/civitai/model_dirs")
+async def route_get_model_dirs(request):
+    """List the base directory (or provided root) and all subdirectories for a given model type."""
+    model_type = request.query.get("type", "checkpoint").lower().strip()
+    root = (request.query.get("root") or "").strip()
+    try:
+        base_dir = root if root else get_model_dir(model_type)
+        subdirs = _list_subdirs(base_dir)
+        return web.json_response({
+            "model_type": model_type,
+            "base_dir": base_dir,
+            "subdirs": subdirs,  # relative paths, "" represents the base root
+        })
+    except Exception as e:
+        return web.json_response({"error": "Failed to list directories", "details": str(e)}, status=500)
+
+@prompt_server.routes.post("/civitai/create_dir")
+async def route_create_model_dir(request):
+    """Create a new subdirectory under a model type's base directory."""
+    try:
+        data = await request.json()
+        model_type = (data.get("model_type") or "checkpoint").lower().strip()
+        new_dir = (data.get("new_dir") or "").strip()
+        if not new_dir:
+            return web.json_response({"error": "Missing 'new_dir'"}, status=400)
+
+        # If client provided an explicit root, prefer it
+        base_dir = (data.get("root") or "").strip() or get_model_dir(model_type)
+
+        # Normalize and sanitize each part; disallow absolute and traversal
+        norm = os.path.normpath(new_dir.replace("\\", "/"))
+        parts = [p for p in norm.split("/") if p and p not in (".", "..")]
+        safe_parts = [sanitize_filename(p) for p in parts]
+        rel_path = os.path.join(*safe_parts) if safe_parts else ""
+        if not rel_path:
+            return web.json_response({"error": "Invalid folder name"}, status=400)
+
+        abs_path = os.path.abspath(os.path.join(base_dir, rel_path))
+        # Ensure it remains inside base_dir
+        if os.path.commonpath([abs_path, os.path.abspath(base_dir)]) != os.path.abspath(base_dir):
+            return web.json_response({"error": "Invalid path"}, status=400)
+
+        os.makedirs(abs_path, exist_ok=True)
+        return web.json_response({
+            "success": True,
+            "created": rel_path,
+            "abs_path": abs_path,
+        })
+    except Exception as e:
+        return web.json_response({"error": "Failed to create directory", "details": str(e)}, status=500)
+
+@prompt_server.routes.post("/civitai/create_model_type")
+async def route_create_model_type(request):
+    """Create a new first-level folder under the main models directory."""
+    try:
+        data = await request.json()
+        name = (data.get("name") or "").strip()
+        if not name:
+            return web.json_response({"error": "Missing 'name'"}, status=400)
+
+        # Sanitize folder name to a single path component
+        from ...utils.helpers import sanitize_filename
+        safe = sanitize_filename(name)
+        if not safe:
+            return web.json_response({"error": "Invalid folder name"}, status=400)
+
+        # Resolve models directory
+        models_dir = getattr(folder_paths, 'models_dir', None)
+        if not models_dir:
+            base = getattr(folder_paths, 'base_path', os.getcwd())
+            models_dir = os.path.join(base, 'models')
+
+        abs_path = os.path.abspath(os.path.join(models_dir, safe))
+        # Ensure it remains inside models_dir
+        if os.path.commonpath([abs_path, os.path.abspath(models_dir)]) != os.path.abspath(models_dir):
+            return web.json_response({"error": "Invalid path"}, status=400)
+
+        os.makedirs(abs_path, exist_ok=True)
+        return web.json_response({"success": True, "name": safe, "path": abs_path})
+    except Exception as e:
+        return web.json_response({"error": "Failed to create model type folder", "details": str(e)}, status=500)
+
+@prompt_server.routes.get("/civitai/model_roots")
+async def route_get_model_roots(request):
+    """Return all known root directories for a model type (ComfyUI + plugin custom roots)."""
+    model_type = request.query.get("type", "checkpoint").lower().strip()
+    roots = _get_all_roots_for_type(model_type)
+    return web.json_response({
+        "model_type": model_type,
+        "roots": roots,
+    })
+
+@prompt_server.routes.post("/civitai/create_root")
+async def route_create_model_root(request):
+    """Create a new root directory for a model type and register it in plugin config.
+       Note: ComfyUI may require restart to recognize this root globally; the plugin uses it immediately.
+    """
+    try:
+        data = await request.json()
+        model_type = (data.get("model_type") or "checkpoint").lower().strip()
+        abs_path = (data.get("path") or "").strip()
+        if not abs_path:
+            return web.json_response({"error": "Missing 'path'"}, status=400)
+        # Normalize to absolute path
+        abs_path = os.path.abspath(abs_path)
+        # Create directory if missing
+        os.makedirs(abs_path, exist_ok=True)
+        roots = _load_custom_roots()
+        current = roots.get(model_type, [])
+        if abs_path not in current:
+            current.append(abs_path)
+            roots[model_type] = current
+            if not _save_custom_roots(roots):
+                return web.json_response({"error": "Failed to persist custom root"}, status=500)
+        return web.json_response({"success": True, "path": abs_path})
+    except Exception as e:
+        return web.json_response({"error": "Failed to create root", "details": str(e)}, status=500)

custom_nodes/Civicomfy/server/routes/GetModelTypes.py

@@ -0,0 +1,31 @@
+# ================================================
+# File: server/routes/GetModelTypes.py
+# ================================================
+import os
+from aiohttp import web
+import server # ComfyUI server instance
+import folder_paths
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.get("/civitai/model_types")
+async def route_get_model_types(request):
+    """API Endpoint to get the known model types and their mapping."""
+    try:
+        # Dynamically list all first-level folders under the main models directory
+        models_dir = getattr(folder_paths, 'models_dir', None)
+        if not models_dir:
+            base = getattr(folder_paths, 'base_path', os.getcwd())
+            models_dir = os.path.join(base, 'models')
+        if not os.path.isdir(models_dir):
+            return web.json_response({})
+
+        entries = {}
+        for name in sorted(os.listdir(models_dir)):
+            p = os.path.join(models_dir, name)
+            if os.path.isdir(p):
+                entries[name] = name
+        return web.json_response(entries)
+    except Exception as e:
+        print(f"Error getting model types: {e}")
+        return web.json_response({"error": "Internal Server Error", "details": str(e), "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/GetStatus.py

@@ -0,0 +1,19 @@
+# ================================================
+# File: server/routes/GetStatus.py
+# ================================================
+from aiohttp import web
+import server # ComfyUI server instance
+from ...downloader.manager import manager as download_manager
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.get("/civitai/status")
+async def route_get_status(request):
+    """API Endpoint to get the status of downloads."""
+    try:
+        status = download_manager.get_status()
+        return web.json_response(status)
+    except Exception as e:
+        print(f"Error getting download status: {e}")
+        # Format error response consistently
+        return web.json_response({"error": "Internal Server Error", "details": f"Failed to get status: {str(e)}", "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/OpenPath.py

@@ -0,0 +1,58 @@
+# ================================================
+# File: server/routes/OpenPath.py
+# ================================================
+import asyncio
+import json
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ...downloader.manager import manager as download_manager
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/open_path")
+async def route_open_path(request):
+    """API Endpoint to open the containing folder of a completed download."""
+    if not download_manager:
+        return web.json_response({"error": "Download Manager not initialized"}, status=500)
+
+    try:
+        data = await request.json()
+        download_id = data.get("download_id")
+
+        if not download_id:
+            return web.json_response({"error": "Missing 'download_id'", "details": "The request body must contain the 'download_id' of the completed item."}, status=400)
+
+        print(f"[API Route /civitai/open_path] Received open path request for ID: {download_id}")
+        # Call manager method in thread
+        result = await asyncio.to_thread(download_manager.open_containing_folder, download_id)
+
+        status_code = 200 if result.get("success") else 404 if "not found" in result.get("error", "").lower() else 400 # Use 400 for OS error, security etc
+        # Check for specific errors to return better codes
+        if not result.get("success"):
+             error_lower = result.get("error", "").lower()
+             if "directory does not exist" in error_lower or "id not found" in error_lower:
+                 status_code = 404
+             elif "cannot open path" in error_lower or "unsupported os" in error_lower or "failed to open" in error_lower or "xdg-open" in error_lower:
+                 status_code = 501 # Not Implemented / Failed on server side
+             elif "must be 'completed'" in error_lower:
+                  status_code = 409 # Conflict - wrong state
+             else:
+                 status_code = 400 # Bad Request / general failure
+
+        # Prevent sensitive path info leakage in error messages by default
+        if not result.get("success") and "error" in result and status_code != 200:
+             print(f"[API Route /civitai/open_path] Error for ID {download_id}: {result['error']}") # Log full error on server
+             # Optionally sanitize error sent to client
+             # if "Directory:" in result["error"] or "Path:" in result["error"]:
+             #    result["error"] = "Server failed to open the specified directory."
+
+        return web.json_response(result, status=status_code)
+
+    except json.JSONDecodeError:
+        return web.json_response({"error": "Invalid JSON body"}, status=400)
+    except Exception as e:
+        import traceback
+        print(f"Error handling /civitai/open_path request for ID '{data.get('download_id', 'N/A')}': {e}")
+        # traceback.print_exc()
+        return web.json_response({"error": "Internal Server Error", "details": f"An unexpected error occurred: {str(e)}"}, status=500)

custom_nodes/Civicomfy/server/routes/RetryDownload.py

@@ -0,0 +1,39 @@
+# ================================================
+# File: server/routes/RetryDownload.py
+# ================================================
+import asyncio
+import json
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ...downloader.manager import manager as download_manager
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/retry")
+async def route_retry_download(request):
+    """API Endpoint to retry a failed/cancelled download."""
+    if not download_manager:
+        return web.json_response({"error": "Download Manager not initialized"}, status=500)
+
+    try:
+        data = await request.json()
+        download_id = data.get("download_id")
+
+        if not download_id:
+            return web.json_response({"error": "Missing 'download_id'", "details": "The request body must contain the 'download_id' of the item to retry."}, status=400)
+
+        print(f"[API Route /civitai/retry] Received retry request for ID: {download_id}")
+        # Call manager method (which handles locking)
+        result = await asyncio.to_thread(download_manager.retry_download, download_id) # Run sync manager method in thread
+
+        status_code = 200 if result.get("success") else 404 if "not found" in result.get("error", "").lower() else 400
+        return web.json_response(result, status=status_code)
+
+    except json.JSONDecodeError:
+        return web.json_response({"error": "Invalid JSON body"}, status=400)
+    except Exception as e:
+        import traceback
+        print(f"Error handling /civitai/retry request for ID '{data.get('download_id', 'N/A')}': {e}")
+        # traceback.print_exc() # Uncomment for detailed logs
+        return web.json_response({"error": "Internal Server Error", "details": f"An unexpected error occurred: {str(e)}"}, status=500)

custom_nodes/Civicomfy/server/routes/SearchModels.py

@@ -0,0 +1,154 @@
+# ================================================
+# File: server/routes/SearchModels.py
+# ================================================
+import json
+import math
+import traceback
+from aiohttp import web
+
+import server # ComfyUI server instance
+from ..utils import get_request_json
+from ...api.civitai import CivitaiAPI
+from ...config import CIVITAI_API_TYPE_MAP
+
+prompt_server = server.PromptServer.instance
+
+@prompt_server.routes.post("/civitai/search")
+async def route_search_models(request):
+    """API Endpoint for searching models using Civitai's Meilisearch."""
+    api_key = None # Meili might not use the standard key
+    try:
+        data = await get_request_json(request)
+
+        query = data.get("query", "").strip()
+        model_type_keys = data.get("model_types", []) # e.g., ["lora", "checkpoint"] (frontend internal keys)
+        base_model_filters = data.get("base_models", []) # e.g., ["SD 1.5", "Pony"]
+        sort = data.get("sort", "Most Downloaded") # Frontend display value
+        # Make period optional or remove if not supported by Meili sort directly
+        # period = data.get("period", "AllTime")
+        limit = int(data.get("limit", 20))
+        page = int(data.get("page", 1))
+        api_key = data.get("api_key", "") # Keep for potential future use or different endpoints
+        nsfw = data.get("nsfw", None) # Expect Boolean or None
+
+        if not query and not model_type_keys and not base_model_filters:
+             raise web.HTTPBadRequest(reason="Search requires a query or at least one filter (type or base model).")
+
+        # Instantiate API - API key might not be needed for Meili public search
+        api = CivitaiAPI(api_key or None)
+
+        # --- Prepare Filters for Meili API call ---
+
+        # 1. Map internal type keys to Civitai API 'type' names (used in Meili filter)
+        # This assumes Meili filters on the uppercase names like "LORA", "Checkpoint"
+        api_types_filter = []
+        if isinstance(model_type_keys, list) and model_type_keys and "any" not in model_type_keys:
+            for key in model_type_keys:
+                # Map key.lower() for robustness - use the existing map from config
+                # CIVITAI_API_TYPE_MAP maps internal key -> Civitai API type name (e.g. 'lora' -> 'LORA')
+                api_type = CIVITAI_API_TYPE_MAP.get(key.lower())
+                # Ensure we handle cases where the map might return None or duplicate types
+                if api_type and api_type not in api_types_filter:
+                    api_types_filter.append(api_type)
+
+        # 2. Base Model Filters (assume frontend sends exact names like "SD 1.5")
+        valid_base_models = []
+        if isinstance(base_model_filters, list) and base_model_filters:
+             # Optional: Validate against known list?
+             valid_base_models = [bm for bm in base_model_filters if isinstance(bm, str) and bm]
+             # Example validation (optional):
+             # valid_base_models = [bm for bm in base_model_filters if bm in AVAILABLE_MEILI_BASE_MODELS]
+             # if len(valid_base_models) != len(base_model_filters):
+             #     print("Warning: Some provided base model filters were invalid.")
+
+        # --- Call the New API Method ---
+        print(f"[Server Search] Meili: query='{query if query else '<none>'}', types={api_types_filter or 'Any'}, baseModels={valid_base_models or 'Any'}, sort={sort}, nsfw={nsfw}, limit={limit}, page={page}")
+
+        # Call the new search method
+        meili_results = api.search_models_meili(
+             query=query or None, # Meili handles empty query if filters exist
+             types=api_types_filter or None,
+             base_models=valid_base_models or None,
+             sort=sort, # Pass the frontend value, mapping happens inside search_models_meili
+             limit=limit,
+             page=page,
+             nsfw=nsfw
+        )
+
+        # Handle API error response from CivitaiAPI helper
+        if meili_results and isinstance(meili_results, dict) and "error" in meili_results:
+             status_code = meili_results.get("status_code", 500) or 500
+             reason = f"Civitai API Meili Search Error: {meili_results.get('details', meili_results.get('error', 'Unknown error'))}"
+             raise web.HTTPException(reason=reason, status=status_code, body=json.dumps(meili_results))
+
+        # --- Process Meili Response for Frontend ---
+        if meili_results and isinstance(meili_results, dict) and "hits" in meili_results:
+              processed_items = []
+              image_base_url = "https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7QA" # Base URL for images
+
+              for hit in meili_results.get("hits", []):
+                   if not isinstance(hit, dict): continue # Skip invalid hits
+
+                   thumbnail_url = None
+                   # Get thumbnail from images array (prefer first image)
+                   images = hit.get("images")
+                   if images and isinstance(images, list) and len(images) > 0:
+                       first_image = images[0]
+                       # Ensure first image is a dict with a 'url' field
+                       if isinstance(first_image, dict) and first_image.get("url"):
+                           image_id = first_image["url"]
+                           # Construct URL with a default width (e.g., 256 or 450)
+                           thumbnail_url = f"{image_base_url}/{image_id}/width=256" # Adjust width as needed
+
+                   # Extract latest version info (Meili response includes 'version' object for the primary version)
+                   latest_version_info = hit.get("version", {}) or {} # Ensure it's a dict
+
+                   # Prepare item structure for frontend (can pass raw hit + extras, or build a specific structure)
+                   # Let's pass the raw `hit` and add the `thumbnailUrl` and potentially other processed fields.
+                   hit['thumbnailUrl'] = thumbnail_url # Add processed thumbnail URL directly to the hit object
+
+                   # Optional: Add more processed fields if needed, e.g., formatted stats
+                   # hit['processedStats'] = { ... }
+
+                   processed_items.append(hit)
+
+              # --- Calculate Pagination Info ---
+              total_hits = meili_results.get("estimatedTotalHits", 0)
+              current_page = page # Use the requested page number
+              total_pages = math.ceil(total_hits / limit) if limit > 0 else 0
+
+              # --- Return Structure for Frontend ---
+              response_data = {
+                  "items": processed_items, # The array of processed hits
+                  "metadata": {
+                      "totalItems": total_hits,
+                      "currentPage": current_page,
+                      "pageSize": limit, # The limit used for the request
+                      "totalPages": total_pages,
+                      # Meili provides offset, limit, processingTimeMs which could also be passed if useful
+                      "meiliProcessingTimeMs": meili_results.get("processingTimeMs"),
+                      "meiliOffset": meili_results.get("offset"),
+                  }
+              }
+              return web.json_response(response_data)
+        else:
+             # Handle unexpected format from API or empty results
+             print(f"[Server Search] Warning: Unexpected Meili search result format or empty hits: {meili_results}")
+             return web.json_response({"items": [], "metadata": {"totalItems": 0, "currentPage": page, "pageSize": limit, "totalPages": 0}}, status=500)
+
+    # --- Keep existing error handlers ---
+    except web.HTTPError as http_err:
+         # ... (keep existing HTTP error handling) ...
+         body_detail = ""
+         try:
+              body_detail = await http_err.text() if hasattr(http_err, 'text') else http_err.body.decode('utf-8', errors='ignore') if http_err.body else ""
+              if body_detail.startswith('{') and body_detail.endswith('}'): body_detail = json.loads(body_detail)
+         except Exception: pass
+         return web.json_response({"error": http_err.reason, "details": body_detail or "No details", "status_code": http_err.status}, status=http_err.status)
+
+    except Exception as e:
+        # ... (keep existing generic error handling) ...
+        print("--- Unhandled Error in /civitai/search ---")
+        traceback.print_exc()
+        print("--- End Error ---")
+        return web.json_response({"error": "Internal Server Error", "details": f"An unexpected search error occurred: {str(e)}", "status_code": 500}, status=500)

custom_nodes/Civicomfy/server/routes/__init__.py

@@ -0,0 +1,21 @@
+# ================================================
+# File: server/routes/__init__.py
+# ================================================
+# This file imports all the individual route modules.
+# When the `routes` package is imported by `server/__init__.py`,
+# these imports will be executed, registering the routes with the
+# ComfyUI server instance.
+
+from . import CancelDownload
+from . import ClearHistory
+from . import DownloadModel
+from . import GetBaseModels
+from . import GetModelDetails
+from . import GetModelTypes
+from . import GetModelDirs
+from . import GetStatus
+from . import OpenPath
+from . import RetryDownload
+from . import SearchModels
+
+print("[Civicomfy] All server route modules loaded.")

custom_nodes/Civicomfy/server/utils.py

@@ -0,0 +1,154 @@
+# ================================================
+# File: server/utils.py
+# ================================================
+import json
+from typing import Any, Dict, Optional
+from aiohttp import web
+
+# Import necessary components from our modules
+from ..api.civitai import CivitaiAPI
+from ..utils.helpers import parse_civitai_input, select_primary_file
+
+async def get_request_json(request):
+    """Safely get JSON data from request."""
+    try:
+        return await request.json()
+    except Exception as e:
+        print(f"Error parsing request JSON: {e}")
+        raise web.HTTPBadRequest(reason=f"Invalid JSON format: {e}")
+
+async def get_civitai_model_and_version_details(api: CivitaiAPI, model_url_or_id: str, req_version_id: Optional[int]) -> Dict[str, Any]:
+    """
+    Helper to fetch Civitai details.
+    Prioritizes fetching model info based on resolved Model ID.
+    Fetches specific version info if version ID is provided/resolved, otherwise latest.
+    Returns a dict with 'model_info', 'version_info', 'primary_file', and resolved IDs.
+    Raises HTTP exceptions on critical failures.
+    """
+    target_model_id = None
+    target_version_id = None
+    potential_version_id_from_input = None
+    model_info = {}
+    version_info_to_use = {} # The version (specific or latest) whose file we'll use
+    primary_file = None
+
+    # --- 1. Parse Input to get potential IDs ---
+    parsed_model_id, parsed_version_id = parse_civitai_input(model_url_or_id)
+
+    # Determine the initial target model ID (input URL/ID takes precedence)
+    target_model_id = parsed_model_id
+
+    # Determine the specific version requested (explicit param > URL param)
+    if req_version_id and str(req_version_id).isdigit():
+        try:
+            potential_version_id_from_input = int(req_version_id)
+        except (ValueError, TypeError):
+             print(f"[API Helper] Warning: Invalid req_version_id: {req_version_id}. Ignoring.")
+    elif parsed_version_id:
+        potential_version_id_from_input = parsed_version_id
+
+    # --- 2. Ensure we have a Model ID ---
+    # If we only got a version ID from the input (e.g., civitai.com/model-versions/456),
+    # we need to fetch that version *first* just to find the model ID.
+    if not target_model_id and potential_version_id_from_input:
+        print(f"[API Helper] Input requires fetching version {potential_version_id_from_input} first to find model ID.")
+        temp_version_info = api.get_model_version_info(potential_version_id_from_input)
+        if temp_version_info and "error" not in temp_version_info and temp_version_info.get('modelId'):
+            target_model_id = temp_version_info['modelId']
+            print(f"[API Helper] Found Model ID {target_model_id} from Version ID {potential_version_id_from_input}.")
+            # We might reuse temp_version_info later if this was the specifically requested version
+        else:
+            err = temp_version_info.get('details', 'Could not find model ID from version') if isinstance(temp_version_info, dict) else 'API error'
+            raise web.HTTPNotFound(reason=f"Could not determine Model ID from Version ID {potential_version_id_from_input}", body=json.dumps({"error": f"Version {potential_version_id_from_input} not found or missing modelId", "details": err}))
+
+    # If still no model ID after potential lookup, fail
+    if not target_model_id:
+        raise web.HTTPBadRequest(reason="Could not determine a valid Model ID from the input.")
+
+    # --- 3. Fetch Core Model Information (Always based on target_model_id) ---
+    print(f"[API Helper] Fetching core model info for Model ID: {target_model_id}")
+    model_info_result = api.get_model_info(target_model_id)
+    if not model_info_result or "error" in model_info_result:
+        err_details = model_info_result.get('details', 'Unknown API error') if isinstance(model_info_result, dict) else 'Unknown API error'
+        raise web.HTTPNotFound(reason=f"Model {target_model_id} not found or API error", body=json.dumps({"error": f"Model {target_model_id} not found or API error", "details": err_details}))
+    model_info = model_info_result # Store the successfully fetched model info
+
+    # --- 4. Determine and Fetch Version Info for File Details ---
+    if potential_version_id_from_input:
+        # User specified a version explicitly, fetch its details
+        print(f"[API Helper] Fetching specific version info for Version ID: {potential_version_id_from_input}")
+        target_version_id = potential_version_id_from_input # This is the version we need info for
+        # Check if we already fetched this during Model ID lookup
+        if 'temp_version_info' in locals() and temp_version_info.get('id') == target_version_id:
+             print("[API Helper] Reusing version info fetched earlier.")
+             version_info_to_use = temp_version_info
+        else:
+            version_info_result = api.get_model_version_info(target_version_id)
+            if not version_info_result or "error" in version_info_result:
+                err_details = version_info_result.get('details', 'Unknown API error') if isinstance(version_info_result, dict) else 'Unknown API error'
+                raise web.HTTPNotFound(reason=f"Specified Version {target_version_id} not found or API error", body=json.dumps({"error": f"Version {target_version_id} not found or API error", "details": err_details}))
+            version_info_to_use = version_info_result
+    else:
+        # No specific version requested, find latest/default from model_info
+        print(f"[API Helper] Finding latest/default version for Model ID: {target_model_id}")
+        versions = model_info.get("modelVersions")
+        if not versions or not isinstance(versions, list) or len(versions) == 0:
+            raise web.HTTPNotFound(reason=f"Model {target_model_id} has no listed model versions.")
+
+        # Find the 'best' default version (usually first published)
+        default_version_summary = next((v for v in versions if v.get('status') == 'Published'), versions[0])
+        target_version_id = default_version_summary.get('id')
+        if not target_version_id:
+            raise web.HTTPNotFound(reason=f"Model {target_model_id}'s latest version has no ID.")
+
+        print(f"[API Helper] Using latest/default Version ID: {target_version_id}. Fetching its full details.")
+        # Fetch full details for this latest version
+        version_info_result = api.get_model_version_info(target_version_id)
+        if not version_info_result or "error" in version_info_result:
+             # Log error, but maybe try to proceed with summary data if desperate? Risky.
+            err_details = version_info_result.get('details', 'Unknown error getting full version') if isinstance(version_info_result, dict) else 'Error'
+            print(f"[API Helper] Warning: Could not fetch full details for latest version {target_version_id}. Details: {err_details}. Falling back to summary.")
+            # Use summary data from model_info as fallback - file info might be missing!
+            version_info_to_use = default_version_summary
+            # Ensure minimal structure for file finding later
+            version_info_to_use['files'] = version_info_to_use.get('files', [])
+            version_info_to_use['images'] = version_info_to_use.get('images', [])
+            version_info_to_use['modelId'] = version_info_to_use.get('modelId', target_model_id) # Ensure modelId is present
+            version_info_to_use['model'] = version_info_to_use.get('model', {'name': model_info.get('name', 'Unknown')}) # Add fallback model name
+
+        else:
+            version_info_to_use = version_info_result
+
+    # --- 5. Find Primary File from the Determined Version (version_info_to_use) ---
+    print(f"[API Helper] Finding primary file for Version ID: {target_version_id}")
+    files = version_info_to_use.get("files", [])
+    if not isinstance(files, list): files = []
+
+    # Handle fallback downloadUrl at version level if 'files' is empty/missing
+    if not files and 'downloadUrl' in version_info_to_use and version_info_to_use['downloadUrl']:
+        print("[API Helper] Warning: No 'files' array found, using version-level 'downloadUrl'.")
+        files = [{
+            "id": None, "name": version_info_to_use.get('name', f"version_{target_version_id}_file"),
+            "primary": True, "type": "Model", "sizeKB": version_info_to_use.get('fileSizeKB'),
+            "downloadUrl": version_info_to_use['downloadUrl'], "hashes": {}, "metadata": {}
+        }]
+
+    if not files:
+        raise web.HTTPNotFound(reason=f"Version {target_version_id} (Name: {version_info_to_use.get('name', 'N/A')}) has no files listed.")
+
+    # Use the centralized helper to select the best file
+    primary_file = select_primary_file(files)
+
+    if not primary_file:
+        raise web.HTTPNotFound(reason=f"Could not find any usable file with a download URL for version {target_version_id}.")
+
+    print(f"[API Helper] Selected file: Name='{primary_file.get('name', 'N/A')}', SizeKB={primary_file.get('sizeKB')}")
+
+    # --- 6. Return Results ---
+    return {
+        "model_info": model_info,                  # Always the full model info
+        "version_info": version_info_to_use,       # Info for the specific/latest version
+        "primary_file": primary_file,              # The file from that version
+        "target_model_id": target_model_id,        # Resolved model ID
+        "target_version_id": target_version_id,    # Resolved version ID (specific or latest)
+    }

custom_nodes/Civicomfy/utils/helpers.py

@@ -0,0 +1,289 @@
+# ================================================
+# File: utils/helpers.py
+# ================================================
+import os
+import urllib.parse
+import re 
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+import folder_paths 
+
+# Import config values needed here
+from ..config import PLUGIN_ROOT, MODEL_TYPE_DIRS
+
+def get_model_dir(model_type: str) -> str:
+    """
+    Resolve the absolute directory path for a model type using ComfyUI's
+    folder_paths manager. Respects extra_model_paths.yaml and symlinks.
+    Ensures the directory exists.
+    """
+    model_type_raw = (model_type or "").strip()
+    model_type_key = model_type_raw.lower()
+
+    display_and_type = MODEL_TYPE_DIRS.get(model_type_key)
+    folder_paths_type = None
+    if display_and_type:
+        _, folder_paths_type = display_and_type
+
+    if display_and_type and folder_paths_type:
+        try:
+            # Preferred: ask ComfyUI for the configured directory for this type
+            full_path = folder_paths.get_directory_by_type(folder_paths_type)
+            # If API returned a falsy value, try alternative lookups
+            if not full_path:
+                raise RuntimeError(f"No directory registered for type '{folder_paths_type}'")
+        except Exception:
+            # Fallback: assume a subdirectory under models_dir
+            print(f"Warning: Could not resolve path for type '{folder_paths_type}' via folder_paths. Falling back to models_dir.")
+            # Try get_folder_paths first
+            full_path = None
+            try:
+                get_fp = getattr(folder_paths, 'get_folder_paths', None)
+                if callable(get_fp):
+                    paths_list = get_fp(folder_paths_type)
+                    if isinstance(paths_list, (list, tuple)) and paths_list:
+                        full_path = paths_list[0]
+            except Exception:
+                pass
+            if not full_path:
+                models_dir = getattr(folder_paths, 'models_dir', None)
+                if not models_dir:
+                    # Last resort: try to infer a models dir near base_path
+                    base = getattr(folder_paths, 'base_path', os.getcwd())
+                    models_dir = os.path.join(base, 'models')
+                full_path = os.path.join(models_dir, folder_paths_type)
+    else:
+        # Treat model_type as a literal folder under the main models directory
+        models_dir = getattr(folder_paths, 'models_dir', None)
+        if not models_dir:
+            base = getattr(folder_paths, 'base_path', os.getcwd())
+            models_dir = os.path.join(base, 'models')
+        # Use the raw (case-preserving) folder name
+        full_path = os.path.join(models_dir, model_type_raw)
+
+    # Ensure the directory exists
+    try:
+        # Ensure full_path is a string path
+        if not isinstance(full_path, (str, bytes, os.PathLike)):
+            raise TypeError(f"Resolved directory for '{model_type_key}' is invalid: {full_path!r}")
+        os.makedirs(full_path, exist_ok=True)
+    except Exception as e:
+        print(f"Error: Could not create directory '{full_path}': {e}")
+
+    return full_path
+
+def parse_civitai_input(url_or_id: str) -> tuple[int | None, int | None]:
+    """
+    Parses Civitai URL or ID string.
+    Returns: (model_id, version_id) tuple. Both can be None.
+    Handles URLs like /models/123 and /models/123?modelVersionId=456
+    """
+    if not url_or_id:
+        return None, None
+
+    url_or_id = str(url_or_id).strip()
+    model_id: int | None = None
+    version_id: int | None = None
+    query_params = {}
+
+    # Check if it's just a number (could be model or version ID)
+    # Treat digits-only input as MODEL ID primarily, as users often copy just that.
+    # Version ID can be specified separately or via full URL query param.
+    if url_or_id.isdigit():
+        try:
+            # Assume it's a Model ID if just digits are provided.
+             model_id = int(url_or_id)
+             print(f"Parsed input '{url_or_id}' as Model ID.")
+             # Don't assume it's a version ID here. Let it be specified if needed.
+             return model_id, None
+        except (ValueError, TypeError):
+              print(f"Warning: Could not parse '{url_or_id}' as a numeric ID.")
+              return None, None
+
+    # If not just digits, try parsing as URL
+    try:
+        parsed_url = urllib.parse.urlparse(url_or_id)
+
+        # Basic check for URL structure and domain
+        if not parsed_url.scheme or not parsed_url.netloc:
+            # Maybe it's a path like /models/123 without the domain?
+            if url_or_id.startswith(("/models/", "/model-versions/")):
+                 # Re-parse with a dummy scheme and domain
+                 parsed_url = urllib.parse.urlparse("https://civitai.com" + url_or_id)
+                 if not parsed_url.path: # If still fails, give up
+                      print(f"Input '{url_or_id}' is not a recognizable Civitai path or URL.")
+                      return None, None
+            else:
+                 print(f"Input '{url_or_id}' is not a valid ID or Civitai URL/path.")
+                 return None, None
+
+        # Check domain if it was present
+        if parsed_url.netloc and "civitai.com" not in parsed_url.netloc.lower():
+            print(f"Input URL '{url_or_id}' is not a Civitai URL.")
+            return None, None
+
+        # Extract path components and query parameters
+        path_parts = [p for p in parsed_url.path.split('/') if p] # Remove empty parts
+        query_params = urllib.parse.parse_qs(parsed_url.query)
+
+        # --- Logic ---
+        # 1. Check query params for modelVersionId FIRST (most explicit)
+        if 'modelVersionId' in query_params:
+            try:
+                version_id = int(query_params['modelVersionId'][0])
+                print(f"Found Version ID {version_id} in query parameters.")
+            except (ValueError, IndexError, TypeError):
+                print(f"Warning: Found modelVersionId in query but couldn't parse: {query_params.get('modelVersionId')}")
+                version_id = None # Reset if parsing failed
+
+        # 2. Check path for /models/ID
+        model_id_from_path = None
+        if "models" in path_parts:
+             try:
+                 models_index = path_parts.index("models")
+                 if models_index + 1 < len(path_parts):
+                     # Take the part right after /models/ and check if it's digits
+                     potential_id_str = path_parts[models_index + 1]
+                     if potential_id_str.isdigit():
+                          model_id_from_path = int(potential_id_str)
+                          print(f"Found Model ID {model_id_from_path} in URL path.")
+             except (ValueError, IndexError, TypeError):
+                  print(f"Warning: Found /models/ in path but couldn't parse ID from {path_parts}")
+
+        # 3. Check path for /model-versions/ID (less common, usually doesn't contain model ID)
+        version_id_from_path = None
+        if version_id is None and "model-versions" in path_parts: # Only check if not found in query
+             try:
+                 versions_index = path_parts.index("model-versions")
+                 if versions_index + 1 < len(path_parts):
+                     potential_id_str = path_parts[versions_index + 1]
+                     if potential_id_str.isdigit():
+                           version_id_from_path = int(potential_id_str)
+                           # Set version_id only if not already set by query param
+                           if version_id is None:
+                                version_id = version_id_from_path
+                                print(f"Found Version ID {version_id} in URL path.")
+             except (ValueError, IndexError, TypeError):
+                  print(f"Warning: Found /model-versions/ in path but couldn't parse ID from {path_parts}")
+
+        # 4. Assign final model ID (prefer path over digits-only assumption if URL was parsed)
+        if model_id_from_path is not None:
+             model_id = model_id_from_path
+        # If no model ID found yet and input looked like a URL, maybe it was ONLY a version URL?
+        elif model_id is None and version_id is not None:
+            print("Warning: Found Version ID but no Model ID in the URL. Model info might be incomplete.")
+         # Keep the initially parsed model_id if input was digits-only
+
+    except Exception as e:
+        print(f"Error parsing Civitai input '{url_or_id}': {e}")
+        return None, None
+
+    print(f"Parsed Civitai input: Model ID = {model_id}, Version ID = {version_id}")
+    # Return the determined IDs. It's the caller's responsibility to fetch model info if only version ID is present.
+    return model_id, version_id
+
+# Updated sanitize_filename to be more restrictive
+def sanitize_filename(filename: str, default_filename: str = "downloaded_model") -> str:
+    """
+    Stricter filename sanitization. Replaces invalid characters, trims whitespace,
+    handles reserved names (Windows), and ensures it's not empty.
+    Aims for better cross-OS compatibility.
+    """
+    if not filename:
+        return default_filename
+
+    # Decode if bytes
+    if isinstance(filename, bytes):
+        try:
+            filename = filename.decode('utf-8')
+        except UnicodeDecodeError:
+            # If decode fails, fall back to a safe default representation or hex
+            # For simplicity, just use default for now if decoding problematic bytes
+            return default_filename + "_decode_error"
+
+    # Remove characters invalid for Windows/Linux/MacOS filenames
+    # Invalid Chars: < > : " / \ | ? * and control characters (0-31)
+    # Also replace NULL character just in case.
+    sanitized = re.sub(r'[\x00-\x1f<>:"/\\|?*]', '_', filename)
+
+    # Replace sequences of multiple underscores or spaces introduced by replacement
+    sanitized = re.sub(r'[_ ]{2,}', '_', sanitized)
+
+    # Remove leading/trailing whitespace, dots, underscores
+    sanitized = sanitized.strip('. _')
+
+    # Windows Reserved Names (case-insensitive)
+    reserved_names = {'CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'}
+     # Check base name without extension
+    base_name, ext = os.path.splitext(sanitized)
+    if base_name.upper() in reserved_names:
+         sanitized = f"_{base_name}_{ext}" # Prepend underscore
+
+    # Prevent names that are just '.' or '..' (though stripping dots should handle this)
+    if sanitized == '.' or sanitized == '..':
+        sanitized = default_filename + "_invalid_name"
+
+     # If sanitization results in an empty string (unlikely now), use default
+    if not sanitized:
+        sanitized = default_filename
+
+    # Optional: Limit overall length (e.g., 200 chars), considering path limits
+    # Be careful as some systems have path limits, not just filename limits
+    max_len = 200 # A reasonable limit for the filename itself
+    if len(sanitized) > max_len:
+         name_part, ext_part = os.path.splitext(sanitized)
+         # Truncate the name part, ensuring total length is within max_len
+         allowed_name_len = max_len - len(ext_part)
+         if allowed_name_len <= 0: # Handle case where extension itself is too long
+              sanitized = sanitized[:max_len] # Truncate forcefully
+         else:
+              sanitized = name_part[:allowed_name_len] + ext_part
+         print(f"Warning: Sanitized filename truncated to {max_len} characters.")
+
+    return sanitized
+    
+def select_primary_file(files: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """
+    Selects the best file from a list of files based on a heuristic.
+    Prefers primary, then safetensors, then pruned, etc.
+    Returns the selected file dictionary or None.
+    """
+    if not files or not isinstance(files, list):
+        return None
+
+    # First, try to find a file explicitly marked as "primary" with a valid download URL
+    primary_marked_file = next((f for f in files if isinstance(f, dict) and f.get("primary") and f.get('downloadUrl')), None)
+    if primary_marked_file:
+        return primary_marked_file
+
+    # If no primary file is marked, sort all available files using a heuristic
+    def sort_key(file_obj):
+        if not isinstance(file_obj, dict): return 99
+        if not file_obj.get('downloadUrl'): return 98 # Deprioritize files without URL
+
+        name_lower = file_obj.get("name", "").lower()
+        meta = file_obj.get("metadata", {}) or {}
+        format_type = meta.get("format", "").lower()
+        size_type = meta.get("size", "").lower()
+        
+        # Fallback to file extension if format metadata missing
+        is_safetensor = ".safetensors" in name_lower or format_type == "safetensor"
+        is_pickle = ".ckpt" in name_lower or ".pt" in name_lower or format_type == "pickletensor"
+        is_pruned = size_type == "pruned"
+
+        if is_safetensor and is_pruned: return 0
+        if is_safetensor: return 1
+        if is_pickle and is_pruned: return 2
+        if is_pickle: return 3
+        # Prioritize model files over others like VAEs if type is available
+        if file_obj.get("type") == "Model": return 4
+        if file_obj.get("type") == "Pruned Model": return 5
+        return 10 # Other types last
+
+    valid_files = [f for f in files if isinstance(f, dict) and f.get("downloadUrl")]
+    if not valid_files:
+        return None
+        
+    sorted_files = sorted(valid_files, key=sort_key)
+    return sorted_files[0]

custom_nodes/Civicomfy/web/js/api/civitai.js

@@ -0,0 +1,144 @@
+// API client for Civicomfy UI
+// Wraps ComfyUI's fetchApi with consistent error handling
+
+import { api } from "../../../../scripts/api.js";
+
+export class CivitaiDownloaderAPI {
+  static async _request(endpoint, options = {}) {
+    try {
+      const url = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+      const response = await api.fetchApi(url, options);
+
+      if (!response.ok) {
+        let errorData;
+        const status = response.status;
+        const statusText = response.statusText;
+        try {
+          errorData = await response.json();
+          if (typeof errorData !== "object" || errorData === null) {
+            errorData = { detail: String(errorData) };
+          }
+        } catch (_) {
+          const detailText = await response.text().catch(() => `Status ${status} - Could not read error text`);
+          errorData = {
+            error: `HTTP error ${status}`,
+            details: String(detailText).substring(0, 500),
+          };
+        }
+        const err = new Error(errorData.error || errorData.reason || `HTTP Error: ${status} ${statusText}`);
+        err.details = errorData.details || errorData.detail || errorData.error || "No details provided.";
+        err.status = status;
+        throw err;
+      }
+
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      if (!error.details) error.details = error.message;
+      throw error;
+    }
+  }
+
+  static async downloadModel(params) {
+    return await this._request("/civitai/download", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+  }
+
+  static async getModelDetails(params) {
+    return await this._request("/civitai/get_model_details", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+  }
+
+  static async getStatus() {
+    return await this._request("/civitai/status");
+  }
+
+  static async cancelDownload(downloadId) {
+    return await this._request("/civitai/cancel", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ download_id: downloadId }),
+    });
+  }
+
+  static async searchModels(params) {
+    return await this._request("/civitai/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+  }
+
+  static async getBaseModels() {
+    return await this._request("/civitai/base_models");
+  }
+
+  static async getModelTypes() {
+    return await this._request("/civitai/model_types");
+  }
+
+  static async getModelDirs(modelType) {
+    const q = encodeURIComponent(modelType || 'checkpoint');
+    return await this._request(`/civitai/model_dirs?type=${q}`);
+  }
+
+  static async createModelDir(modelType, newDir) {
+    return await this._request("/civitai/create_dir", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model_type: modelType, new_dir: newDir }),
+    });
+  }
+
+  static async createModelType(name) {
+    return await this._request("/civitai/create_model_type", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name }),
+    });
+  }
+
+  static async getModelRoots(modelType) {
+    const q = encodeURIComponent(modelType || 'checkpoint');
+    return await this._request(`/civitai/model_roots?type=${q}`);
+  }
+
+  static async createModelRoot(modelType, absPath) {
+    return await this._request("/civitai/create_root", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model_type: modelType, path: absPath }),
+    });
+  }
+
+  static async retryDownload(downloadId) {
+    return await this._request("/civitai/retry", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ download_id: downloadId }),
+    });
+  }
+
+  static async openPath(downloadId) {
+    return await this._request("/civitai/open_path", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ download_id: downloadId }),
+    });
+  }
+
+  static async clearHistory() {
+    return await this._request("/civitai/clear_history", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+}

custom_nodes/Civicomfy/web/js/civitaiDownloader.css

@@ -0,0 +1,731 @@
+.civitai-downloader-modal {
+    position: fixed;
+    z-index: 1001; /* Above ComfyUI elements */
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    overflow: hidden; /* Prevent body scroll */
+    background-color: rgba(0, 0, 0, 0.6);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.3s ease, visibility 0s linear 0.3s;
+}
+
+.civitai-downloader-modal.open {
+    opacity: 1;
+    visibility: visible;
+    transition: opacity 0.3s ease, visibility 0s linear 0s;
+}
+
+.civitai-downloader-modal-content {
+    background-color: var(--comfy-menu-bg);
+    color: var(--comfy-text-color);
+    margin: auto;
+    padding: 0; /* Remove padding, handle internally */
+    border-radius: 8px;
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+    width: 900px;
+    max-width: 95%;
+    height: 700px; /* Fixed height */
+    max-height: 90vh;
+    display: flex; /* Use flexbox for layout */
+    flex-direction: column; /* Stack header, tabs, content */
+    overflow: hidden; /* Prevent content overflow */
+}
+
+.civitai-downloader-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 15px 20px;
+    border-bottom: 1px solid var(--border-color, #444);
+    flex-shrink: 0; /* Prevent header from shrinking */
+}
+
+.civitai-downloader-header h2 {
+    margin: 0;
+    font-size: 1.3em;
+}
+
+.civitai-close-button {
+    background: none;
+    border: none;
+    color: var(--comfy-text-color);
+    font-size: 28px;
+    cursor: pointer;
+    padding: 0 5px;
+    line-height: 1;
+}
+.civitai-close-button:hover {
+    color: #aaa;
+}
+
+.civitai-downloader-body {
+    display: flex;
+    flex-direction: column;
+    flex-grow: 1; /* Allow body to take remaining space */
+    overflow: hidden; /* Manage internal scrolling */
+}
+
+.civitai-downloader-tabs {
+    display: flex;
+    border-bottom: 1px solid var(--border-color, #444);
+    padding: 0 15px;
+    flex-shrink: 0; /* Prevent tabs from shrinking */
+}
+
+.civitai-downloader-tab {
+    padding: 10px 18px;
+    cursor: pointer;
+    border: none;
+    background: none;
+    color: var(--comfy-text-color);
+    opacity: 0.7;
+    position: relative;
+    top: 1px; /* Align with bottom border */
+    margin-bottom: -1px; /* Overlap border */
+}
+
+.civitai-downloader-tab.active {
+    opacity: 1;
+    border-bottom: 3px solid var(--accent-color, #5c8aff);
+    font-weight: bold;
+}
+.civitai-downloader-tab:hover {
+    opacity: 1;
+}
+
+.civitai-downloader-tab-content {
+    display: none;
+    padding: 20px;
+    flex-grow: 1; /* Allow content to take space */
+    overflow-y: auto; /* Enable scrolling ONLY for the content area */
+}
+
+.civitai-downloader-tab-content.active {
+    display: block; /* Show active tab */
+}
+
+.civitai-form-group {
+    margin-bottom: 18px;
+}
+.civitai-form-group:last-child {
+    margin-bottom: 0;
+}
+
+.civitai-form-group label {
+    display: block;
+    margin-bottom: 6px;
+    font-weight: bold;
+    font-size: 0.95em;
+}
+
+.civitai-input,
+.civitai-select {
+    width: 100%;
+    padding: 10px;
+    background-color: var(--comfy-input-bg);
+    color: var(--comfy-text-color);
+    border: 1px solid var(--border-color, #555);
+    border-radius: 4px;
+    box-sizing: border-box; /* Include padding/border in width */
+}
+.civitai-input:focus,
+.civitai-select:focus {
+    outline: none;
+    border-color: var(--accent-color, #5c8aff);
+    box-shadow: 0 0 0 2px rgba(92, 138, 255, 0.3);
+}
+
+.civitai-form-row {
+    display: flex;
+    gap: 15px;
+    flex-wrap: wrap; /* Allow wrapping on smaller screens */
+}
+.civitai-form-row > .civitai-form-group {
+    flex: 1; /* Distribute space */
+    min-width: 180px; /* Minimum width before wrapping */
+}
+/* Adjust for checkbox/inline elements */
+.civitai-form-group.inline {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 10px; /* Less margin for checkboxes */
+}
+.civitai-form-group.inline label {
+    margin-bottom: 0; /* Remove default bottom margin */
+    order: 1; /* Put label after checkbox */
+}
+.civitai-checkbox {
+    width: auto;
+    order: 0; /* Put checkbox before label */
+    accent-color: var(--accent-color, #5c8aff);
+    transform: scale(1.1);
+}
+
+.civitai-button {
+    background-color: var(--comfy-input-bg);
+    color: var(--comfy-text-color);
+    border: 1px solid var(--border-color, #555);
+    padding: 10px 18px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 1em;
+    transition: background-color 0.2s ease, border-color 0.2s ease;
+}
+.civitai-button:hover {
+    background-color: var(--comfy-input-bg-hover);
+    border-color: #777;
+}
+.civitai-button:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.civitai-button.primary {
+    background-color: var(--accent-color, #5c8aff);
+    border-color: var(--accent-color, #5c8aff);
+    color: white;
+}
+.civitai-button.primary:hover {
+    background-color: #4a7ee0; /* Slightly darker blue */
+    border-color: #4a7ee0;
+}
+.civitai-button.primary:disabled {
+    background-color: var(--accent-color, #5c8aff); /* Keep color but lower opacity */
+    border-color: var(--accent-color, #5c8aff);
+}
+
+.civitai-button.danger {
+    background-color: #e64b4b;
+    border-color: #e64b4b;
+    color: white;
+}
+.civitai-button.danger:hover {
+    background-color: #d93a3a;
+    border-color: #d93a3a;
+}
+.civitai-button.small {
+    padding: 5px 10px;
+    font-size: 0.85em;
+}
+
+/* Status Tab Styling */
+.civitai-status-section {
+    margin-bottom: 25px;
+}
+.civitai-status-section h3 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    border-bottom: 1px solid var(--border-color, #444);
+    padding-bottom: 8px;
+    font-size: 1.1em;
+}
+
+.civitai-download-list {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.civitai-download-item {
+    display: flex;
+    gap: 15px;
+    align-items: flex-start; /* Align items top */
+    padding: 15px;
+    border-radius: 6px;
+    background-color: var(--comfy-input-bg); /* Slightly different bg for items */
+    border: 1px solid var(--border-color, #555);
+}
+
+.civitai-download-thumbnail {
+    width: 80px;
+    height: 80px;
+    object-fit: cover;
+    border-radius: 4px;
+    background-color: #333; /* Placeholder color */
+    flex-shrink: 0; /* Don't shrink thumbnail */
+    margin-top: 3px; /* Align better with text */
+}
+
+.civitai-download-info {
+    flex-grow: 1; /* Allow info to take available space */
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+    overflow: hidden; /* Prevent long text overflow */
+}
+.civitai-download-info strong {
+    font-size: 1.05em;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.civitai-download-info p {
+    margin: 0;
+    font-size: 0.9em;
+    color: #ccc;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.civitai-download-info .filename {
+   font-style: italic;
+   color: #bbb;
+}
+.civitai-download-info .error-message {
+   color: #ff6b6b;
+   font-size: 0.85em;
+   white-space: normal; /* Allow error message to wrap */
+   word-break: break-word;
+}
+
+.civitai-download-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-left: auto; /* Push actions to the right */
+    flex-shrink: 0; /* Don't shrink action buttons */
+}
+
+.civitai-progress-container {
+    margin-top: 8px;
+    width: 100%;
+    background-color: var(--comfy-menu-bg); /* Darker background for contrast */
+    border-radius: 4px;
+    overflow: hidden;
+    height: 20px;
+    border: 1px solid var(--border-color, #555);
+}
+
+.civitai-progress-bar {
+    height: 100%;
+    background-color: var(--accent-color, #5c8aff);
+    text-align: center;
+    color: white;
+    line-height: 20px; /* Center text vertically */
+    font-size: 12px;
+    font-weight: bold;
+    transition: width 0.3s ease-out;
+    min-width: 20px; /* Show something even for 0% */
+    width: 0%; /* Start at 0 */
+    white-space: nowrap;
+    overflow: hidden;
+}
+.civitai-progress-bar.completed {
+    background-color: #4caf50; /* Green for completed */
+}
+.civitai-progress-bar.failed {
+    background-color: #f44336; /* Red for failed */
+}
+.civitai-progress-bar.cancelled {
+    background-color: #9e9e9e; /* Grey for cancelled */
+}
+
+.civitai-speed-indicator {
+    font-size: 0.85em;
+    color: #ccc;
+    margin-top: 4px;
+    text-align: right;
+}
+
+/* Search Tab Styling */
+.civitai-search-controls {
+    display: flex;
+    gap: 15px;
+    margin-bottom: 20px;
+    flex-wrap: wrap;
+}
+.civitai-search-controls .civitai-input {
+    flex-grow: 1; /* Let search input take more space */
+}
+.civitai-search-controls .civitai-select {
+    min-width: 150px; /* Min width for dropdowns */
+}
+.civitai-search-controls .civitai-button {
+    align-self: flex-end; /* Align button with bottom of inputs */
+}
+
+.civitai-search-results {
+    margin-top: 20px;
+}
+.civitai-search-item {
+    display: flex;
+    gap: 15px;
+    align-items: flex-start;
+    margin-bottom: 15px;
+    padding: 15px;
+    border-radius: 6px;
+    background-color: var(--comfy-input-bg);
+    border: 1px solid var(--border-color, #555);
+    transition: background-color 0.2s ease;
+}
+
+.civitai-thumbnail-container {
+    position: relative; /* Required for absolute positioning of the child badge */
+    display: block; 
+    line-height: 0; 
+    width: 120px;
+    height: 170px;
+    flex-shrink: 0; 
+}
+
+.civitai-search-thumbnail {
+    width: 120px; /* Slightly larger for search */
+    height: 170px;
+    object-fit: cover;
+    border-radius: 4px;
+    background-color: #333;
+    flex-shrink: 0;
+}
+
+.civitai-search-meta-info {
+    font-size: 0.85em;
+    color: #aaa; 
+    margin-bottom: 5px;
+    display: flex;
+    gap: 15px; 
+    flex-wrap: wrap; 
+}
+
+.civitai-search-meta-info span {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px; 
+}
+
+.civitai-search-meta-info i {
+    color: #ccc; 
+}
+.civitai-type-badge {
+    position: absolute;
+    bottom: 5px;         /* Adjust spacing from bottom */
+    left: 5px;           /* Adjust spacing from left */
+    background-color: rgb(48, 94, 70); /* Black background with transparency */
+    color: white; 
+    padding: 10px 8px;    /* Adjust padding (top/bottom, left/right) */
+    border-radius: 10px; /* Adjust for desired roundness */
+    font-size: 0.75em;   /* Adjust font size */
+    font-weight: bold; 
+    z-index: 2;          /* Ensure it's above the image */
+    white-space: nowrap; /* Prevent text wrapping */
+}
+
+.civitai-search-info {
+    flex-grow: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+    overflow: hidden;
+}
+.civitai-search-info h4 {
+    margin: 0;
+    font-size: 1.1em;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.civitai-search-info p {
+    margin: 0;
+    font-size: 0.9em;
+    color: #ccc;
+}
+.civitai-search-tags {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 5px;
+    margin-top: 8px;
+}
+.civitai-search-tag {
+    background-color: rgba(255, 255, 255, 0.1);
+    color: #eee;
+    padding: 3px 8px;
+    border-radius: 10px;
+    font-size: 0.8em;
+}
+.civitai-search-stats span {
+    margin-right: 15px;
+    font-size: 0.85em;
+    color: #bbb;
+}
+.civitai-search-stats i { /* If using icons */
+    margin-right: 4px;
+}
+
+.civitai-search-actions {
+    display: flex;
+    flex-direction: column; /* Stack buttons vertically */
+    gap: 8px;
+    align-items: flex-end; /* Align buttons to the right */
+    margin-left: auto;
+    flex-shrink: 0;
+}
+
+.version-buttons-container {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end; 
+    gap: 5px;
+}
+
+.all-versions-container {
+    display: flex;
+    flex-direction: column; 
+    gap: 5px;
+    padding-bottom: 5px;
+    white-space: nowrap; /* Prevent wrapping */
+    max-width: 100%; /* Prevent excessive width */
+    align-items: flex-end; 
+}
+
+.show-all-versions-button {
+    align-self: flex-end; /* Align button to left */
+    margin-top: auto; /* Push to the bottom */
+}
+.base-model-badge {
+    display: inline-block; /* Allows padding and background */
+    background-color: #3a3a3a;  /* Or a specific purple hex code like #800080 */
+    color: white;
+    font-weight: bold;
+    padding: 2px 6px;       /* Adjust padding for desired size (vertical horizontal) */
+    border-radius: 3px;     /* Adjust for desired roundness */
+    margin-right: 4px;     /* Optional: Adds some space between badge and hyphen */
+    line-height: 1;        /* Optional: Can help contain the background better */
+    vertical-align: middle; /* Optional: Helps align the badge nicely with text */
+}
+
+
+/* Settings Tab Styling */
+.civitai-settings-container {
+    display: grid;
+    grid-template-columns: 1fr; /* Single column */
+    gap: 20px;
+}
+
+@media (min-width: 768px) {
+    .civitai-settings-container {
+        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); /* Responsive columns */
+    }
+}
+
+.civitai-settings-section {
+    background-color: var(--comfy-input-bg);
+    padding: 15px;
+    border-radius: 6px;
+    border: 1px solid var(--border-color, #555);
+}
+.civitai-settings-section h4 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    border-bottom: 1px solid var(--border-color, #444);
+    padding-bottom: 8px;
+}
+
+.civitai-toast {
+    position: fixed;
+    bottom: 20px;
+    left: 50%;
+    transform: translateX(-50%);
+    background-color: rgba(0, 0, 0, 0.8);
+    color: white;
+    padding: 12px 20px;
+    border-radius: 6px;
+    z-index: 1005; /* Above modal */
+    font-size: 0.95em;
+    opacity: 0;
+    transition: opacity 0.3s ease, bottom 0.3s ease;
+    pointer-events: none; /* Don't block clicks */
+}
+
+.civitai-toast.show {
+    opacity: 1;
+    bottom: 30px;
+}
+
+.civitai-toast.success {
+    background-color: rgba(76, 175, 80, 0.9); /* Green */
+}
+
+.civitai-toast.error {
+    background-color: rgba(244, 67, 54, 0.9); /* Red */
+}
+
+.civitai-toast.info {
+    background-color: rgba(33, 150, 243, 0.9); /* Blue */
+}
+
+/* Tooltip Styles */
+[data-tooltip] {
+  position: relative;
+  cursor: help;
+}
+[data-tooltip]::after {
+  content: attr(data-tooltip);
+  position: absolute;
+  left: 50%;
+  transform: translateX(-50%);
+  bottom: 100%;
+  margin-bottom: 5px;
+  background-color: rgba(0, 0, 0, 0.85);
+  color: white;
+  padding: 5px 10px;
+  border-radius: 4px;
+  font-size: 0.85em;
+  white-space: nowrap;
+  opacity: 0;
+  visibility: hidden;
+  transition: opacity 0.2s ease, visibility 0.2s ease;
+  z-index: 1010; /* Ensure tooltip is on top */
+}
+[data-tooltip]:hover::after {
+  opacity: 1;
+  visibility: visible;
+}
+
+.civitai-download-preview-area {
+    /* Add specific margins/padding if needed */
+     min-height: 50px; /* Ensure it has some height for the loading spinner */
+}
+
+/* Style for the description box */
+.model-description-content {
+    max-height: 200px; /* Limit height */
+    overflow-y: auto; /* Allow scrolling */
+    background-color: var(--comfy-input-bg); /* Match input background */
+    padding: 10px;
+    border-radius: 4px;
+    font-size: 0.9em; /* Slightly smaller text */
+    border: 1px solid var(--border-color, #555);
+    color: var(--comfy-text-color); /* Ensure text color matches */
+    line-height: 1.5; /* Improve readability */
+}
+
+/* Style links within the description */
+.model-description-content a {
+    color: var(--accent-color, #5c8aff); /* Make links stand out */
+    text-decoration: underline;
+}
+.model-description-content a:hover {
+    color: #8bb0ff; /* Lighter color on hover */
+}
+
+/* Ensure reused search item styles look okay in this context */
+.civitai-download-preview-area .civitai-search-item {
+    margin-bottom: 15px; /* Add space below the item */
+     background-color: var(--comfy-input-bg); /* Explicitly set background */
+}
+
+/* --- Confirmation Modal Styles --- */
+.civitai-confirmation-modal {
+    display: none; /* Hidden by default */
+    position: fixed; /* Stay in place */
+    z-index: 1001; /* Ensure it's above the main modal */
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    overflow: auto; /* Enable scroll if needed */
+    background-color: rgba(0,0,0,0.6); /* Dim background */
+    /* Use flexbox for easy centering */
+    justify-content: center;
+    align-items: center;
+}
+
+.civitai-confirmation-modal-content {
+    background-color: var(--comfy-menu-bg, #282828);
+    margin: auto;
+    padding: 25px;
+    border: 1px solid var(--border-color, #444);
+    border-radius: 8px;
+    width: 80%;
+    max-width: 450px; /* Limit width */
+    box-shadow: 0 5px 15px rgba(0,0,0,0.3);
+    color: var(--input-text, #ddd);
+}
+
+.civitai-confirmation-modal-content h4 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    color: var(--desc-text, #eee);
+    border-bottom: 1px solid var(--border-color, #444);
+    padding-bottom: 10px;
+}
+
+.civitai-confirmation-modal-content p {
+    margin-bottom: 25px;
+    line-height: 1.5;
+    font-size: 0.95em;
+}
+
+.civitai-confirmation-modal-actions {
+    display: flex;
+    justify-content: flex-end; /* Align buttons to the right */
+    gap: 10px; /* Space between buttons */
+}
+
+/* Style buttons within the confirmation modal */
+.civitai-confirmation-modal-actions .civitai-button {
+    padding: 8px 15px; /* Adjust padding */
+    min-width: 80px; /* Ensure minimum width */
+}
+
+/* Ensure both img and video within the thumbnail container behave similarly */
+.civitai-thumbnail-container img.civitai-search-thumbnail,
+.civitai-thumbnail-container video.civitai-search-thumbnail,
+.civitai-thumbnail-container img.civitai-download-thumbnail,
+.civitai-thumbnail-container video.civitai-download-thumbnail {
+    display: block; /* Prevent extra space below */
+    width: 100%;    /* Fill the container width */
+    height: 100%;   /* Fill the container height */
+    object-fit: cover; /* Scale while maintaining aspect ratio, cropping if needed */
+    background-color: #333; /* Background for loading/error states */
+}
+
+/* You might already have rules for the container itself, ensure they define a size */
+.civitai-thumbnail-container {
+    width: 100px; /* Example size */
+    height: 140px; /* Example size */
+    overflow: hidden; /* Hide parts of the video/image outside the cover area */
+    position: relative; /* For positioning badges etc. */
+    flex-shrink: 0; /* Prevent shrinking in flex layouts */
+    border-radius: 4px; /* Match styling */
+}
+
+/* Blur/Hide for R-rated thumbnails */
+.civitai-thumbnail-container.blurred img.civitai-search-thumbnail,
+.civitai-thumbnail-container.blurred video.civitai-search-thumbnail,
+.civitai-thumbnail-container.blurred img.civitai-download-thumbnail,
+.civitai-thumbnail-container.blurred video.civitai-download-thumbnail {
+    filter: blur(14px) brightness(0.6) saturate(0.6);
+    pointer-events: none; /* Let clicks hit the container */
+}
+.civitai-thumbnail-container .civitai-nsfw-overlay {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #fff;
+    font-weight: 800;
+    font-size: 20px;
+    letter-spacing: 1px;
+    background: rgba(0,0,0,0.35);
+    z-index: 3;
+    user-select: none;
+}
+/* Make it obvious it’s clickable */
+.civitai-thumbnail-container.blurred { cursor: pointer; }
+
+/* Style for the type badge (likely exists) */
+.civitai-type-badge {
+    /* ... existing styles ... */
+    position: absolute;
+    bottom: 5px;
+    right: 5px;
+    /* ... */
+}

custom_nodes/Civicomfy/web/js/civitaiDownloader.js

@@ -0,0 +1,89 @@
+import { app } from "../../../scripts/app.js";
+import { addCssLink } from "./utils/dom.js";
+import { CivitaiDownloaderUI } from "./ui/UI.js";
+
+console.log("Loading Civicomfy UI...");
+
+// --- Configuration ---
+const EXTENSION_NAME = "Civicomfy";
+const CSS_URL = `../civitaiDownloader.css`;
+const PLACEHOLDER_IMAGE_URL = `/extensions/Civicomfy/images/placeholder.jpeg`;
+
+// Add Menu Button to ComfyUI
+function addMenuButton() {
+    const buttonGroup = document.querySelector(".comfyui-button-group");
+
+    if (!buttonGroup) {
+        console.warn(`[${EXTENSION_NAME}] ComfyUI button group not found. Retrying...`);
+        setTimeout(addMenuButton, 500);
+        return;
+    }
+
+    if (document.getElementById("civitai-downloader-button")) {
+        console.log(`[${EXTENSION_NAME}] Button already exists.`);
+        return;
+    }
+
+    const civitaiButton = document.createElement("button");
+    civitaiButton.textContent = "Civicomfy";
+    civitaiButton.id = "civitai-downloader-button";
+    civitaiButton.title = "Open Civicomfy";
+
+    civitaiButton.onclick = async () => {
+        if (!window.civitaiDownloaderUI) {
+            console.info(`[${EXTENSION_NAME}] Creating CivitaiDownloaderUI instance...`);
+            window.civitaiDownloaderUI = new CivitaiDownloaderUI();
+            document.body.appendChild(window.civitaiDownloaderUI.modal);
+
+            try {
+                await window.civitaiDownloaderUI.initializeUI();
+                console.info(`[${EXTENSION_NAME}] UI Initialization complete.`);
+            } catch (error) {
+                console.error(`[${EXTENSION_NAME}] Error during UI initialization:`, error);
+                window.civitaiDownloaderUI?.showToast("Error initializing UI components. Check console.", "error", 5000);
+            }
+        }
+
+        if (window.civitaiDownloaderUI) {
+            window.civitaiDownloaderUI.openModal();
+        } else {
+            console.error(`[${EXTENSION_NAME}] Cannot open modal: UI instance not available.`);
+            alert("Civicomfy failed to initialize. Please check the browser console for errors.");
+        }
+    };
+
+    buttonGroup.appendChild(civitaiButton);
+    console.log(`[${EXTENSION_NAME}] Civicomfy button added to .comfyui-button-group.`);
+
+    const menu = document.querySelector(".comfy-menu");
+    if (!buttonGroup.contains(civitaiButton) && menu && !menu.contains(civitaiButton)) {
+        console.warn(`[${EXTENSION_NAME}] Failed to append button to group, falling back to menu.`);
+        const settingsButton = menu.querySelector("#comfy-settings-button");
+        if (settingsButton) {
+            settingsButton.insertAdjacentElement("beforebegin", civitaiButton);
+        } else {
+            menu.appendChild(civitaiButton);
+        }
+    }
+}
+
+// --- Initialization ---
+app.registerExtension({
+    name: "Civicomfy.CivitaiDownloader",
+    async setup(appInstance) {
+        console.log(`[${EXTENSION_NAME}] Setting up Civicomfy Extension...`);
+        addCssLink(CSS_URL);
+        addMenuButton();
+
+        // Optional: Pre-check placeholder image
+        fetch(PLACEHOLDER_IMAGE_URL)
+            .then(res => {
+                if (!res.ok) {
+                    console.warn(`[${EXTENSION_NAME}] Placeholder image not found at ${PLACEHOLDER_IMAGE_URL}.`);
+                }
+            })
+            .catch(err => console.warn(`[${EXTENSION_NAME}] Error checking for placeholder image:`, err));
+
+        console.log(`[${EXTENSION_NAME}] Extension setup complete. UI will initialize on first click.`);
+    },
+});

custom_nodes/Civicomfy/web/js/ui/UI.js

@@ -0,0 +1,437 @@
+import { Feedback } from "./feedback.js";
+import { setupEventListeners } from "./handlers/eventListeners.js";
+import { handleDownloadSubmit, fetchAndDisplayDownloadPreview, debounceFetchDownloadPreview } from "./handlers/downloadHandler.js";
+import { handleSearchSubmit } from "./handlers/searchHandler.js";
+import { handleSettingsSave, loadAndApplySettings, loadSettingsFromCookie, saveSettingsToCookie, applySettings, getDefaultSettings } from "./handlers/settingsHandler.js";
+import { startStatusUpdates, stopStatusUpdates, updateStatus, handleCancelDownload, handleRetryDownload, handleOpenPath, handleClearHistory } from "./handlers/statusHandler.js";
+import { renderSearchResults } from "./searchRenderer.js";
+import { renderDownloadList } from "./statusRenderer.js";
+import { renderDownloadPreview } from "./previewRenderer.js";
+import { modalTemplate } from "./templates.js";
+import { CivitaiDownloaderAPI } from "../api/civitai.js";
+
+export class CivitaiDownloaderUI {
+    constructor() {
+        this.modal = null;
+        this.tabs = {};
+        this.tabContents = {};
+        this.activeTab = 'download';
+        this.modelTypes = {};
+        this.statusInterval = null;
+        this.statusData = { queue: [], active: [], history: [] };
+        this.baseModels = [];
+        this.searchPagination = { currentPage: 1, totalPages: 1, limit: 20 };
+        this.settings = this.getDefaultSettings();
+        this.toastTimeout = null;
+        this.modelPreviewDebounceTimeout = null;
+
+        this.updateStatus();
+        this.buildModalHTML();
+        this.cacheDOMElements();
+        this.setupEventListeners();
+        this.feedback = new Feedback(this.modal.querySelector('#civitai-toast'));
+        // Ensure icon stylesheet is loaded so buttons render icons immediately
+        this.ensureFontAwesome();
+    }
+
+    // --- Core UI Methods ---
+    buildModalHTML() {
+        this.modal = document.createElement('div');
+        this.modal.className = 'civitai-downloader-modal';
+        this.modal.id = 'civitai-downloader-modal';
+        this.modal.innerHTML = modalTemplate(this.settings);
+    }
+
+    cacheDOMElements() {
+        this.closeButton = this.modal.querySelector('#civitai-close-modal');
+        this.tabContainer = this.modal.querySelector('.civitai-downloader-tabs');
+
+        // Download Tab
+        this.downloadForm = this.modal.querySelector('#civitai-download-form');
+        this.downloadPreviewArea = this.modal.querySelector('#civitai-download-preview-area');
+        this.modelUrlInput = this.modal.querySelector('#civitai-model-url');
+        this.modelVersionIdInput = this.modal.querySelector('#civitai-model-version-id');
+        this.downloadModelTypeSelect = this.modal.querySelector('#civitai-model-type');
+        this.createModelTypeButton = this.modal.querySelector('#civitai-create-model-type');
+        this.customFilenameInput = this.modal.querySelector('#civitai-custom-filename');
+        this.subdirSelect = this.modal.querySelector('#civitai-subdir-select');
+        this.createSubdirButton = this.modal.querySelector('#civitai-create-subdir');
+        this.downloadConnectionsInput = this.modal.querySelector('#civitai-connections');
+        this.forceRedownloadCheckbox = this.modal.querySelector('#civitai-force-redownload');
+        this.downloadSubmitButton = this.modal.querySelector('#civitai-download-submit');
+
+        // Search Tab
+        this.searchForm = this.modal.querySelector('#civitai-search-form');
+        this.searchQueryInput = this.modal.querySelector('#civitai-search-query');
+        this.searchTypeSelect = this.modal.querySelector('#civitai-search-type');
+        this.searchBaseModelSelect = this.modal.querySelector('#civitai-search-base-model');
+        this.searchSortSelect = this.modal.querySelector('#civitai-search-sort');
+        this.searchPeriodSelect = this.modal.querySelector('#civitai-search-period');
+        this.searchSubmitButton = this.modal.querySelector('#civitai-search-submit');
+        this.searchResultsContainer = this.modal.querySelector('#civitai-search-results');
+        this.searchPaginationContainer = this.modal.querySelector('#civitai-search-pagination');
+
+        // Status Tab
+        this.statusContent = this.modal.querySelector('#civitai-status-content');
+        this.activeListContainer = this.modal.querySelector('#civitai-active-list');
+        this.queuedListContainer = this.modal.querySelector('#civitai-queued-list');
+        this.historyListContainer = this.modal.querySelector('#civitai-history-list');
+        this.statusIndicator = this.modal.querySelector('#civitai-status-indicator');
+        this.activeCountSpan = this.modal.querySelector('#civitai-active-count');
+        this.clearHistoryButton = this.modal.querySelector('#civitai-clear-history-button');
+        this.confirmClearModal = this.modal.querySelector('#civitai-confirm-clear-modal');
+        this.confirmClearYesButton = this.modal.querySelector('#civitai-confirm-clear-yes');
+        this.confirmClearNoButton = this.modal.querySelector('#civitai-confirm-clear-no');
+
+        // Settings Tab
+        this.settingsForm = this.modal.querySelector('#civitai-settings-form');
+        this.settingsApiKeyInput = this.modal.querySelector('#civitai-settings-api-key');
+        this.settingsConnectionsInput = this.modal.querySelector('#civitai-settings-connections');
+        this.settingsDefaultTypeSelect = this.modal.querySelector('#civitai-settings-default-type');
+        this.settingsAutoOpenCheckbox = this.modal.querySelector('#civitai-settings-auto-open-status');
+        this.settingsHideMatureCheckbox = this.modal.querySelector('#civitai-settings-hide-mature');
+        this.settingsNsfwThresholdInput = this.modal.querySelector('#civitai-settings-nsfw-threshold');
+        this.settingsSaveButton = this.modal.querySelector('#civitai-settings-save');
+
+        // Toast Notification
+        this.toastElement = this.modal.querySelector('#civitai-toast');
+
+        // Collect tabs and contents
+        this.tabs = {};
+        this.modal.querySelectorAll('.civitai-downloader-tab').forEach(tab => {
+            this.tabs[tab.dataset.tab] = tab;
+        });
+        this.tabContents = {};
+        this.modal.querySelectorAll('.civitai-downloader-tab-content').forEach(content => {
+            const tabName = content.id.replace('civitai-tab-', '');
+            if (tabName) this.tabContents[tabName] = content;
+        });
+    }
+
+    async initializeUI() {
+        console.info("[Civicomfy] Initializing UI components...");
+        await this.populateModelTypes();
+        await this.populateBaseModels();
+        this.loadAndApplySettings();
+    }
+
+    async populateModelTypes() {
+        console.log("[Civicomfy] Populating model types...");
+        try {
+            const types = await CivitaiDownloaderAPI.getModelTypes();
+            if (!types || typeof types !== 'object' || Object.keys(types).length === 0) {
+                 throw new Error("Received invalid model types data format.");
+            }
+            this.modelTypes = types;
+            const sortedTypes = Object.entries(this.modelTypes).sort((a, b) => a[1].localeCompare(b[1]));
+
+            this.downloadModelTypeSelect.innerHTML = '';
+            this.searchTypeSelect.innerHTML = '<option value="any">Any Type</option>';
+            this.settingsDefaultTypeSelect.innerHTML = '';
+
+            sortedTypes.forEach(([key, displayName]) => {
+                const option = document.createElement('option');
+                option.value = key;
+                option.textContent = displayName;
+            this.downloadModelTypeSelect.appendChild(option.cloneNode(true));
+            this.settingsDefaultTypeSelect.appendChild(option.cloneNode(true));
+            this.searchTypeSelect.appendChild(option.cloneNode(true));
+        });
+        // After types are populated, load subdirs for the current selection
+        await this.loadAndPopulateSubdirs(this.downloadModelTypeSelect.value);
+        } catch (error) {
+            console.error("[Civicomfy] Failed to get or populate model types:", error);
+            this.showToast('Failed to load model types', 'error');
+            this.downloadModelTypeSelect.innerHTML = '<option value="checkpoint">Checkpoint (Default)</option>';
+            this.modelTypes = { "checkpoint": "Checkpoint (Default)" };
+        }
+    }
+
+    async loadAndPopulateSubdirs(modelType) {
+        try {
+            const res = await CivitaiDownloaderAPI.getModelDirs(modelType);
+            const select = this.subdirSelect;
+            if (!select) return;
+            const current = select.value;
+            select.innerHTML = '';
+            const optRoot = document.createElement('option');
+            optRoot.value = '';
+            optRoot.textContent = '(root)';
+            select.appendChild(optRoot);
+            if (res && Array.isArray(res.subdirs)) {
+                // res.subdirs contains '' for root; skip empty since we added (root)
+                res.subdirs.filter(p => p && typeof p === 'string').forEach(rel => {
+                    const opt = document.createElement('option');
+                    opt.value = rel;
+                    opt.textContent = rel;
+                    select.appendChild(opt);
+                });
+            }
+            // Restore selection if still present
+            if (Array.from(select.options).some(o => o.value === current)) {
+                select.value = current;
+            }
+        } catch (e) {
+            console.error('[Civicomfy] Failed to load subdirectories:', e);
+            if (this.subdirSelect) {
+                this.subdirSelect.innerHTML = '<option value="">(root)</option>';
+            }
+        }
+    }
+
+    // (loadAndPopulateRoots removed; dynamic types already reflect models/ subfolders)
+
+    async populateBaseModels() {
+        console.log("[Civicomfy] Populating base models...");
+        try {
+            const result = await CivitaiDownloaderAPI.getBaseModels();
+            if (!result || !Array.isArray(result.base_models)) {
+                throw new Error("Invalid base models data format received.");
+            }
+            this.baseModels = result.base_models.sort();
+            const existingOptions = Array.from(this.searchBaseModelSelect.options);
+            existingOptions.slice(1).forEach(opt => opt.remove());
+            this.baseModels.forEach(baseModelName => {
+                const option = document.createElement('option');
+                option.value = baseModelName;
+                option.textContent = baseModelName;
+                this.searchBaseModelSelect.appendChild(option);
+            });
+        } catch (error) {
+             console.error("[Civicomfy] Failed to get or populate base models:", error);
+             this.showToast('Failed to load base models list', 'error');
+        }
+    }
+
+    switchTab(tabId) {
+        if (this.activeTab === tabId || !this.tabs[tabId] || !this.tabContents[tabId]) return;
+
+        this.tabs[this.activeTab]?.classList.remove('active');
+        this.tabContents[this.activeTab]?.classList.remove('active');
+
+        this.tabs[tabId].classList.add('active');
+        this.tabContents[tabId].classList.add('active');
+        this.tabContents[tabId].scrollTop = 0;
+        this.activeTab = tabId;
+
+        if (tabId === 'status') this.updateStatus();
+        else if (tabId === 'settings') this.applySettings();
+        else if(tabId === 'download') {
+            this.downloadConnectionsInput.value = this.settings.numConnections;
+            if (Object.keys(this.modelTypes).length > 0) {
+                this.downloadModelTypeSelect.value = this.settings.defaultModelType;
+            }
+        }
+    }
+
+    // --- Modal Control ---
+    openModal() {
+        this.modal?.classList.add('open');
+        document.body.style.setProperty('overflow', 'hidden', 'important');
+        this.startStatusUpdates();
+        if (this.activeTab === 'status') this.updateStatus();
+        if (!this.settings.apiKey) this.switchTab('settings');
+    }
+
+    closeModal() {
+        this.modal?.classList.remove('open');
+        document.body.style.removeProperty('overflow');
+        this.stopStatusUpdates();
+    }
+
+    // --- Utility Methods ---
+    formatBytes(bytes, decimals = 2) {
+        if (bytes === null || bytes === undefined || isNaN(bytes)) return 'N/A';
+        if (bytes === 0) return '0 Bytes';
+        const k = 1024;
+        const dm = decimals < 0 ? 0 : decimals;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+    }
+
+    formatSpeed(bytesPerSecond) {
+        if (!isFinite(bytesPerSecond) || bytesPerSecond <= 0) return '';
+        return this.formatBytes(bytesPerSecond) + '/s';
+    }
+
+    formatDuration(isoStart, isoEnd) {
+        try {
+            const diffSeconds = Math.round((new Date(isoEnd) - new Date(isoStart)) / 1000);
+            if (isNaN(diffSeconds) || diffSeconds < 0) return 'N/A';
+            if (diffSeconds < 60) return `${diffSeconds}s`;
+            const diffMinutes = Math.floor(diffSeconds / 60);
+            const remainingSeconds = diffSeconds % 60;
+            return `${diffMinutes}m ${remainingSeconds}s`;
+        } catch (e) {
+            return 'N/A';
+        }
+    }
+
+    showToast(message, type = 'info', duration = 3000) {
+        this.feedback?.show(message, type, duration);
+    }
+
+    ensureFontAwesome() {
+        this.feedback?.ensureFontAwesome();
+    }
+
+    // --- Rendering (delegated to external renderers) ---
+    renderDownloadList = (items, container, emptyMessage) => renderDownloadList(this, items, container, emptyMessage);
+    renderSearchResults = (items) => renderSearchResults(this, items);
+    renderDownloadPreview = (data) => renderDownloadPreview(this, data);
+    
+    // --- Auto-select model type based on Civitai model type ---
+    inferFolderFromCivitaiType(civitaiType) {
+        if (!civitaiType || typeof civitaiType !== 'string') return null;
+        const t = civitaiType.trim().toLowerCase();
+        const keys = Object.keys(this.modelTypes || {});
+        if (keys.length === 0) return null;
+
+        const exists = (k) => keys.includes(k);
+        const findBy = (pred) => keys.find(pred);
+
+        // Direct matches first
+        if (exists(t)) return t;
+        if (exists(`${t}s`)) return `${t}s`;
+
+        // Common mappings from Civitai types to ComfyUI folders
+        const candidates = [];
+        const addIfExists = (k) => { if (exists(k)) candidates.push(k); };
+
+        switch (t) {
+            case 'checkpoint':
+                addIfExists('checkpoints');
+                addIfExists('models');
+                break;
+            case 'lora': case 'locon': case 'lycoris':
+                addIfExists('loras');
+                break;
+            case 'vae':
+                addIfExists('vae');
+                break;
+            case 'textualinversion': case 'embedding': case 'embeddings':
+                addIfExists('embeddings');
+                break;
+            case 'hypernetwork':
+                addIfExists('hypernetworks');
+                break;
+            case 'controlnet':
+                addIfExists('controlnet');
+                break;
+            case 'unet': case 'unet2':
+                addIfExists('unet');
+                break;
+            case 'diffusers': case 'diffusionmodels': case 'diffusion_models': case 'diffusion':
+                addIfExists('diffusers');
+                addIfExists('diffusion_models');
+                break;
+            case 'upscaler': case 'upscalers':
+                addIfExists('upscale_models');
+                addIfExists('upscalers');
+                break;
+            case 'motionmodule':
+                addIfExists('motion_models');
+                break;
+            case 'poses':
+                addIfExists('poses');
+                break;
+            case 'wildcards':
+                addIfExists('wildcards');
+                break;
+            case 'onnx':
+                addIfExists('onnx');
+                break;
+        }
+        if (candidates.length > 0) return candidates[0];
+
+        // Relaxed match: name contains type
+        const contains = findBy(k => k.toLowerCase().includes(t));
+        if (contains) return contains;
+
+        return null;
+    }
+
+    async autoSelectModelTypeFromCivitai(civitaiType) {
+        try {
+            const folder = this.inferFolderFromCivitaiType(civitaiType);
+            if (!folder) return;
+            if (this.downloadModelTypeSelect && this.downloadModelTypeSelect.value !== folder) {
+                this.downloadModelTypeSelect.value = folder;
+                await this.loadAndPopulateSubdirs(folder);
+                // Reset subdir to root after auto-switch
+                if (this.subdirSelect) this.subdirSelect.value = '';
+            }
+        } catch (e) {
+            console.warn('[Civicomfy] Auto-select model type failed:', e);
+        }
+    }
+
+    renderSearchPagination(metadata) {
+        if (!this.searchPaginationContainer) return;
+        if (!metadata || metadata.totalPages <= 1) {
+            this.searchPaginationContainer.innerHTML = '';
+            this.searchPagination = { ...this.searchPagination, ...metadata };
+            return;
+        }
+
+        this.searchPagination = { ...this.searchPagination, ...metadata };
+        const { currentPage, totalPages, totalItems } = this.searchPagination;
+
+        const createButton = (text, page, isDisabled = false, isCurrent = false) => {
+            const button = document.createElement('button');
+            button.className = `civitai-button small civitai-page-button ${isCurrent ? 'primary active' : ''}`;
+            button.dataset.page = page;
+            button.disabled = isDisabled;
+            button.innerHTML = text;
+            button.type = 'button';
+            return button;
+        };
+
+        const fragment = document.createDocumentFragment();
+        fragment.appendChild(createButton('&laquo; Prev', currentPage - 1, currentPage === 1));
+        
+        let startPage = Math.max(1, currentPage - 2);
+        let endPage = Math.min(totalPages, currentPage + 2);
+
+        if (startPage > 1) fragment.appendChild(createButton('1', 1));
+        if (startPage > 2) fragment.appendChild(document.createElement('span')).textContent = '...';
+
+        for (let i = startPage; i <= endPage; i++) {
+            fragment.appendChild(createButton(i, i, false, i === currentPage));
+        }
+
+        if (endPage < totalPages - 1) fragment.appendChild(document.createElement('span')).textContent = '...';
+        if (endPage < totalPages) fragment.appendChild(createButton(totalPages, totalPages));
+        
+        fragment.appendChild(createButton('Next &raquo;', currentPage + 1, currentPage === totalPages));
+
+        const info = document.createElement('div');
+        info.className = 'civitai-pagination-info';
+        info.textContent = `Page ${currentPage} of ${totalPages} (${totalItems.toLocaleString()} models)`;
+        fragment.appendChild(info);
+
+        this.searchPaginationContainer.innerHTML = '';
+        this.searchPaginationContainer.appendChild(fragment);
+    }
+
+    // --- Event Handlers and State Management (delegated to handlers) ---
+    setupEventListeners = () => setupEventListeners(this);
+    getDefaultSettings = () => getDefaultSettings();
+    loadAndApplySettings = () => loadAndApplySettings(this);
+    loadSettingsFromCookie = () => loadSettingsFromCookie(this);
+    saveSettingsToCookie = () => saveSettingsToCookie(this);
+    applySettings = () => applySettings(this);
+    handleSettingsSave = () => handleSettingsSave(this);
+    handleDownloadSubmit = () => handleDownloadSubmit(this);
+    handleSearchSubmit = () => handleSearchSubmit(this);
+    fetchAndDisplayDownloadPreview = () => fetchAndDisplayDownloadPreview(this);
+    debounceFetchDownloadPreview = (delay) => debounceFetchDownloadPreview(this, delay);
+    startStatusUpdates = () => startStatusUpdates(this);
+    stopStatusUpdates = () => stopStatusUpdates(this);
+    updateStatus = () => updateStatus(this);
+    handleCancelDownload = (downloadId) => handleCancelDownload(this, downloadId);
+    handleRetryDownload = (downloadId, button) => handleRetryDownload(this, downloadId, button);
+    handleOpenPath = (downloadId, button) => handleOpenPath(this, downloadId, button);
+    handleClearHistory = () => handleClearHistory(this);
+}

custom_nodes/Civicomfy/web/js/ui/feedback.js

@@ -0,0 +1,41 @@
+// Centralized feedback utilities: toasts and icon CSS
+
+export class Feedback {
+  constructor(toastElement) {
+    this.toastElement = toastElement || null;
+    this.toastTimeout = null;
+  }
+
+  ensureFontAwesome() {
+    if (!document.getElementById('civitai-fontawesome-link')) {
+      const faLink = document.createElement('link');
+      faLink.id = 'civitai-fontawesome-link';
+      faLink.rel = 'stylesheet';
+      faLink.href = 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css';
+      faLink.integrity = 'sha512-1ycn6IcaQQ40/MKBW2W4Rhis/DbILU74C1vSrLJxCq57o941Ym01SwNsOMqvEBFlcgUa6xLiPY/NS5R+E6ztJQ==';
+      faLink.crossOrigin = 'anonymous';
+      faLink.referrerPolicy = 'no-referrer';
+      document.head.appendChild(faLink);
+    }
+  }
+
+  show(message, type = 'info', duration = 3000) {
+    if (!this.toastElement) return;
+    if (this.toastTimeout) {
+      clearTimeout(this.toastTimeout);
+      this.toastTimeout = null;
+    }
+    const valid = ['info', 'success', 'error', 'warning'];
+    const toastType = valid.includes(type) ? type : 'info';
+
+    this.toastElement.textContent = message;
+    this.toastElement.className = 'civitai-toast';
+    this.toastElement.classList.add(toastType);
+    requestAnimationFrame(() => this.toastElement.classList.add('show'));
+    this.toastTimeout = setTimeout(() => {
+      this.toastElement.classList.remove('show');
+      this.toastTimeout = null;
+    }, duration);
+  }
+}
+

custom_nodes/Civicomfy/web/js/ui/handlers/downloadHandler.js

@@ -0,0 +1,110 @@
+import { CivitaiDownloaderAPI } from "../../api/civitai.js";
+
+export function debounceFetchDownloadPreview(ui, delay = 500) {
+    clearTimeout(ui.modelPreviewDebounceTimeout);
+    ui.modelPreviewDebounceTimeout = setTimeout(() => {
+        fetchAndDisplayDownloadPreview(ui);
+    }, delay);
+}
+
+export async function fetchAndDisplayDownloadPreview(ui) {
+    const modelUrlOrId = ui.modelUrlInput.value.trim();
+    const versionId = ui.modelVersionIdInput.value.trim();
+
+    if (!modelUrlOrId) {
+        ui.downloadPreviewArea.innerHTML = '';
+        return;
+    }
+
+    ui.downloadPreviewArea.innerHTML = '<p><i class="fas fa-spinner fa-spin"></i> Loading model details...</p>';
+    ui.ensureFontAwesome();
+
+    const params = {
+        model_url_or_id: modelUrlOrId,
+        model_version_id: versionId ? parseInt(versionId, 10) : null,
+        api_key: ui.settings.apiKey
+    };
+
+    try {
+        const result = await CivitaiDownloaderAPI.getModelDetails(params);
+        if (result && result.success) {
+            ui.renderDownloadPreview(result);
+            // Auto-select model type save location based on Civitai model type
+            if (result.model_type) {
+                await ui.autoSelectModelTypeFromCivitai(result.model_type);
+            }
+        } else {
+            const message = `Failed to get details: ${result.details || result.error || 'Unknown backend error'}`;
+            ui.downloadPreviewArea.innerHTML = `<p style="color: var(--error-text, #ff6b6b);">${message}</p>`;
+        }
+    } catch (error) {
+        const message = `Error fetching details: ${error.details || error.message || 'Unknown error'}`;
+        console.error("Download Preview Fetch Error:", error);
+        ui.downloadPreviewArea.innerHTML = `<p style="color: var(--error-text, #ff6b6b);">${message}</p>`;
+    }
+}
+
+export async function handleDownloadSubmit(ui) {
+    if (!ui.settings.apiKey) {
+        ui.showToast("API key empty, please fill your API key in the settings", "error");
+        ui.switchTab("settings");
+        return;
+    }
+
+    ui.downloadSubmitButton.disabled = true;
+    ui.downloadSubmitButton.textContent = 'Starting...';
+
+    const modelUrlOrId = ui.modelUrlInput.value.trim();
+    if (!modelUrlOrId) {
+        ui.showToast("Model URL or ID cannot be empty.", "error");
+        ui.downloadSubmitButton.disabled = false;
+        ui.downloadSubmitButton.textContent = 'Start Download';
+        return;
+    }
+
+    // Subfolder comes from dropdown; filename is base name only
+    const selectedSubdir = ui.subdirSelect ? ui.subdirSelect.value.trim() : '';
+    const userFilename = ui.customFilenameInput.value.trim();
+
+    const params = {
+        model_url_or_id: modelUrlOrId,
+        model_type: ui.downloadModelTypeSelect.value,
+        model_version_id: ui.modelVersionIdInput.value ? parseInt(ui.modelVersionIdInput.value, 10) : null,
+        custom_filename: userFilename,
+        subdir: selectedSubdir,
+        num_connections: parseInt(ui.downloadConnectionsInput.value, 10),
+        force_redownload: ui.forceRedownloadCheckbox.checked,
+        api_key: ui.settings.apiKey
+    };
+
+    const fileSelectEl = ui.modal.querySelector('#civitai-file-select');
+    if (fileSelectEl && fileSelectEl.value) {
+        const fid = parseInt(fileSelectEl.value, 10);
+        if (!Number.isNaN(fid)) params.file_id = fid;
+    }
+
+    try {
+        const result = await CivitaiDownloaderAPI.downloadModel(params);
+
+        if (result.status === 'queued') {
+            ui.showToast(`Download queued: ${result.details?.filename || 'Model'}`, 'success');
+            if (ui.settings.autoOpenStatusTab) {
+                ui.switchTab('status');
+            } else {
+                ui.updateStatus();
+            }
+        } else if (result.status === 'exists' || result.status === 'exists_size_mismatch') {
+            ui.showToast(`${result.message}`, 'info', 4000);
+        } else {
+            console.warn("Unexpected success response from /civitai/download:", result);
+            ui.showToast(`Unexpected status: ${result.status} - ${result.message || ''}`, 'info');
+        }
+    } catch (error) {
+        const message = `Download failed: ${error.details || error.message || 'Unknown error'}`;
+        console.error("Download Submit Error:", error);
+        ui.showToast(message, 'error', 6000);
+    } finally {
+        ui.downloadSubmitButton.disabled = false;
+        ui.downloadSubmitButton.textContent = 'Start Download';
+    }
+}

custom_nodes/Civicomfy/web/js/ui/handlers/eventListeners.js

@@ -0,0 +1,238 @@
+import { CivitaiDownloaderAPI } from "../../api/civitai.js";
+export function setupEventListeners(ui) {
+    // Modal close
+    ui.closeButton.addEventListener('click', () => ui.closeModal());
+    ui.modal.addEventListener('click', (event) => {
+        if (event.target === ui.modal) ui.closeModal();
+    });
+
+    // Tab switching
+    ui.tabContainer.addEventListener('click', (event) => {
+        if (event.target.matches('.civitai-downloader-tab')) {
+            ui.switchTab(event.target.dataset.tab);
+        }
+    });
+
+    // --- FORMS ---
+    ui.downloadForm.addEventListener('submit', (event) => {
+        event.preventDefault();
+        ui.handleDownloadSubmit();
+    });
+
+    // Change of model type should refresh subdir list
+    ui.downloadModelTypeSelect.addEventListener('change', async () => {
+        await ui.loadAndPopulateSubdirs(ui.downloadModelTypeSelect.value);
+    });
+
+    // Create new model type folder (first-level under models/)
+    ui.createModelTypeButton.addEventListener('click', async () => {
+        const name = prompt('Enter new model type folder name (will be created under models/)');
+        if (!name) return;
+        try {
+            const res = await CivitaiDownloaderAPI.createModelType(name);
+            if (res && res.success) {
+                await ui.populateModelTypes();
+                ui.downloadModelTypeSelect.value = res.name;
+                await ui.loadAndPopulateSubdirs(res.name);
+                ui.showToast(`Created model type folder: ${res.name}`, 'success');
+            } else {
+                ui.showToast(res?.error || 'Failed to create model type folder', 'error');
+            }
+        } catch (e) {
+            ui.showToast(e.details || e.message || 'Error creating model type folder', 'error');
+        }
+    });
+
+    // Create new subfolder under current model type
+    ui.createSubdirButton.addEventListener('click', async () => {
+        const type = ui.downloadModelTypeSelect.value;
+        const name = prompt('Enter new subfolder name (you can include nested paths like A/B):');
+        if (!name) return;
+        try {
+            const res = await CivitaiDownloaderAPI.createModelDir(type, name);
+            if (res && res.success) {
+                await ui.loadAndPopulateSubdirs(type);
+                if (ui.subdirSelect) ui.subdirSelect.value = res.created || '';
+                ui.showToast(`Created folder: ${res.created}`, 'success');
+            } else {
+                ui.showToast(res?.error || 'Failed to create folder', 'error');
+            }
+        } catch (e) {
+            ui.showToast(e.details || e.message || 'Error creating folder', 'error');
+        }
+    });
+
+    ui.searchForm.addEventListener('submit', (event) => {
+        event.preventDefault();
+        if (!ui.searchQueryInput.value.trim() && ui.searchTypeSelect.value === 'any' && ui.searchBaseModelSelect.value === 'any') {
+            ui.showToast("Please enter a search query or select a filter.", "error");
+            if (ui.searchResultsContainer) ui.searchResultsContainer.innerHTML = '<p>Please enter a search query or select a filter.</p>';
+            if (ui.searchPaginationContainer) ui.searchPaginationContainer.innerHTML = '';
+            return;
+        }
+        ui.searchPagination.currentPage = 1;
+        ui.handleSearchSubmit();
+    });
+
+    ui.settingsForm.addEventListener('submit', (event) => {
+        event.preventDefault();
+        ui.handleSettingsSave();
+    });
+
+    // Download form inputs
+    ui.modelUrlInput.addEventListener('input', () => ui.debounceFetchDownloadPreview());
+    ui.modelUrlInput.addEventListener('paste', () => ui.debounceFetchDownloadPreview(0));
+    ui.modelVersionIdInput.addEventListener('blur', () => ui.fetchAndDisplayDownloadPreview());
+
+    // --- DYNAMIC CONTENT LISTENERS (Event Delegation) ---
+
+    // Status tab actions (Cancel/Retry/Open/Clear) and click-to-toggle blur on thumbs
+    ui.statusContent.addEventListener('click', (event) => {
+        const thumbContainer = event.target.closest('.civitai-thumbnail-container');
+        if (thumbContainer) {
+            const nsfwLevel = Number(thumbContainer.dataset.nsfwLevel ?? thumbContainer.getAttribute('data-nsfw-level'));
+            const threshold = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+            const enabled = ui.settings?.hideMatureInSearch === true;
+            if (enabled && Number.isFinite(nsfwLevel) && nsfwLevel >= threshold) {
+                if (thumbContainer.classList.contains('blurred')) {
+                    thumbContainer.classList.remove('blurred');
+                    const overlay = thumbContainer.querySelector('.civitai-nsfw-overlay');
+                    if (overlay) overlay.remove();
+                } else {
+                    thumbContainer.classList.add('blurred');
+                    if (!thumbContainer.querySelector('.civitai-nsfw-overlay')) {
+                        const ov = document.createElement('div');
+                        ov.className = 'civitai-nsfw-overlay';
+                        ov.title = 'R-rated: click to reveal';
+                        ov.textContent = 'R';
+                        thumbContainer.appendChild(ov);
+                    }
+                }
+                return; // consume
+            }
+        }
+
+        const button = event.target.closest('button');
+        if (!button) return;
+
+        const downloadId = button.dataset.id;
+        if (downloadId) {
+            if (button.classList.contains('civitai-cancel-button')) ui.handleCancelDownload(downloadId);
+            else if (button.classList.contains('civitai-retry-button')) ui.handleRetryDownload(downloadId, button);
+            else if (button.classList.contains('civitai-openpath-button')) ui.handleOpenPath(downloadId, button);
+        } else if (button.id === 'civitai-clear-history-button') {
+            ui.confirmClearModal.style.display = 'flex';
+        }
+    });
+
+    // Download preview click-to-toggle blur
+    ui.downloadPreviewArea.addEventListener('click', (event) => {
+        const thumbContainer = event.target.closest('.civitai-thumbnail-container');
+        if (thumbContainer) {
+            const nsfwLevel = Number(thumbContainer.dataset.nsfwLevel ?? thumbContainer.getAttribute('data-nsfw-level'));
+            const threshold = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+            const enabled = ui.settings?.hideMatureInSearch === true;
+            if (enabled && Number.isFinite(nsfwLevel) && nsfwLevel >= threshold) {
+                if (thumbContainer.classList.contains('blurred')) {
+                    thumbContainer.classList.remove('blurred');
+                    const overlay = thumbContainer.querySelector('.civitai-nsfw-overlay');
+                    if (overlay) overlay.remove();
+                } else {
+                    thumbContainer.classList.add('blurred');
+                    if (!thumbContainer.querySelector('.civitai-nsfw-overlay')) {
+                        const ov = document.createElement('div');
+                        ov.className = 'civitai-nsfw-overlay';
+                        ov.title = 'R-rated: click to reveal';
+                        ov.textContent = 'R';
+                        thumbContainer.appendChild(ov);
+                    }
+                }
+            }
+        }
+    });
+
+    // Search results actions, including click-to-toggle blur
+    ui.searchResultsContainer.addEventListener('click', (event) => {
+        const thumbContainer = event.target.closest('.civitai-thumbnail-container');
+        if (thumbContainer) {
+            const nsfwLevel = Number(thumbContainer.dataset.nsfwLevel ?? thumbContainer.getAttribute('data-nsfw-level'));
+            const threshold = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+            const enabled = ui.settings?.hideMatureInSearch === true;
+            if (enabled && Number.isFinite(nsfwLevel) && nsfwLevel >= threshold) {
+                if (thumbContainer.classList.contains('blurred')) {
+                    thumbContainer.classList.remove('blurred');
+                    const overlay = thumbContainer.querySelector('.civitai-nsfw-overlay');
+                    if (overlay) overlay.remove();
+                } else {
+                    thumbContainer.classList.add('blurred');
+                    if (!thumbContainer.querySelector('.civitai-nsfw-overlay')) {
+                        const ov = document.createElement('div');
+                        ov.className = 'civitai-nsfw-overlay';
+                        ov.title = 'R-rated: click to reveal';
+                        ov.textContent = 'R';
+                        thumbContainer.appendChild(ov);
+                    }
+                }
+                return; // Don't trigger other actions on this click
+            }
+        }
+
+        const downloadButton = event.target.closest('.civitai-search-download-button');
+        if (downloadButton) {
+            event.preventDefault();
+            const { modelId, versionId, modelType } = downloadButton.dataset;
+            if (!modelId || !versionId) {
+                ui.showToast("Error: Missing data for download.", "error");
+                return;
+            }
+            const modelTypeInternalKey = Object.keys(ui.modelTypes).find(key => ui.modelTypes[key]?.toLowerCase() === modelType?.toLowerCase()) || ui.settings.defaultModelType;
+
+            ui.modelUrlInput.value = modelId;
+            ui.modelVersionIdInput.value = versionId;
+            ui.customFilenameInput.value = '';
+            ui.forceRedownloadCheckbox.checked = false;
+            ui.downloadModelTypeSelect.value = modelTypeInternalKey;
+
+            ui.switchTab('download');
+            ui.showToast(`Filled download form for Model ID ${modelId}.`, 'info', 4000);
+            ui.fetchAndDisplayDownloadPreview();
+            return;
+        }
+
+        const viewAllButton = event.target.closest('.show-all-versions-button');
+        if (viewAllButton) {
+            const modelId = viewAllButton.dataset.modelId;
+            const versionsContainer = ui.searchResultsContainer.querySelector(`#all-versions-${modelId}`);
+            if (versionsContainer) {
+                const currentlyVisible = versionsContainer.style.display !== 'none';
+                versionsContainer.style.display = currentlyVisible ? 'none' : 'flex';
+                viewAllButton.innerHTML = currentlyVisible
+                    ? `All versions (${viewAllButton.dataset.totalVersions}) <i class="fas fa-chevron-down"></i>`
+                    : `Show less <i class="fas fa-chevron-up"></i>`;
+            }
+        }
+    });
+
+    // Pagination
+    ui.searchPaginationContainer.addEventListener('click', (event) => {
+        const button = event.target.closest('.civitai-page-button');
+        if (button && !button.disabled) {
+            const page = parseInt(button.dataset.page, 10);
+            if (page && page !== ui.searchPagination.currentPage) {
+                ui.searchPagination.currentPage = page;
+                ui.handleSearchSubmit();
+            }
+        }
+    });
+
+    // Confirmation Modal
+    ui.confirmClearYesButton.addEventListener('click', () => ui.handleClearHistory());
+    ui.confirmClearNoButton.addEventListener('click', () => {
+        ui.confirmClearModal.style.display = 'none';
+    });
+    ui.confirmClearModal.addEventListener('click', (event) => {
+        if (event.target === ui.confirmClearModal) {
+            ui.confirmClearModal.style.display = 'none';
+        }
+    });
+}

custom_nodes/Civicomfy/web/js/ui/handlers/searchHandler.js

@@ -0,0 +1,39 @@
+import { CivitaiDownloaderAPI } from "../../api/civitai.js";
+
+export async function handleSearchSubmit(ui) {
+    ui.searchSubmitButton.disabled = true;
+    ui.searchSubmitButton.textContent = 'Searching...';
+    ui.searchResultsContainer.innerHTML = '<p><i class="fas fa-spinner fa-spin"></i> Searching...</p>';
+    ui.searchPaginationContainer.innerHTML = '';
+    ui.ensureFontAwesome();
+
+    const params = {
+        query: ui.searchQueryInput.value.trim(),
+        model_types: ui.searchTypeSelect.value === 'any' ? [] : [ui.searchTypeSelect.value],
+        base_models: ui.searchBaseModelSelect.value === 'any' ? [] : [ui.searchBaseModelSelect.value],
+        sort: ui.searchSortSelect.value,
+        limit: ui.searchPagination.limit,
+        page: ui.searchPagination.currentPage,
+        api_key: ui.settings.apiKey,
+    };
+
+    try {
+        const response = await CivitaiDownloaderAPI.searchModels(params);
+        if (!response || !response.metadata || !Array.isArray(response.items)) {
+            console.error("Invalid search response structure:", response);
+            throw new Error("Received invalid data from search API.");
+        }
+
+        ui.renderSearchResults(response.items);
+        ui.renderSearchPagination(response.metadata);
+
+    } catch (error) {
+        const message = `Search failed: ${error.details || error.message || 'Unknown error'}`;
+        console.error("Search Submit Error:", error);
+        ui.searchResultsContainer.innerHTML = `<p style="color: var(--error-text, #ff6b6b);">${message}</p>`;
+        ui.showToast(message, 'error');
+    } finally {
+        ui.searchSubmitButton.disabled = false;
+        ui.searchSubmitButton.textContent = 'Search';
+    }
+}

custom_nodes/Civicomfy/web/js/ui/handlers/settingsHandler.js

@@ -0,0 +1,104 @@
+import { setCookie, getCookie } from "../../utils/cookies.js";
+
+const SETTINGS_COOKIE_NAME = 'civitaiDownloaderSettings';
+
+export function getDefaultSettings() {
+    return {
+        apiKey: '',
+        numConnections: 1,
+        defaultModelType: 'checkpoint',
+        autoOpenStatusTab: true,
+        searchResultLimit: 20,
+        hideMatureInSearch: true,
+        nsfwBlurMinLevel: 4, // Blur thumbnails with nsfwLevel >= this value
+    };
+}
+
+export function loadAndApplySettings(ui) {
+    ui.settings = ui.loadSettingsFromCookie();
+    ui.applySettings();
+}
+
+export function loadSettingsFromCookie(ui) {
+    const defaults = ui.getDefaultSettings();
+    const cookieValue = getCookie(SETTINGS_COOKIE_NAME);
+
+    if (cookieValue) {
+        try {
+            const loadedSettings = JSON.parse(cookieValue);
+            return { ...defaults, ...loadedSettings };
+        } catch (e) {
+            console.error("Failed to parse settings cookie:", e);
+            return defaults;
+        }
+    }
+    return defaults;
+}
+
+export function saveSettingsToCookie(ui) {
+    try {
+        const settingsString = JSON.stringify(ui.settings);
+        setCookie(SETTINGS_COOKIE_NAME, settingsString, 365);
+        ui.showToast('Settings saved successfully!', 'success');
+    } catch (e) {
+        console.error("Failed to save settings to cookie:", e);
+        ui.showToast('Error saving settings', 'error');
+    }
+}
+
+export function applySettings(ui) {
+    if (ui.settingsApiKeyInput) {
+        ui.settingsApiKeyInput.value = ui.settings.apiKey || '';
+    }
+    if (ui.settingsConnectionsInput) {
+        ui.settingsConnectionsInput.value = Math.max(1, Math.min(16, ui.settings.numConnections || 1));
+    }
+    if (ui.settingsDefaultTypeSelect) {
+        ui.settingsDefaultTypeSelect.value = ui.settings.defaultModelType || 'checkpoint';
+    }
+    if (ui.settingsAutoOpenCheckbox) {
+        ui.settingsAutoOpenCheckbox.checked = ui.settings.autoOpenStatusTab === true;
+    }
+    if (ui.settingsHideMatureCheckbox) {
+        ui.settingsHideMatureCheckbox.checked = ui.settings.hideMatureInSearch === true;
+    }
+    if (ui.settingsNsfwThresholdInput) {
+        const val = Number(ui.settings.nsfwBlurMinLevel);
+        ui.settingsNsfwThresholdInput.value = Number.isFinite(val) ? val : 4;
+    }
+    if (ui.downloadConnectionsInput) {
+        ui.downloadConnectionsInput.value = Math.max(1, Math.min(16, ui.settings.numConnections || 1));
+    }
+    if (ui.downloadModelTypeSelect && Object.keys(ui.modelTypes).length > 0) {
+        ui.downloadModelTypeSelect.value = ui.settings.defaultModelType || 'checkpoint';
+    }
+    ui.searchPagination.limit = ui.settings.searchResultLimit || 20;
+}
+
+export function handleSettingsSave(ui) {
+    const apiKey = ui.settingsApiKeyInput.value.trim();
+    const numConnections = parseInt(ui.settingsConnectionsInput.value, 10);
+    const defaultModelType = ui.settingsDefaultTypeSelect.value;
+    const autoOpenStatusTab = ui.settingsAutoOpenCheckbox.checked;
+    const hideMatureInSearch = ui.settingsHideMatureCheckbox.checked;
+    const nsfwBlurMinLevel = Number(ui.settingsNsfwThresholdInput.value);
+
+    if (isNaN(numConnections) || numConnections < 1 || numConnections > 16) {
+        ui.showToast("Invalid Default Connections (must be 1-16).", "error");
+        return;
+    }
+    if (!ui.settingsDefaultTypeSelect.querySelector(`option[value="${defaultModelType}"]`)) {
+        ui.showToast("Invalid Default Model Type selected.", "error");
+        return;
+    }
+
+    ui.settings.apiKey = apiKey;
+    ui.settings.numConnections = numConnections;
+    ui.settings.defaultModelType = defaultModelType;
+    ui.settings.autoOpenStatusTab = autoOpenStatusTab;
+    ui.settings.hideMatureInSearch = hideMatureInSearch;
+    ui.settings.nsfwBlurMinLevel = (Number.isFinite(nsfwBlurMinLevel) && nsfwBlurMinLevel >= 0) ? Math.min(128, Math.round(nsfwBlurMinLevel)) : 4;
+
+    ui.saveSettingsToCookie();
+    ui.applySettings();
+}

custom_nodes/Civicomfy/web/js/ui/handlers/statusHandler.js

@@ -0,0 +1,154 @@
+import { CivitaiDownloaderAPI } from "../../api/civitai.js";
+
+export function startStatusUpdates(ui) {
+    if (!ui.statusInterval) {
+        console.log("[Civicomfy] Starting status updates (every 3s)...");
+        ui.updateStatus();
+        ui.statusInterval = setInterval(() => ui.updateStatus(), 3000);
+    }
+}
+
+export function stopStatusUpdates(ui) {
+    if (ui.statusInterval) {
+        clearInterval(ui.statusInterval);
+        ui.statusInterval = null;
+        console.log("[Civicomfy] Stopped status updates.");
+    }
+}
+
+export async function updateStatus(ui) {
+    if (!ui.modal || !ui.modal.classList.contains('open')) return;
+
+    try {
+        const newStatusData = await CivitaiDownloaderAPI.getStatus();
+        if (!newStatusData || !Array.isArray(newStatusData.active) || !Array.isArray(newStatusData.queue) || !Array.isArray(newStatusData.history)) {
+            throw new Error("Invalid status data structure received from server.");
+        }
+
+        const oldStateString = JSON.stringify(ui.statusData);
+        const newStateString = JSON.stringify(newStatusData);
+
+        // Cache new state if it differs
+        if (oldStateString !== newStateString) {
+            ui.statusData = newStatusData;
+        }
+
+        // Always keep counters in sync
+        const activeCount = ui.statusData.active.length + ui.statusData.queue.length;
+        ui.activeCountSpan.textContent = activeCount;
+        ui.statusIndicator.style.display = activeCount > 0 ? 'inline' : 'none';
+
+        // Always render when Status tab is active, even if data hasn't changed
+        if (ui.activeTab === 'status') {
+            ui.renderDownloadList(ui.statusData.active, ui.activeListContainer, 'No active downloads.');
+            ui.renderDownloadList(ui.statusData.queue, ui.queuedListContainer, 'Download queue is empty.');
+            ui.renderDownloadList(ui.statusData.history, ui.historyListContainer, 'No download history yet.');
+        }
+    } catch (error) {
+        console.error("[Civicomfy] Failed to update status:", error);
+        if (ui.activeTab === 'status') {
+            const errorHtml = `<p style="color: var(--error-text, #ff6b6b);">${error.details || error.message}</p>`;
+            if (ui.activeListContainer) ui.activeListContainer.innerHTML = errorHtml;
+            if (ui.queuedListContainer) ui.queuedListContainer.innerHTML = '';
+            if (ui.historyListContainer) ui.historyListContainer.innerHTML = '';
+        }
+    }
+}
+
+export async function handleCancelDownload(ui, downloadId) {
+    const button = ui.modal.querySelector(`.civitai-cancel-button[data-id="${downloadId}"]`);
+    if (button) {
+        button.disabled = true;
+        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+        button.title = "Cancelling...";
+    }
+    try {
+        const result = await CivitaiDownloaderAPI.cancelDownload(downloadId);
+        ui.showToast(result.message || `Cancellation requested for ${downloadId}`, 'info');
+        ui.updateStatus();
+    } catch (error) {
+        const message = `Cancel failed: ${error.details || error.message}`;
+        console.error("Cancel Download Error:", error);
+        ui.showToast(message, 'error');
+        if (button) {
+            button.disabled = false;
+            button.innerHTML = '<i class="fas fa-times"></i>';
+            button.title = "Cancel Download";
+        }
+    }
+}
+
+export async function handleRetryDownload(ui, downloadId, button) {
+    button.disabled = true;
+    button.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+    button.title = "Retrying...";
+    try {
+        const result = await CivitaiDownloaderAPI.retryDownload(downloadId);
+        if (result.success) {
+            ui.showToast(result.message || `Retry queued successfully!`, 'success');
+            if (ui.settings.autoOpenStatusTab) ui.switchTab('status');
+            else ui.updateStatus();
+        } else {
+            ui.showToast(`Retry failed: ${result.details || result.error}`, 'error', 5000);
+            button.disabled = false;
+            button.innerHTML = '<i class="fas fa-redo"></i>';
+            button.title = "Retry Download";
+        }
+    } catch (error) {
+        const message = `Retry failed: ${error.details || error.message}`;
+        console.error("Retry Download UI Error:", error);
+        ui.showToast(message, 'error', 5000);
+        button.disabled = false;
+        button.innerHTML = '<i class="fas fa-redo"></i>';
+        button.title = "Retry Download";
+    }
+}
+
+export async function handleOpenPath(ui, downloadId, button) {
+    const originalIcon = button.innerHTML;
+    button.disabled = true;
+    button.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+    button.title = "Opening...";
+    try {
+        const result = await CivitaiDownloaderAPI.openPath(downloadId);
+        if (result.success) {
+            ui.showToast(result.message || `Opened path successfully!`, 'success');
+        } else {
+            ui.showToast(`Open path failed: ${result.details || result.error}`, 'error', 5000);
+        }
+    } catch (error) {
+        const message = `Open path failed: ${error.details || error.message}`;
+        console.error("Open Path UI Error:", error);
+        ui.showToast(message, 'error', 5000);
+    } finally {
+        button.disabled = false;
+        button.innerHTML = originalIcon;
+        button.title = "Open Containing Folder";
+    }
+}
+
+export async function handleClearHistory(ui) {
+    ui.confirmClearYesButton.disabled = true;
+    ui.confirmClearNoButton.disabled = true;
+    ui.confirmClearYesButton.textContent = 'Clearing...';
+
+    try {
+        const result = await CivitaiDownloaderAPI.clearHistory();
+        if (result.success) {
+            ui.showToast(result.message || 'History cleared successfully!', 'success');
+            ui.statusData.history = [];
+            ui.renderDownloadList(ui.statusData.history, ui.historyListContainer, 'No download history yet.');
+            ui.confirmClearModal.style.display = 'none';
+        } else {
+            ui.showToast(`Clear history failed: ${result.details || result.error}`, 'error', 5000);
+        }
+    } catch (error) {
+        const message = `Clear history failed: ${error.details || error.message}`;
+        console.error("Clear History UI Error:", error);
+        ui.showToast(message, 'error', 5000);
+    } finally {
+        ui.confirmClearYesButton.disabled = false;
+        ui.confirmClearNoButton.disabled = false;
+        ui.confirmClearYesButton.textContent = 'Confirm Clear';
+    }
+}

custom_nodes/Civicomfy/web/js/ui/previewRenderer.js

@@ -0,0 +1,96 @@
+// Renders the download preview panel
+
+const PLACEHOLDER_IMAGE_URL = `/extensions/Civicomfy/images/placeholder.jpeg`;
+
+export function renderDownloadPreview(ui, data) {
+  if (!ui.downloadPreviewArea) return;
+  ui.ensureFontAwesome();
+
+  const modelId = data.model_id;
+  const modelName = data.model_name || 'Untitled Model';
+  const creator = data.creator_username || 'Unknown Creator';
+  const modelType = data.model_type || 'N/A';
+  const versionName = data.version_name || 'N/A';
+  const baseModel = data.base_model || 'N/A';
+  const stats = data.stats || {};
+  const descriptionHtml = data.description_html || '<p><em>No description.</em></p>';
+  const version_description_html = data.version_description_html || '<p><em>No description.</em></p>';
+  const fileInfo = data.file_info || {};
+  const files = Array.isArray(data.files) ? data.files : [];
+  const thumbnail = data.thumbnail_url || PLACEHOLDER_IMAGE_URL;
+  const nsfwLevel = Number(data.nsfw_level ?? 0);
+  const blurMinLevel = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+  const shouldBlur = ui.settings?.hideMatureInSearch === true && nsfwLevel >= blurMinLevel;
+  const civitaiLink = `https://civitai.com/models/${modelId}${data.version_id ? '?modelVersionId=' + data.version_id : ''}`;
+
+  const onErrorScript = `this.onerror=null; this.src='${PLACEHOLDER_IMAGE_URL}'; this.style.backgroundColor='#444';`;
+
+  const overlayHtml = shouldBlur ? `<div class="civitai-nsfw-overlay" title="R-rated: click to reveal">R</div>` : '';
+  const containerClasses = `civitai-thumbnail-container${shouldBlur ? ' blurred' : ''}`;
+
+  const previewHtml = `
+    <div class="civitai-search-item" style="background-color: var(--comfy-input-bg);">
+      <div class="${containerClasses}" data-nsfw-level="${Number.isFinite(nsfwLevel) ? nsfwLevel : ''}">
+        <img src="${thumbnail}" alt="${modelName} thumbnail" class="civitai-search-thumbnail" loading="lazy" onerror="${onErrorScript}">
+        ${overlayHtml}
+        <div class="civitai-type-badge">${modelType}</div>
+      </div>
+      <div class="civitai-search-info">
+        <h4>${modelName} <span style="font-weight: normal; font-size: 0.9em;">by ${creator}</span></h4>
+        <p style="font-weight: bold;">Version: ${versionName} <span class="base-model-badge" style="margin-left: 5px;">${baseModel}</span></p>
+        <div class="civitai-search-stats" title="Stats: Downloads / Rating (Count) / Likes">
+          <span title="Downloads"><i class="fas fa-download"></i> ${stats.downloads?.toLocaleString() || 0}</span>
+          <span title="Likes"><i class="fas fa-thumbs-up"></i> ${stats.likes?.toLocaleString(0) || 0}</span>
+          <span title="Dislikes"><i class="fas fa-thumbs-down"></i> ${stats.dislikes?.toLocaleString() || 0}</span>
+          <span title="Buzz"><i class="fas fa-bolt"></i> ${stats.buzz?.toLocaleString() || 0}</span>
+        </div>
+        <p style="font-weight: bold; margin-top: 10px;">Primary File:</p>
+        <p style="font-size: 0.9em; color: #ccc;">
+          Name: ${fileInfo.name || 'N/A'}<br>
+          Size: ${ui.formatBytes(fileInfo.size_kb * 1024) || 'N/A'} <br>
+          Format: ${fileInfo.format || 'N/A'}<br>
+          Precision: ${fileInfo.precision || 'N/A'}<br>
+          Model Size: ${fileInfo.model_size || 'N/A'}
+        </p>
+        ${files.length > 0 ? `
+          <div class=\"civitai-form-group\" style=\"margin-top: 10px;\">
+            <label for=\"civitai-file-select\">Choose File (optional)</label>
+            <select id=\"civitai-file-select\" class=\"civitai-select\">
+              <option value=\"\">Auto (primary/best)</option>
+              ${files.map(f => {
+                const id = f.id ?? '';
+                const name = (f.name || '').replace(/</g,'&lt;');
+                const fmt = f.format || 'N/A';
+                const prec = (f.precision || '').toUpperCase();
+                const msize = f.model_size || '';
+                const size = (typeof f.size_kb === 'number') ? ui.formatBytes(f.size_kb * 1024) : 'N/A';
+                const disabled = f.downloadable ? '' : 'disabled';
+                const title = f.downloadable ? '' : ' (not downloadable)';
+                const extras = [prec, msize].filter(Boolean).join(' • ');
+                return `<option value=\"${id}\" ${disabled}>#${id} • ${name} • ${fmt}${extras ? ' • ' + extras : ''} • ${size}${title}</option>`;
+              }).join('')}
+            </select>
+            <p style=\"font-size: 0.9em; color: #aaa; margin-top: 6px;\">Pick other variants when available.</p>
+          </div>
+        ` : ''}
+        <a href="${civitaiLink}" target="_blank" rel="noopener noreferrer" class="civitai-button small" title="Open on Civitai website" style="margin-top: 5px; display: inline-block;">
+          View on Civitai <i class="fas fa-external-link-alt"></i>
+        </a>
+      </div>
+    </div>
+    <div style="margin-top: 15px;">
+      <h5 style="margin-bottom: 5px;">Model Description:</h5>
+      <div class="model-description-content" style="max-height: 200px; overflow-y: auto; background-color: var(--comfy-input-bg); padding: 10px; border-radius: 4px; font-size: 0.9em; border: 1px solid var(--border-color, #555);">
+        ${descriptionHtml}
+      </div>
+    </div>
+    <div style="margin-top: 15px;">
+      <h5 style="margin-bottom: 5px;">Version Description:</h5>
+      <div class="model-description-content" style="max-height: 200px; overflow-y: auto; background-color: var(--comfy-input-bg); padding: 10px; border-radius: 4px; font-size: 0.9em; border: 1px solid var(--border-color, #555);">
+        ${version_description_html}
+      </div>
+    </div>
+  `;
+
+  ui.downloadPreviewArea.innerHTML = previewHtml;
+}

custom_nodes/Civicomfy/web/js/ui/searchRenderer.js

@@ -0,0 +1,189 @@
+// Rendering of search results list
+// Usage: renderSearchResults(uiInstance, itemsArray)
+
+const PLACEHOLDER_IMAGE_URL = `/extensions/Civicomfy/images/placeholder.jpeg`;
+
+export function renderSearchResults(ui, items) {
+  ui.feedback?.ensureFontAwesome();
+
+  if (!items || items.length === 0) {
+    const queryUsed = ui.searchQueryInput && ui.searchQueryInput.value.trim();
+    const typeFilterUsed = ui.searchTypeSelect && ui.searchTypeSelect.value !== 'any';
+    const baseModelFilterUsed = ui.searchBaseModelSelect && ui.searchBaseModelSelect.value !== 'any';
+    const message = (queryUsed || typeFilterUsed || baseModelFilterUsed)
+      ? 'No models found matching your criteria.'
+      : 'Enter a query or select filters and click Search.';
+    ui.searchResultsContainer.innerHTML = `<p>${message}</p>`;
+    return;
+  }
+
+  const placeholder = PLACEHOLDER_IMAGE_URL;
+  const onErrorScript = `this.onerror=null; this.src='${placeholder}'; this.style.backgroundColor='#444';`;
+  const fragment = document.createDocumentFragment();
+
+  items.forEach(hit => {
+    const modelId = hit.id;
+    if (!modelId) return;
+
+    const creator = hit.user?.username || 'Unknown Creator';
+    const modelName = hit.name || 'Untitled Model';
+    const modelTypeApi = hit.type || 'other';
+    console.log('Model type for badge:', modelTypeApi);
+    const stats = hit.metrics || {};
+    const tags = hit.tags?.map(t => t.name) || [];
+
+    const thumbnailUrl = hit.thumbnailUrl || placeholder;
+    const firstImage = Array.isArray(hit.images) && hit.images.length > 0 ? hit.images[0] : null;
+    const thumbnailType = firstImage?.type;
+    const nsfwLevel = Number(firstImage?.nsfwLevel ?? hit.nsfwLevel ?? 0);
+    const blurMinLevel = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+    const shouldBlur = ui.settings?.hideMatureInSearch === true && nsfwLevel >= blurMinLevel;
+
+    const allVersions = hit.versions || [];
+    const primaryVersion = hit.version || (allVersions.length > 0 ? allVersions[0] : {});
+    const primaryVersionId = primaryVersion.id;
+    const primaryBaseModel = primaryVersion.baseModel || 'N/A';
+
+    const uniqueBaseModels = allVersions.length > 0
+      ? [...new Set(allVersions.map(v => v.baseModel).filter(Boolean))]
+      : (primaryBaseModel !== 'N/A' ? [primaryBaseModel] : []);
+    const baseModelsDisplay = uniqueBaseModels.length > 0 ? uniqueBaseModels.join(', ') : 'N/A';
+
+    const publishedAt = hit.publishedAt;
+    let lastUpdatedFormatted = 'N/A';
+    if (publishedAt) {
+      try {
+        const date = new Date(publishedAt);
+        lastUpdatedFormatted = date.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+      } catch (_) {}
+    }
+
+    const listItem = document.createElement('div');
+    listItem.className = 'civitai-search-item';
+    listItem.dataset.modelId = modelId;
+
+    const MAX_VISIBLE_VERSIONS = 3;
+    let visibleVersions = [];
+    if (primaryVersionId) {
+      visibleVersions.push({ id: primaryVersionId, name: primaryVersion.name || 'Primary Version', baseModel: primaryBaseModel });
+    }
+    allVersions.forEach(v => {
+      if (v.id !== primaryVersionId && visibleVersions.length < MAX_VISIBLE_VERSIONS) visibleVersions.push(v);
+    });
+
+    let versionButtonsHtml = visibleVersions.map(version => {
+      const versionId = version.id;
+      const versionName = version.name || 'Unknown Version';
+      const baseModel = version.baseModel || 'N/A';
+      return `
+        <button class="civitai-button primary small civitai-search-download-button"
+                data-model-id="${modelId}"
+                data-version-id="${versionId || ''}"
+                data-model-type="${modelTypeApi || ''}"
+                ${!versionId ? 'disabled title="Version ID missing, cannot pre-fill"' : 'title="Pre-fill Download Tab"'} >
+          <span class="base-model-badge">${baseModel}</span> ${versionName} <i class="fas fa-download"></i>
+        </button>
+      `;
+    }).join('');
+
+    const hasMoreVersions = allVersions.length > visibleVersions.length;
+    const totalVersionCount = allVersions.length;
+    const moreButtonHtml = hasMoreVersions ? `
+      <button class="civitai-button secondary small show-all-versions-button"
+              data-model-id="${modelId}"
+              data-total-versions="${totalVersionCount}"
+              title="Show all ${totalVersionCount} versions">
+        All versions (${totalVersionCount}) <i class="fas fa-chevron-down"></i>
+      </button>
+    ` : '';
+
+    let allVersionsHtml = '';
+    if (hasMoreVersions) {
+      const hiddenVersions = allVersions.filter(v => !visibleVersions.some(vis => vis.id === v.id));
+      allVersionsHtml = `
+        <div class="all-versions-container" id="all-versions-${modelId}" style="display: none;">
+          ${hiddenVersions.map(version => {
+            const versionId = version.id;
+            const versionName = version.name || 'Unknown Version';
+            const baseModel = version.baseModel || 'N/A';
+            return `
+              <button class="civitai-button primary small civitai-search-download-button"
+                      data-model-id="${modelId}"
+                      data-version-id="${versionId || ''}"
+                      data-model-type="${modelTypeApi || ''}"
+                      ${!versionId ? 'disabled title="Version ID missing, cannot pre-fill"' : 'title="Pre-fill Download Tab"'} >
+                <span class="base-model-badge">${baseModel}</span> ${versionName} <i class="fas fa-download"></i>
+              </button>
+            `;
+          }).join('')}
+        </div>
+      `;
+    }
+
+    let thumbnailHtml = '';
+    const videoTitle = `Video preview for ${modelName}`;
+    const imageAlt = `${modelName} thumbnail`;
+    if (thumbnailUrl && typeof thumbnailUrl === 'string' && thumbnailType === 'video') {
+      thumbnailHtml = `
+        <video class="civitai-search-thumbnail" src="${thumbnailUrl}" autoplay loop muted playsinline
+               title="${videoTitle}"
+               onerror="console.error('Failed to load video preview:', this.src)">
+          Your browser does not support the video tag.
+        </video>
+      `;
+    } else {
+      const effective = thumbnailUrl || placeholder;
+      thumbnailHtml = `
+        <img src="${effective}" alt="${imageAlt}" class="civitai-search-thumbnail" loading="lazy" onerror="${onErrorScript}">
+      `;
+    }
+
+    const overlayHtml = shouldBlur ? `<div class="civitai-nsfw-overlay" title="R-rated: click to reveal">R</div>` : '';
+    const containerClasses = `civitai-thumbnail-container${shouldBlur ? ' blurred' : ''}`;
+
+    listItem.innerHTML = `
+      <div class="${containerClasses}" data-nsfw-level="${nsfwLevel ?? ''}">
+        ${thumbnailHtml}
+        ${overlayHtml}
+        <div class="civitai-type-badge" data-type="${modelTypeApi.toLowerCase()}">${modelTypeApi}</div>
+      </div>
+      <div class="civitai-search-info">
+        <h4>${modelName}</h4>
+        <div class="civitai-search-meta-info">
+          <span title="Creator: ${creator}"><i class="fas fa-user"></i> ${creator}</span>
+          <span title="Base Models: ${baseModelsDisplay}"><i class="fas fa-layer-group"></i> ${baseModelsDisplay}</span>
+          <span title="Published: ${lastUpdatedFormatted}"><i class="fas fa-calendar-alt"></i> ${lastUpdatedFormatted}</span>
+        </div>
+        <div class="civitai-search-stats" title="Stats: Downloads / Rating (Count) / Likes">
+          <span title="Downloads"><i class="fas fa-download"></i> ${stats.downloadCount?.toLocaleString() || 0}</span>
+          <span title="Thumbs"><i class="fas fa-thumbs-up"></i> ${stats.thumbsUpCount?.toLocaleString() || 0}</span>
+          <span title="Collected"><i class="fas fa-archive"></i> ${stats.collectedCount?.toLocaleString() || 0}</span>
+          <span title="Buzz"><i class="fas fa-bolt"></i> ${stats.tippedAmountCount?.toLocaleString() || 0}</span>
+        </div>
+        ${tags.length > 0 ? `
+        <div class="civitai-search-tags" title="${tags.join(', ')}">
+          ${tags.slice(0, 5).map(tag => `<span class="civitai-search-tag">${tag}</span>`).join('')}
+          ${tags.length > 5 ? `<span class="civitai-search-tag">...</span>` : ''}
+        </div>
+        ` : ''}
+      </div>
+      <div class="civitai-search-actions">
+        <a href="https://civitai.com/models/${modelId}${primaryVersionId ? '?modelVersionId='+primaryVersionId : ''}" 
+           target="_blank" rel="noopener noreferrer" class="civitai-button small" 
+           title="Open on Civitai website">
+          View <i class="fas fa-external-link-alt"></i>
+        </a>
+        <div class="version-buttons-container">
+          ${versionButtonsHtml}
+          ${moreButtonHtml}
+        </div>
+        ${allVersionsHtml}
+      </div>
+    `;
+
+    fragment.appendChild(listItem);
+  });
+
+  ui.searchResultsContainer.innerHTML = '';
+  ui.searchResultsContainer.appendChild(fragment);
+}

custom_nodes/Civicomfy/web/js/ui/statusRenderer.js

@@ -0,0 +1,113 @@
+// Renders active/queued/history download lists
+
+const PLACEHOLDER_IMAGE_URL = `/extensions/Civicomfy/images/placeholder.jpeg`;
+
+export function renderDownloadList(ui, items, container, emptyMessage) {
+  if (!items || items.length === 0) {
+    container.innerHTML = `<p>${emptyMessage}</p>`;
+    return;
+  }
+
+  const fragment = document.createDocumentFragment();
+  items.forEach(item => {
+    const id = item.id || 'unknown-id';
+    const progress = item.progress !== undefined ? Math.max(0, Math.min(100, item.progress)) : 0;
+    const speed = item.speed !== undefined ? Math.max(0, item.speed) : 0;
+    const status = item.status || 'unknown';
+    const size = item.known_size !== undefined && item.known_size !== null ? item.known_size : (item.file_size || 0);
+    const downloadedBytes = size > 0 ? size * (progress / 100) : 0;
+    const errorMsg = item.error || null;
+    const modelName = item.model_name || item.model?.name || 'Unknown Model';
+    const versionName = item.version_name || 'Unknown Version';
+    const filename = item.filename || 'N/A';
+    const addedTime = item.added_time || null;
+    const startTime = item.start_time || null;
+    const endTime = item.end_time || null;
+    const thumbnail = item.thumbnail || PLACEHOLDER_IMAGE_URL;
+    const nsfwLevel = Number(item.thumbnail_nsfw_level ?? 0);
+    const blurMinLevel = Number(ui.settings?.nsfwBlurMinLevel ?? 4);
+    const shouldBlur = ui.settings?.hideMatureInSearch === true && nsfwLevel >= blurMinLevel;
+    const connectionType = item.connection_type || "N/A";
+
+    let progressBarClass = '';
+    let statusText = status.charAt(0).toUpperCase() + status.slice(1);
+    switch (status) {
+      case 'completed': progressBarClass = 'completed'; break;
+      case 'failed': progressBarClass = 'failed'; statusText = 'Failed'; break;
+      case 'cancelled': progressBarClass = 'cancelled'; statusText = 'Cancelled'; break;
+      case 'downloading': case 'queued': case 'starting': default: break;
+    }
+
+    const listItem = document.createElement('div');
+    listItem.className = 'civitai-download-item';
+    listItem.dataset.id = id;
+
+    const onErrorScript = `this.onerror=null; this.src='${PLACEHOLDER_IMAGE_URL}'; this.style.backgroundColor='#444';`;
+    const addedTooltip = addedTime ? `data-tooltip="Added: ${new Date(addedTime).toLocaleString()}"` : '';
+    const startedTooltip = startTime ? `data-tooltip="Started: ${new Date(startTime).toLocaleString()}"` : '';
+    const endedTooltip = endTime ? `data-tooltip="Ended: ${new Date(endTime).toLocaleString()}"` : '';
+    const durationTooltip = startTime && endTime ? `data-tooltip="Duration: ${ui.formatDuration(startTime, endTime)}"` : '';
+    const filenameTooltip = filename !== 'N/A' ? `title="Filename: ${filename}"` : '';
+    const errorTooltip = errorMsg ? `title="Error Details: ${String(errorMsg).substring(0, 200)}${String(errorMsg).length > 200 ? '...' : ''}"` : '';
+    const connectionInfoHtml = connectionType !== "N/A" ? `<span style="font-size: 0.85em; color: #aaa; margin-left: 10px;">(Conn: ${connectionType})</span>` : '';
+
+    const overlayHtml = shouldBlur ? `<div class=\"civitai-nsfw-overlay\" title=\"R-rated: click to reveal\">R</div>` : '';
+    const containerClasses = `civitai-thumbnail-container${shouldBlur ? ' blurred' : ''}`;
+
+    let innerHTML = `
+      <div class="${containerClasses}" data-nsfw-level="${Number.isFinite(nsfwLevel) ? nsfwLevel : ''}">
+        <img src="${thumbnail}" alt="thumbnail" class="civitai-download-thumbnail" loading="lazy" onerror="${onErrorScript}">
+        ${overlayHtml}
+      </div>
+      <div class="civitai-download-info">
+        <strong>${modelName}</strong>
+        <p>Ver: ${versionName}</p>
+        <p class="filename" ${filenameTooltip}>${filename}</p>
+        ${size > 0 ? `<p>Size: ${ui.formatBytes(size)}</p>` : ''}
+        ${item.file_format ? `<p>Format: ${item.file_format}</p>` : ''}
+        ${item.file_precision || item.file_model_size ? `<p>${item.file_precision ? 'Precision: ' + String(item.file_precision).toUpperCase() : ''}${item.file_precision && item.file_model_size ? ' • ' : ''}${item.file_model_size ? 'Model Size: ' + item.file_model_size : ''}</p>` : ''}
+        ${errorMsg ? `<p class="error-message" ${errorTooltip}><i class="fas fa-exclamation-triangle"></i> ${String(errorMsg).substring(0, 100)}${String(errorMsg).length > 100 ? '...' : ''}</p>` : ''}
+    `;
+
+    if (status === 'downloading' || status === 'starting' || status === 'completed') {
+      const statusLine = `<div ${durationTooltip} ${endedTooltip}>Status: ${statusText} ${connectionInfoHtml}</div>`;
+      innerHTML += `
+        <div class="civitai-progress-container" title="${statusText} - ${progress.toFixed(1)}%">
+          <div class="civitai-progress-bar ${progressBarClass}" style="width: ${progress}%;">
+            ${progress > 15 ? progress.toFixed(0)+'%' : ''}
+          </div>
+        </div>
+      `;
+      const speedText = (status === 'downloading' && speed > 0) ? ui.formatSpeed(speed) : '';
+      const progressText = (status === 'downloading' && size > 0) ? `(${ui.formatBytes(downloadedBytes)} / ${ui.formatBytes(size)})` : '';
+      const completedText = status === 'completed' ? '' : '';
+      const speedProgLine = `<div class="civitai-speed-indicator">${speedText} ${progressText} ${completedText}</div>`;
+      if (status === 'downloading') { innerHTML += speedProgLine; }
+      innerHTML += statusLine;
+    } else if (status === 'failed' || status === 'cancelled' || status === 'queued') {
+      innerHTML += `<div class="status-line-simple" ${durationTooltip} ${endedTooltip} ${addedTooltip}>Status: ${statusText} ${connectionInfoHtml}</div>`;
+    } else {
+      innerHTML += `<div class="status-line-simple">Status: ${statusText} ${connectionInfoHtml}</div>`;
+    }
+
+    innerHTML += `</div>`;
+    innerHTML += `<div class="civitai-download-actions">`;
+    if (status === 'queued' || status === 'downloading' || status === 'starting') {
+      innerHTML += `<button class="civitai-button danger small civitai-cancel-button" data-id="${id}" title="Cancel Download"><i class="fas fa-times"></i></button>`;
+    }
+    if (status === 'failed' || status === 'cancelled') {
+      innerHTML += `<button class="civitai-button small civitai-retry-button" data-id="${id}" title="Retry Download"><i class="fas fa-redo"></i></button>`;
+    }
+    if (status === 'completed') {
+      innerHTML += `<button class="civitai-button small civitai-openpath-button" data-id="${id}" title="Open Containing Folder"><i class="fas fa-folder-open"></i></button>`;
+    }
+    innerHTML += `</div>`;
+
+    listItem.innerHTML = innerHTML;
+    fragment.appendChild(listItem);
+  });
+
+  container.innerHTML = '';
+  container.appendChild(fragment);
+  ui.ensureFontAwesome();
+}

custom_nodes/Civicomfy/web/js/ui/templates.js

@@ -0,0 +1,181 @@
+// Modal template for Civicomfy UI
+// Keep structure identical to the original inline HTML to minimize risk
+
+export function modalTemplate(settings = {}) {
+  const numConnections = Number.isFinite(settings.numConnections) ? settings.numConnections : 1;
+  return `
+    <div class="civitai-downloader-modal-content">
+      <div class="civitai-downloader-header">
+        <h2>Civicomfy</h2>
+        <button class="civitai-close-button" id="civitai-close-modal">&times;</button>
+      </div>
+      <div class="civitai-downloader-body">
+        <div class="civitai-downloader-tabs">
+          <button class="civitai-downloader-tab active" data-tab="download">Download</button>
+          <button class="civitai-downloader-tab" data-tab="search">Search</button>
+          <button class="civitai-downloader-tab" data-tab="status">Status <span id="civitai-status-indicator" style="display: none;">(<span id="civitai-active-count">0</span>)</span></button>
+          <button class="civitai-downloader-tab" data-tab="settings">Settings</button>
+        </div>
+        <div id="civitai-tab-download" class="civitai-downloader-tab-content active">
+          <form id="civitai-download-form">
+            <div class="civitai-form-group">
+              <label for="civitai-model-url">Model URL or ID</label>
+              <input type="text" id="civitai-model-url" class="civitai-input" placeholder="e.g., https://civitai.com/models/12345 or 12345" required>
+            </div>
+            <p style="font-size: 0.9em; color: #ccc; margin-top: -10px; margin-bottom: 15px;">You can optionally specify a version ID using "?modelVersionId=xxxxx" in the URL or in the field below.</p>
+            <div class="civitai-form-row">
+              <div class="civitai-form-group">
+                <label for="civitai-model-type">Model Type (Save Location)</label>
+                <div style="display:flex; gap:6px; align-items:center;">
+                  <select id="civitai-model-type" class="civitai-select" required></select>
+                  <button type="button" id="civitai-create-model-type" class="civitai-button small" title="Create new model type folder"><i class="fas fa-folder-plus"></i></button>
+                </div>
+              </div>
+              <div class="civitai-form-group">
+                <label for="civitai-subdir-select">Save Subfolder</label>
+                <div style="display:flex; gap:6px; align-items:center;">
+                  <select id="civitai-subdir-select" class="civitai-select">
+                    <option value="">(root)</option>
+                  </select>
+                  <button type="button" id="civitai-create-subdir" class="civitai-button small" title="Create new subfolder"><i class="fas fa-folder-plus"></i></button>
+                </div>
+              </div>
+              <div class="civitai-form-group">
+                <label for="civitai-model-version-id">Version ID (Optional)</label>
+                <input type="number" id="civitai-model-version-id" class="civitai-input" placeholder="Overrides URL/Latest">
+              </div>
+            </div>
+            <div class="civitai-form-row">
+              <div class="civitai-form-group">
+                <label for="civitai-custom-filename">Custom Filename (Optional)</label>
+                <input type="text" id="civitai-custom-filename" class="civitai-input" placeholder="Leave blank to use original name">
+              </div>
+              <div class="civitai-form-group">
+                <label for="civitai-connections">Connections</label>
+                <input type="number" id="civitai-connections" class="civitai-input" value="${numConnections}" min="1" max="16" step="1" required disabled>
+                <p style="font-size: 0.9em; color: #ccc; margin-top: 7px; margin-bottom: 15px;">Disabled: Only single connection possible for now</p>
+              </div>
+            </div>
+            <div class="civitai-form-group inline">
+              <input type="checkbox" id="civitai-force-redownload" class="civitai-checkbox">
+              <label for="civitai-force-redownload">Force Re-download (if exists)</label>
+            </div>
+            <div id="civitai-download-preview-area" class="civitai-download-preview-area" style="margin-top: 25px; margin-bottom: 25px; padding-top: 15px; border-top: 1px solid var(--border-color, #444);">
+              <!-- Preview content will be injected here -->
+            </div>
+            <button type="submit" id="civitai-download-submit" class="civitai-button primary">Start Download</button>
+          </form>
+        </div>
+        <div id="civitai-tab-search" class="civitai-downloader-tab-content">
+          <form id="civitai-search-form">
+            <div class="civitai-search-controls">
+              <input type="text" id="civitai-search-query" class="civitai-input" placeholder="Search Civitai...">
+              <select id="civitai-search-type" class="civitai-select">
+                <option value="any">Any Type</option>
+              </select>
+              <select id="civitai-search-base-model" class="civitai-select">
+                <option value="any">Any Base Model</option>
+              </select>
+              <select id="civitai-search-sort" class="civitai-select">
+                <option value="Relevancy">Relevancy</option>
+                <option value="Highest Rated">Highest Rated</option>
+                <option value="Most Liked">Most Liked</option>
+                <option value="Most Discussed">Most Discussed</option>
+                <option value="Most Collected">Most Collected</option>
+                <option value="Most Buzz">Most Buzz</option>
+                <option value="Most Downloaded">Most Downloaded</option>
+                <option value="Newest">Newest</option>
+              </select>
+            </div>
+            <button type="submit" id="civitai-search-submit" class="civitai-button primary">Search</button>
+          </form>
+          <div id="civitai-search-results" class="civitai-search-results"></div>
+          <div id="civitai-search-pagination" style="text-align: center; margin-top: 20px;"></div>
+        </div>
+        <div id="civitai-tab-status" class="civitai-downloader-tab-content">
+          <div id="civitai-status-content">
+            <div class="civitai-status-section">
+              <h3>Active Downloads</h3>
+              <div id="civitai-active-list" class="civitai-download-list">
+                <p>No active downloads.</p>
+              </div>
+            </div>
+            <div class="civitai-status-section">
+              <h3>Queued Downloads</h3>
+              <div id="civitai-queued-list" class="civitai-download-list">
+                <p>Download queue is empty.</p>
+              </div>
+            </div>
+            <div class="civitai-status-section">
+              <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+                <h3>Download History (Recent)</h3>
+                <button id="civitai-clear-history-button" class="civitai-button danger small" title="Clear all history items">
+                  <i class="fas fa-trash-alt"></i> Clear History
+                </button>
+              </div>
+              <div id="civitai-history-list" class="civitai-download-list">
+                <p>No download history yet.</p>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div id="civitai-tab-settings" class="civitai-downloader-tab-content">
+          <form id="civitai-settings-form">
+            <div class="civitai-settings-container">
+              <div class="civitai-settings-section">
+                <h4>API & Defaults</h4>
+                <div class="civitai-form-group">
+                  <label for="civitai-settings-api-key">Civitai API Key (Optional)</label>
+                  <input type="password" id="civitai-settings-api-key" class="civitai-input" placeholder="Enter API key for higher limits / authenticated access" autocomplete="new-password">
+                  <p style="font-size: 0.85em; color: #bbb; margin-top: 5px;">Needed for some downloads/features. Find keys at civitai.com/user/account</p>
+                </div>
+                <div class="civitai-form-group">
+                  <label for="civitai-settings-connections">Default Connections</label>
+                  <input type="number" id="civitai-settings-connections" class="civitai-input" value="1" min="1" max="16" step="1" required disabled>
+                  <p style="font-size: 0.85em; color: #bbb; margin-top: 5px;">Disabled. Only single connection possible for now</p>
+                </div>
+                <div class="civitai-form-group">
+                  <label for="civitai-settings-default-type">Default Model Type (for saving)</label>
+                  <select id="civitai-settings-default-type" class="civitai-select" required></select>
+                </div>
+              </div>
+              <div class="civitai-settings-section">
+                <h4>Interface & Search</h4>
+                <div class="civitai-form-group inline">
+                  <input type="checkbox" id="civitai-settings-auto-open-status" class="civitai-checkbox">
+                  <label for="civitai-settings-auto-open-status">Switch to Status tab after starting download</label>
+                </div>
+                <div class="civitai-form-group inline">
+                  <input type="checkbox" id="civitai-settings-hide-mature" class="civitai-checkbox" ${settings.hideMatureInSearch ? 'checked' : ''}>
+                  <label for="civitai-settings-hide-mature">Hide R-rated (Mature) images in search (click to reveal)</label>
+                </div>
+                <div class="civitai-form-group">
+                  <label for="civitai-settings-nsfw-threshold">NSFW Blur Threshold (nsfwLevel)</label>
+                  <input type="number" id="civitai-settings-nsfw-threshold" class="civitai-input" value="${Number.isFinite(settings.nsfwBlurMinLevel) ? settings.nsfwBlurMinLevel : 4}" min="0" max="128" step="1">
+                  <p style="font-size: 0.85em; color: #bbb; margin-top: 5px;">
+                    Blur thumbnails when an image's <code>nsfwLevel</code> is greater than or equal to this value.
+                    Higher numbers indicate more explicit content. None (Safe/PG): 1, Mild (PG-13): 2, Mature (R): 4, Adult (X): 5, Extra Explicit (R): 8, Explicit (XXX): 16/32+
+                  </p>
+                </div>
+              </div>
+            </div>
+            <button type="submit" id="civitai-settings-save" class="civitai-button primary" style="margin-top: 20px;">Save Settings</button>
+          </form>
+        </div>
+      </div>
+      <!-- Toast Notification Area -->
+      <div id="civitai-toast" class="civitai-toast"></div>
+      <!-- Confirmation Modal -->
+      <div id="civitai-confirm-clear-modal" class="civitai-confirmation-modal">
+        <div class="civitai-confirmation-modal-content">
+          <h4>Confirm Clear History</h4>
+          <p>Are you sure you want to clear the download history? This action cannot be undone.</p>
+          <div class="civitai-confirmation-modal-actions">
+            <button id="civitai-confirm-clear-no" class="civitai-button secondary">Cancel</button>
+            <button id="civitai-confirm-clear-yes" class="civitai-button danger">Confirm Clear</button>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}

custom_nodes/Civicomfy/web/js/utils/cookies.js

@@ -0,0 +1,24 @@
+// Lightweight cookie helpers for Civicomfy UI
+// Exports: setCookie, getCookie
+
+export function setCookie(name, value, days) {
+  let expires = "";
+  if (days) {
+    const date = new Date();
+    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+    expires = "; expires=" + date.toUTCString();
+  }
+  document.cookie = `${name}=${value || ""}${expires}; path=/; SameSite=Lax`;
+}
+
+export function getCookie(name) {
+  const nameEQ = name + "=";
+  const parts = document.cookie.split(";");
+  for (let i = 0; i < parts.length; i++) {
+    let c = parts[i];
+    while (c.charAt(0) === " ") c = c.substring(1);
+    if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length);
+  }
+  return null;
+}
+