feat: update README and pyproject.toml for v0.8.10 release; add standalone mode and portable edition features

Dev

README.md

@@ -20,6 +20,24 @@ Watch this quick tutorial to learn how to use the new one-click LoRA integration
 
 ## Release Notes
 
+### v0.8.10
+* **Standalone Mode** - Run LoRA Manager independently from ComfyUI for a lightweight experience that works even with other stable diffusion interfaces
+* **Portable Edition** - New one-click portable version for easy startup and updates in standalone mode
+* **Enhanced Metadata Collection** - Added support for SamplerCustomAdvanced node in the metadata collector module
+* **Improved UI Organization** - Optimized Lora Loader node height to display up to 5 LoRAs at once with scrolling capability for larger collections
+
+### v0.8.9
+* **Favorites System** - New functionality to bookmark your favorite LoRAs and checkpoints for quick access and better organization
+* **Enhanced UI Controls** - Increased model card button sizes for improved usability and easier interaction
+* **Smoother Page Transitions** - Optimized interface switching between pages, eliminating flash issues particularly noticeable in dark theme
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
+### v0.8.8
+* **Real-time TriggerWord Updates** - Enhanced TriggerWord Toggle node to instantly update when connected Lora Loader or Lora Stacker nodes change, without requiring workflow execution
+* **Optimized Metadata Recovery** - Improved utilization of existing .civitai.info files for faster initialization and preservation of metadata from models deleted from CivitAI
+* **Migration Acceleration** - Further speed improvements for users transitioning from A1111/Forge environments
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
 ### v0.8.7
 * **Enhanced Context Menu** - Added comprehensive context menu functionality to Recipes and Checkpoints pages for improved workflow
 * **Interactive LoRA Strength Control** - Implemented drag functionality in LoRA Loader for intuitive strength adjustment
@@ -140,7 +158,7 @@ Watch this quick tutorial to learn how to use the new one-click LoRA integration
 ```bash
 git clone https://github.com/willmiao/ComfyUI-Lora-Manager.git
 cd ComfyUI-Lora-Manager
-pip install requirements.txt
+pip install -r requirements.txt
 ```
 
 ## Usage
@@ -161,23 +179,92 @@ pip install requirements.txt
    - Paste into the Lora Loader node's text input
    - The node will automatically apply preset strength and trigger words
 
+### Filename Format Patterns for Save Image Node
+
+The Save Image Node supports dynamic filename generation using pattern codes. You can customize how your images are named using the following format patterns:
+
+#### Available Pattern Codes
+
+- `%seed%` - Inserts the generation seed number
+- `%width%` - Inserts the image width
+- `%height%` - Inserts the image height
+- `%pprompt:N%` - Inserts the positive prompt (limited to N characters)
+- `%nprompt:N%` - Inserts the negative prompt (limited to N characters)
+- `%model:N%` - Inserts the model/checkpoint name (limited to N characters)
+- `%date%` - Inserts current date/time as "yyyyMMddhhmmss"
+- `%date:FORMAT%` - Inserts date using custom format with:
+  - `yyyy` - 4-digit year
+  - `yy` - 2-digit year
+  - `MM` - 2-digit month
+  - `dd` - 2-digit day
+  - `hh` - 2-digit hour
+  - `mm` - 2-digit minute
+  - `ss` - 2-digit second
+
+#### Examples
+
+- `image_%seed%` → `image_1234567890`
+- `gen_%width%x%height%` → `gen_512x768`
+- `%model:10%_%seed%` → `dreamshape_1234567890`
+- `%date:yyyy-MM-dd%` → `2025-04-28`
+- `%pprompt:20%_%seed%` → `beautiful landscape_1234567890`
+- `%model%_%date:yyMMdd%_%seed%` → `dreamshaper_v8_250428_1234567890`
+
+You can combine multiple patterns to create detailed, organized filenames for your generated images.
+
+### Standalone Mode
+
+You can now run LoRA Manager independently from ComfyUI:
+
+1. **For ComfyUI users**:
+   - Launch ComfyUI with LoRA Manager at least once to initialize the necessary path information in the `settings.json` file.
+   - Make sure dependencies are installed: `pip install -r requirements.txt`
+   - From your ComfyUI root directory, run:
+     ```bash
+     python custom_nodes\comfyui-lora-manager\standalone.py
+     ```
+   - Access the interface at: `http://localhost:8188/loras`
+   - You can specify a different host or port with arguments:
+     ```bash
+     python custom_nodes\comfyui-lora-manager\standalone.py --host 127.0.0.1 --port 9000
+     ```
+
+2. **For non-ComfyUI users**:
+   - Copy the provided `settings.json.example` file to create a new file named `settings.json`
+   - Edit `settings.json` to include your correct model folder paths and CivitAI API key
+   - Install required dependencies: `pip install -r requirements.txt`
+   - Run standalone mode:
+     ```bash
+     python standalone.py
+     ```
+   - Access the interface through your browser at: `http://localhost:8188/loras`
+
+This standalone mode provides a lightweight option for managing your model and recipe collection without needing to run the full ComfyUI environment, making it useful even for users who primarily use other stable diffusion interfaces.
+
+---
+
+## Contributing
+
+Thank you for your interest in contributing to ComfyUI LoRA Manager! As this project is currently in its early stages and undergoing rapid development and refactoring, we are temporarily not accepting pull requests.
+
+However, your feedback and ideas are extremely valuable to us:
+- Please feel free to open issues for any bugs you encounter
+- Submit feature requests through GitHub issues
+- Share your suggestions for improvements
+
+We appreciate your understanding and look forward to potentially accepting code contributions once the project architecture stabilizes.
+
 ---
 
 ## Credits
 
 This project has been inspired by and benefited from other excellent ComfyUI extensions:
 
-- [ComfyUI-SaveImageWithMetaData](https://github.com/Comfy-Community/ComfyUI-SaveImageWithMetaData) - For the image metadata functionality
+- [ComfyUI-SaveImageWithMetaData](https://github.com/nkchocoai/ComfyUI-SaveImageWithMetaData) - For the image metadata functionality
 - [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) - For the lora loader functionality
 
 ---
 
-## Contributing
-
-If you have suggestions, bug reports, or improvements, feel free to open an issue or contribute directly to the codebase. Pull requests are always welcome!
-
----
-
 ## ☕ Support
 
 If you find this project helpful, consider supporting its development:
@@ -190,3 +277,4 @@ Join our Discord community for support, discussions, and updates:
 [Discord Server](https://discord.gg/vcqNrWVFvM)
 
 ---
+````

py/config.py

@@ -3,6 +3,11 @@ import platform
 import folder_paths # type: ignore
 from typing import List
 import logging
+import sys
+import json
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
 
 logger = logging.getLogger(__name__)
 
@@ -18,9 +23,46 @@ class Config:
         self._route_mappings = {}
         self.loras_roots = self._init_lora_paths()
         self.checkpoints_roots = self._init_checkpoint_paths()
-        self.temp_directory = folder_paths.get_temp_directory()
         # 在初始化时扫描符号链接
         self._scan_symbolic_links()
+        
+        if not standalone_mode:
+            # Save the paths to settings.json when running in ComfyUI mode
+            self.save_folder_paths_to_settings()
+
+    def save_folder_paths_to_settings(self):
+        """Save folder paths to settings.json for standalone mode to use later"""
+        try:
+            # Check if we're running in ComfyUI mode (not standalone)
+            if hasattr(folder_paths, "get_folder_paths") and not isinstance(folder_paths, type):
+                # Get all relevant paths
+                lora_paths = folder_paths.get_folder_paths("loras")
+                checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
+                diffuser_paths = folder_paths.get_folder_paths("diffusers")
+                unet_paths = folder_paths.get_folder_paths("unet")
+                
+                # Load existing settings
+                settings_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'settings.json')
+                settings = {}
+                if os.path.exists(settings_path):
+                    with open(settings_path, 'r', encoding='utf-8') as f:
+                        settings = json.load(f)
+                
+                # Update settings with paths
+                settings['folder_paths'] = {
+                    'loras': lora_paths,
+                    'checkpoints': checkpoint_paths,
+                    'diffusers': diffuser_paths,
+                    'unet': unet_paths
+                }
+                
+                # Save settings
+                with open(settings_path, 'w', encoding='utf-8') as f:
+                    json.dump(settings, f, indent=2)
+                
+                logger.info("Saved folder paths to settings.json")
+        except Exception as e:
+            logger.warning(f"Failed to save folder paths: {e}")
 
     def _is_link(self, path: str) -> bool:
         try:
@@ -103,50 +145,66 @@ class Config:
 
     def _init_lora_paths(self) -> List[str]:
         """Initialize and validate LoRA paths from ComfyUI settings"""
-        paths = sorted(set(path.replace(os.sep, "/") 
-                for path in folder_paths.get_folder_paths("loras") 
-                if os.path.exists(path)), key=lambda p: p.lower())
-        print("Found LoRA roots:", "\n - " + "\n - ".join(paths))
-        
-        if not paths:
-            raise ValueError("No valid loras folders found in ComfyUI configuration")
-        
-        # 初始化路径映射
-        for path in paths:
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            if real_path != path:
-                self.add_path_mapping(path, real_path)
-        
-        return paths
+        try:
+            raw_paths = folder_paths.get_folder_paths("loras")
+            
+            # Normalize and resolve symlinks, store mapping from resolved -> original
+            path_map = {}
+            for path in raw_paths:
+                if os.path.exists(path):
+                    real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
+                    path_map[real_path] = path_map.get(real_path, path.replace(os.sep, "/"))  # preserve first seen
+            
+            # Now sort and use only the deduplicated real paths
+            unique_paths = sorted(path_map.values(), key=lambda p: p.lower())
+            logger.info("Found LoRA roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            
+            if not unique_paths:
+                logger.warning("No valid loras folders found in ComfyUI configuration")
+                return []
+            
+            for original_path in unique_paths:
+                real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+                if real_path != original_path:
+                    self.add_path_mapping(original_path, real_path)
+            
+            return unique_paths
+        except Exception as e:
+            logger.warning(f"Error initializing LoRA paths: {e}")
+            return []
 
     def _init_checkpoint_paths(self) -> List[str]:
         """Initialize and validate checkpoint paths from ComfyUI settings"""
-        # Get checkpoint paths from folder_paths
-        checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
-        diffusion_paths = folder_paths.get_folder_paths("diffusers")
-        unet_paths = folder_paths.get_folder_paths("unet")
-        
-        # Combine all checkpoint-related paths
-        all_paths = checkpoint_paths + diffusion_paths + unet_paths
-        
-        # Filter and normalize paths
-        paths = sorted(set(path.replace(os.sep, "/") 
-                for path in all_paths 
-                if os.path.exists(path)), key=lambda p: p.lower())
-        
-        print("Found checkpoint roots:", paths)
-        
-        if not paths:
-            logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+        try:
+            # Get checkpoint paths from folder_paths
+            checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
+            diffusion_paths = folder_paths.get_folder_paths("diffusers")
+            unet_paths = folder_paths.get_folder_paths("unet")
+            
+            # Combine all checkpoint-related paths
+            all_paths = checkpoint_paths + diffusion_paths + unet_paths
+            
+            # Filter and normalize paths
+            paths = sorted(set(path.replace(os.sep, "/") 
+                    for path in all_paths 
+                    if os.path.exists(path)), key=lambda p: p.lower())
+            
+            logger.info("Found checkpoint roots:" + ("\n - " + "\n - ".join(paths) if paths else "[]"))
+            
+            if not paths:
+                logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+                return []
+            
+            # 初始化路径映射，与 LoRA 路径处理方式相同
+            for path in paths:
+                real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
+                if real_path != path:
+                    self.add_path_mapping(path, real_path)
+            
+            return paths
+        except Exception as e:
+            logger.warning(f"Error initializing checkpoint paths: {e}")
             return []
-        
-        # 初始化路径映射，与 LoRA 路径处理方式相同
-        for path in paths:
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            if real_path != path:
-                self.add_path_mapping(path, real_path)
-        
-        return paths
 
     def get_preview_static_url(self, preview_path: str) -> str:
         """Convert local preview path to static URL"""

py/lora_manager.py

@@ -5,11 +5,17 @@ from .routes.lora_routes import LoraRoutes
 from .routes.api_routes import ApiRoutes
 from .routes.recipe_routes import RecipeRoutes
 from .routes.checkpoints_routes import CheckpointsRoutes
+from .routes.update_routes import UpdateRoutes
+from .routes.usage_stats_routes import UsageStatsRoutes
 from .services.service_registry import ServiceRegistry
 import logging
+import sys
 
 logger = logging.getLogger(__name__)
 
+# Check if we're in standalone mode
+STANDALONE_MODE = 'nodes' not in sys.modules
+
 class LoraManager:
     """Main entry point for LoRA Manager plugin"""
     
@@ -18,6 +24,9 @@ class LoraManager:
         """Initialize and register all routes"""
         app = PromptServer.instance.app
 
+        # Configure aiohttp access logger to be less verbose
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+
         added_targets = set()  # Track already added target paths
         
         # Add static routes for each lora root
@@ -92,6 +101,8 @@ class LoraManager:
         checkpoints_routes.setup_routes(app)
         ApiRoutes.setup_routes(app)
         RecipeRoutes.setup_routes(app)
+        UpdateRoutes.setup_routes(app)  
+        UsageStatsRoutes.setup_routes(app)  # Register usage stats routes
         
         # Schedule service initialization 
         app.on_startup.append(lambda app: cls._initialize_services())
@@ -104,6 +115,9 @@ class LoraManager:
     async def _initialize_services(cls):
         """Initialize all services using the ServiceRegistry"""
         try:
+            # Ensure aiohttp access logger is configured with reduced verbosity
+            logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+            
             # Initialize CivitaiClient first to ensure it's ready for other services
             civitai_client = await ServiceRegistry.get_civitai_client()
             
@@ -133,6 +147,12 @@ class LoraManager:
             # Initialize recipe scanner if needed
             recipe_scanner = await ServiceRegistry.get_recipe_scanner()
             
+            # Initialize metadata collector if not in standalone mode
+            if not STANDALONE_MODE:
+                from .metadata_collector import init as init_metadata
+                init_metadata()
+                logger.debug("Metadata collector initialized")
+            
             # Create low-priority initialization tasks
             asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init')
             asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init')

py/metadata_collector/__init__.py

@@ -1,18 +1,32 @@
 import os
 import importlib
-from .metadata_hook import MetadataHook
-from .metadata_registry import MetadataRegistry
+import sys
 
-def init():
-    # Install hooks to collect metadata during execution
-    MetadataHook.install()
-    
-    # Initialize registry
-    registry = MetadataRegistry()
-    
-    print("ComfyUI Metadata Collector initialized")
-    
-def get_metadata(prompt_id=None):
-    """Helper function to get metadata from the registry"""
-    registry = MetadataRegistry()
-    return registry.get_metadata(prompt_id)
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
+if not standalone_mode:
+    from .metadata_hook import MetadataHook
+    from .metadata_registry import MetadataRegistry
+
+    def init():
+        # Install hooks to collect metadata during execution
+        MetadataHook.install()
+        
+        # Initialize registry
+        registry = MetadataRegistry()
+        
+        print("ComfyUI Metadata Collector initialized")
+        
+    def get_metadata(prompt_id=None):
+        """Helper function to get metadata from the registry"""
+        registry = MetadataRegistry()
+        return registry.get_metadata(prompt_id)
+else:
+    # Standalone mode - provide dummy implementations
+    def init():
+        print("ComfyUI Metadata Collector disabled in standalone mode")
+        
+    def get_metadata(prompt_id=None):
+        """Dummy implementation for standalone mode"""
+        return {}

py/metadata_collector/constants.py

@@ -1,12 +1,14 @@
 """Constants used by the metadata collector"""
 
-# Individual category constants
+# Metadata collection constants
+
+# Metadata categories
 MODELS = "models"
 PROMPTS = "prompts"
 SAMPLING = "sampling"
 LORAS = "loras"
 SIZE = "size"
-IMAGES = "images"  # Added new category for image results
+IMAGES = "images"
 
-# Collection of categories for iteration
-METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]  # Added IMAGES to categories
+# Complete list of categories to track
+METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]

py/metadata_collector/metadata_processor.py

@@ -1,4 +1,8 @@
 import json
+import sys
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
 
 from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE
 
@@ -11,7 +15,16 @@ class MetadataProcessor:
         primary_sampler = None
         primary_sampler_id = None
         
-        # First, check for KSamplerAdvanced with add_noise="enable"
+        # First, check for SamplerCustomAdvanced
+        prompt = metadata.get("current_prompt")
+        if prompt and prompt.original_prompt:
+            for node_id, node_info in prompt.original_prompt.items():
+                if node_info.get("class_type") == "SamplerCustomAdvanced":
+                    # Found a SamplerCustomAdvanced node
+                    if node_id in metadata.get(SAMPLING, {}):
+                        return node_id, metadata[SAMPLING][node_id]
+        
+        # Next, check for KSamplerAdvanced with add_noise="enable"
         for node_id, sampler_info in metadata.get(SAMPLING, {}).items():
             parameters = sampler_info.get("parameters", {})
             add_noise = parameters.get("add_noise")
@@ -22,7 +35,7 @@ class MetadataProcessor:
                 primary_sampler_id = node_id
                 break
         
-        # If no KSamplerAdvanced found, fall back to traditional KSampler with denoise=1
+        # If no specialized sampler found, fall back to traditional KSampler with denoise=1
         if primary_sampler is None:
             for node_id, sampler_info in metadata.get(SAMPLING, {}).items():
                 parameters = sampler_info.get("parameters", {})
@@ -152,22 +165,60 @@ class MetadataProcessor:
             
             # Trace connections from the primary sampler
             if prompt and primary_sampler_id:
-                # Trace positive prompt - look specifically for CLIPTextEncode
-                positive_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "CLIPTextEncode", max_depth=10)
-                if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
-                    params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                # Check if this is a SamplerCustomAdvanced node
+                is_custom_advanced = False
+                if prompt.original_prompt and primary_sampler_id in prompt.original_prompt:
+                    is_custom_advanced = prompt.original_prompt[primary_sampler_id].get("class_type") == "SamplerCustomAdvanced"
                 
-                # Find any FluxGuidance nodes in the positive conditioning path
-                flux_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "FluxGuidance", max_depth=5)
-                if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
-                    flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
-                    params["guidance"] = flux_params.get("guidance")
+                if is_custom_advanced:
+                    # For SamplerCustomAdvanced, trace specific inputs
+                    
+                    # 1. Trace sigmas input to find BasicScheduler
+                    scheduler_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "sigmas", "BasicScheduler", max_depth=5)
+                    if scheduler_node_id and scheduler_node_id in metadata.get(SAMPLING, {}):
+                        scheduler_params = metadata[SAMPLING][scheduler_node_id].get("parameters", {})
+                        params["steps"] = scheduler_params.get("steps")
+                        params["scheduler"] = scheduler_params.get("scheduler")
+                    
+                    # 2. Trace sampler input to find KSamplerSelect
+                    sampler_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "sampler", "KSamplerSelect", max_depth=5)
+                    if sampler_node_id and sampler_node_id in metadata.get(SAMPLING, {}):
+                        sampler_params = metadata[SAMPLING][sampler_node_id].get("parameters", {})
+                        params["sampler"] = sampler_params.get("sampler_name")
+                    
+                    # 3. Trace guider input for FluxGuidance and CLIPTextEncode
+                    guider_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "guider", max_depth=5)
+                    if guider_node_id:
+                        # Look for FluxGuidance along the guider path
+                        flux_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "FluxGuidance", max_depth=5)
+                        if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
+                            flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
+                            params["guidance"] = flux_params.get("guidance")
+                        
+                        # Find CLIPTextEncode for positive prompt (through conditioning)
+                        positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "CLIPTextEncode", max_depth=10)
+                        if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                            params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
                 
-                # Trace negative prompt - look specifically for CLIPTextEncode
-                negative_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "negative", "CLIPTextEncode", max_depth=10)
-                if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
-                    params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
+                else:
+                    # Original tracing for standard samplers
+                    # Trace positive prompt - look specifically for CLIPTextEncode
+                    positive_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "CLIPTextEncode", max_depth=10)
+                    if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                        params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                    
+                    # Find any FluxGuidance nodes in the positive conditioning path
+                    flux_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "FluxGuidance", max_depth=5)
+                    if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
+                        flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
+                        params["guidance"] = flux_params.get("guidance")
+                    
+                    # Trace negative prompt - look specifically for CLIPTextEncode
+                    negative_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "negative", "CLIPTextEncode", max_depth=10)
+                    if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
+                        params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
                 
+                # Size extraction is same for all sampler types
                 # Check if the sampler itself has size information (from latent_image)
                 if primary_sampler_id in metadata.get(SIZE, {}):
                     width = metadata[SIZE][primary_sampler_id].get("width")
@@ -229,6 +280,10 @@ class MetadataProcessor:
     @staticmethod
     def to_dict(metadata):
         """Convert extracted metadata to the ComfyUI output.json format"""           
+        if standalone_mode:
+            # Return empty dictionary in standalone mode
+            return {}
+        
         params = MetadataProcessor.extract_generation_params(metadata)
         
         # Convert all values to strings to match output.json format

py/metadata_collector/node_extractors.py

@@ -257,12 +257,85 @@ class VAEDecodeExtractor(NodeMetadataExtractor):
         if "first_decode" not in metadata[IMAGES]:
             metadata[IMAGES]["first_decode"] = metadata[IMAGES][node_id]
 
+class KSamplerSelectExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "sampler_name" not in inputs:
+            return
+            
+        sampling_params = {}
+        if "sampler_name" in inputs:
+            sampling_params["sampler_name"] = inputs["sampler_name"]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+
+class BasicSchedulerExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+        for key in ["scheduler", "steps", "denoise"]:
+            if key in inputs:
+                sampling_params[key] = inputs[key]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+
+class SamplerCustomAdvancedExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+
+        # Handle noise.seed as seed
+        if "noise" in inputs and inputs["noise"] is not None and hasattr(inputs["noise"], "seed"):
+            noise = inputs["noise"]
+            sampling_params["seed"] = noise.seed
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+        
+        # Extract latent image dimensions if available
+        if "latent_image" in inputs and inputs["latent_image"] is not None:
+            latent = inputs["latent_image"]
+            if isinstance(latent, dict) and "samples" in latent:
+                # Extract dimensions from latent tensor
+                samples = latent["samples"]
+                if hasattr(samples, "shape") and len(samples.shape) >= 3:
+                    # Correct shape interpretation: [batch_size, channels, height/8, width/8]
+                    # Multiply by 8 to get actual pixel dimensions
+                    height = int(samples.shape[2] * 8)
+                    width = int(samples.shape[3] * 8)
+                    
+                    if SIZE not in metadata:
+                        metadata[SIZE] = {}
+                        
+                    metadata[SIZE][node_id] = {
+                        "width": width,
+                        "height": height,
+                        "node_id": node_id
+                    }
+
 # Registry of node-specific extractors
 NODE_EXTRACTORS = {
     # Sampling
     "KSampler": SamplerExtractor,
-    "KSamplerAdvanced": KSamplerAdvancedExtractor,  # Add KSamplerAdvanced
-    "SamplerCustomAdvanced": SamplerExtractor,  # Add SamplerCustomAdvanced
+    "KSamplerAdvanced": KSamplerAdvancedExtractor,
+    "SamplerCustomAdvanced": SamplerCustomAdvancedExtractor,  # Updated to use dedicated extractor
+    # Sampling Selectors
+    "KSamplerSelect": KSamplerSelectExtractor,  # Add KSamplerSelect
+    "BasicScheduler": BasicSchedulerExtractor,  # Add BasicScheduler
     # Loaders
     "CheckpointLoaderSimple": CheckpointLoaderExtractor,
     "UNETLoader": UNETLoaderExtractor,          # Updated to use dedicated extractor

py/nodes/lora_loader.py

@@ -5,7 +5,7 @@ from ..services.lora_scanner import LoraScanner
 from ..config import config
 import asyncio
 import os
-from .utils import FlexibleOptionalInputType, any_type
+from .utils import FlexibleOptionalInputType, any_type, get_lora_info, extract_lora_name, get_loras_list
 
 logger = logging.getLogger(__name__)
 
@@ -32,48 +32,6 @@ class LoraManagerLoader:
     RETURN_TYPES = ("MODEL", "CLIP", IO.STRING, IO.STRING)
     RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
     FUNCTION = "load_loras"
-
-    async def get_lora_info(self, lora_name):
-        """Get the lora path and trigger words from cache"""
-        scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
-        
-        for item in cache.raw_data:
-            if item.get('file_name') == lora_name:
-                file_path = item.get('file_path')
-                if file_path:
-                    for root in config.loras_roots:
-                        root = root.replace(os.sep, '/')
-                        if file_path.startswith(root):
-                            relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
-                            # Get trigger words from civitai metadata
-                            civitai = item.get('civitai', {})
-                            trigger_words = civitai.get('trainedWords', []) if civitai else []
-                            return relative_path, trigger_words
-        return lora_name, []  # Fallback if not found
-
-    def extract_lora_name(self, lora_path):
-        """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-        # Get the basename without extension
-        basename = os.path.basename(lora_path)
-        return os.path.splitext(basename)[0]
-    
-    def _get_loras_list(self, kwargs):
-        """Helper to extract loras list from either old or new kwargs format"""
-        if 'loras' not in kwargs:
-            return []
-            
-        loras_data = kwargs['loras']
-        # Handle new format: {'loras': {'__value__': [...]}}
-        if isinstance(loras_data, dict) and '__value__' in loras_data:
-            return loras_data['__value__']
-        # Handle old format: {'loras': [...]}
-        elif isinstance(loras_data, list):
-            return loras_data
-        # Unexpected format
-        else:
-            logger.warning(f"Unexpected loras format: {type(loras_data)}")
-            return []
     
     def load_loras(self, model, text, **kwargs):
         """Loads multiple LoRAs based on the kwargs input and lora_stack."""
@@ -89,14 +47,14 @@ class LoraManagerLoader:
                 model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
                 
                 # Extract lora name for trigger words lookup
-                lora_name = self.extract_lora_name(lora_path)
-                _, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = asyncio.run(get_lora_info(lora_name))
                 
                 all_trigger_words.extend(trigger_words)
                 loaded_loras.append(f"{lora_name}: {model_strength}")
         
         # Then process loras from kwargs with support for both old and new formats
-        loras_list = self._get_loras_list(kwargs)
+        loras_list = get_loras_list(kwargs)
         for lora in loras_list:
             if not lora.get('active', False):
                 continue
@@ -105,7 +63,7 @@ class LoraManagerLoader:
             strength = float(lora['strength'])
             
             # Get lora path and trigger words
-            lora_path, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+            lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
             
             # Apply the LoRA using the resolved path
             model, clip = LoraLoader().load_lora(model, clip, lora_path, strength, strength)

py/nodes/lora_stacker.py

@@ -3,7 +3,7 @@ from ..services.lora_scanner import LoraScanner
 from ..config import config
 import asyncio
 import os
-from .utils import FlexibleOptionalInputType, any_type
+from .utils import FlexibleOptionalInputType, any_type, get_lora_info, extract_lora_name, get_loras_list
 import logging
 
 logger = logging.getLogger(__name__)
@@ -29,48 +29,6 @@ class LoraStacker:
     RETURN_TYPES = ("LORA_STACK", IO.STRING, IO.STRING)
     RETURN_NAMES = ("LORA_STACK", "trigger_words", "active_loras")
     FUNCTION = "stack_loras"
-
-    async def get_lora_info(self, lora_name):
-        """Get the lora path and trigger words from cache"""
-        scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
-        
-        for item in cache.raw_data:
-            if item.get('file_name') == lora_name:
-                file_path = item.get('file_path')
-                if file_path:
-                    for root in config.loras_roots:
-                        root = root.replace(os.sep, '/')
-                        if file_path.startswith(root):
-                            relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
-                            # Get trigger words from civitai metadata
-                            civitai = item.get('civitai', {})
-                            trigger_words = civitai.get('trainedWords', []) if civitai else []
-                            return relative_path, trigger_words
-        return lora_name, []  # Fallback if not found
-
-    def extract_lora_name(self, lora_path):
-        """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-        # Get the basename without extension
-        basename = os.path.basename(lora_path)
-        return os.path.splitext(basename)[0]
-    
-    def _get_loras_list(self, kwargs):
-        """Helper to extract loras list from either old or new kwargs format"""
-        if 'loras' not in kwargs:
-            return []
-            
-        loras_data = kwargs['loras']
-        # Handle new format: {'loras': {'__value__': [...]}}
-        if isinstance(loras_data, dict) and '__value__' in loras_data:
-            return loras_data['__value__']
-        # Handle old format: {'loras': [...]}
-        elif isinstance(loras_data, list):
-            return loras_data
-        # Unexpected format
-        else:
-            logger.warning(f"Unexpected loras format: {type(loras_data)}")
-            return []
     
     def stack_loras(self, text, **kwargs):
         """Stacks multiple LoRAs based on the kwargs input without loading them."""
@@ -84,12 +42,12 @@ class LoraStacker:
             stack.extend(lora_stack)
             # Get trigger words from existing stack entries
             for lora_path, _, _ in lora_stack:
-                lora_name = self.extract_lora_name(lora_path)
-                _, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = asyncio.run(get_lora_info(lora_name))
                 all_trigger_words.extend(trigger_words)
         
         # Process loras from kwargs with support for both old and new formats
-        loras_list = self._get_loras_list(kwargs)
+        loras_list = get_loras_list(kwargs)
         for lora in loras_list:
             if not lora.get('active', False):
                 continue
@@ -99,7 +57,7 @@ class LoraStacker:
             clip_strength = model_strength  # Using same strength for both as in the original loader
             
             # Get lora path and trigger words
-            lora_path, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+            lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
             
             # Add to stack without loading
             # replace '/' with os.sep to avoid different OS path format

py/nodes/save_image.py

@@ -5,6 +5,7 @@ import re
 import numpy as np
 import folder_paths # type: ignore
 from ..services.lora_scanner import LoraScanner
+from ..services.checkpoint_scanner import CheckpointScanner
 from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
 from PIL import Image, PngImagePlugin
@@ -53,18 +54,55 @@ class SaveImage:
     async def get_lora_hash(self, lora_name):
         """Get the lora hash from cache"""
         scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
         
+        # Use the new direct filename lookup method
+        hash_value = scanner.get_hash_by_filename(lora_name)
+        if hash_value:
+            return hash_value
+            
+        # Fallback to old method for compatibility
+        cache = await scanner.get_cached_data()
         for item in cache.raw_data:
             if item.get('file_name') == lora_name:
                 return item.get('sha256')
         return None
 
+    async def get_checkpoint_hash(self, checkpoint_path):
+        """Get the checkpoint hash from cache"""
+        scanner = await CheckpointScanner.get_instance()
+        
+        if not checkpoint_path:
+            return None
+            
+        # Extract basename without extension
+        checkpoint_name = os.path.basename(checkpoint_path)
+        checkpoint_name = os.path.splitext(checkpoint_name)[0]
+        
+        # Try direct filename lookup first
+        hash_value = scanner.get_hash_by_filename(checkpoint_name)
+        if hash_value:
+            return hash_value
+            
+        # Fallback to old method for compatibility
+        cache = await scanner.get_cached_data()
+        normalized_path = checkpoint_path.replace('\\', '/')
+        
+        for item in cache.raw_data:
+            if item.get('file_name') == checkpoint_name and item.get('file_path').endswith(normalized_path):
+                return item.get('sha256')
+                
+        return None
+
     async def format_metadata(self, metadata_dict):
         """Format metadata in the requested format similar to userComment example"""
         if not metadata_dict:
             return ""
         
+        # Helper function to only add parameter if value is not None
+        def add_param_if_not_none(param_list, label, value):
+            if value is not None:
+                param_list.append(f"{label}: {value}")
+        
         # Extract the prompt and negative prompt
         prompt = metadata_dict.get('prompt', '')
         negative_prompt = metadata_dict.get('negative_prompt', '')
@@ -100,7 +138,11 @@ class SaveImage:
         
         # Add standard parameters in the correct order
         if 'steps' in metadata_dict:
-            params.append(f"Steps: {metadata_dict.get('steps')}")
+            add_param_if_not_none(params, "Steps", metadata_dict.get('steps'))
+        
+        # Combine sampler and scheduler information
+        sampler_name = None
+        scheduler_name = None
         
         if 'sampler' in metadata_dict:
             sampler = metadata_dict.get('sampler')
@@ -123,7 +165,6 @@ class SaveImage:
                 'ddim': 'DDIM'
             }
             sampler_name = sampler_mapping.get(sampler, sampler)
-            params.append(f"Sampler: {sampler_name}")
         
         if 'scheduler' in metadata_dict:
             scheduler = metadata_dict.get('scheduler')
@@ -135,38 +176,48 @@ class SaveImage:
                 'sgm_quadratic': 'SGM Quadratic'
             }
             scheduler_name = scheduler_mapping.get(scheduler, scheduler)
-            params.append(f"Schedule type: {scheduler_name}")
         
-        # CFG scale (cfg_scale in metadata_dict)
-        if 'cfg_scale' in metadata_dict:
-            params.append(f"CFG scale: {metadata_dict.get('cfg_scale')}")
+        # Add combined sampler and scheduler information
+        if sampler_name:
+            if scheduler_name:
+                params.append(f"Sampler: {sampler_name} {scheduler_name}")
+            else:
+                params.append(f"Sampler: {sampler_name}")
+        
+        # CFG scale (Use guidance if available, otherwise fall back to cfg_scale or cfg)
+        if 'guidance' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('guidance'))
+        elif 'cfg_scale' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg_scale'))
         elif 'cfg' in metadata_dict:
-            params.append(f"CFG scale: {metadata_dict.get('cfg')}")
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg'))
         
         # Seed
         if 'seed' in metadata_dict:
-            params.append(f"Seed: {metadata_dict.get('seed')}")
+            add_param_if_not_none(params, "Seed", metadata_dict.get('seed'))
         
         # Size
         if 'size' in metadata_dict:
-            params.append(f"Size: {metadata_dict.get('size')}")
+            add_param_if_not_none(params, "Size", metadata_dict.get('size'))
         
         # Model info
         if 'checkpoint' in metadata_dict:
             # Ensure checkpoint is a string before processing
             checkpoint = metadata_dict.get('checkpoint')
             if checkpoint is not None:
-                # Handle both string and other types safely
-                if isinstance(checkpoint, str):
-                    # Extract basename without path
-                    checkpoint = os.path.basename(checkpoint)
-                    # Remove extension if present
-                    checkpoint = os.path.splitext(checkpoint)[0]
-                else:
-                    # Convert non-string to string
-                    checkpoint = str(checkpoint)
+                # Get model hash
+                model_hash = await self.get_checkpoint_hash(checkpoint)
                 
-                params.append(f"Model: {checkpoint}")
+                # Extract basename without path
+                checkpoint_name = os.path.basename(checkpoint)
+                # Remove extension if present
+                checkpoint_name = os.path.splitext(checkpoint_name)[0]
+                
+                # Add model hash if available
+                if model_hash:
+                    params.append(f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}")
+                else:
+                    params.append(f"Model: {checkpoint_name}")
         
         # Add LoRA hashes if available
         if lora_hashes:
@@ -284,7 +335,7 @@ class SaveImage:
             if add_counter_to_filename:
                 # Use counter + i to ensure unique filenames for all images in batch
                 current_counter = counter + i
-                base_filename += f"_{current_counter:05}"
+                base_filename += f"_{current_counter:05}_"
                 
             # Set file extension and prepare saving parameters
             if file_format == "png":

py/nodes/trigger_word_toggle.py

@@ -47,10 +47,10 @@ class TriggerWordToggle:
         trigger_words = trigger_words_data if isinstance(trigger_words_data, str) else ""
         
         # Send trigger words to frontend
-        PromptServer.instance.send_sync("trigger_word_update", {
-            "id": id,
-            "message": trigger_words
-        })
+        # PromptServer.instance.send_sync("trigger_word_update", {
+        #     "id": id,
+        #     "message": trigger_words
+        # })
         
         filtered_triggers = trigger_words
         

py/nodes/utils.py

@@ -30,4 +30,55 @@ class FlexibleOptionalInputType(dict):
     return True
 
 
-any_type = AnyType("*")
+any_type = AnyType("*")
+
+# Common methods extracted from lora_loader.py and lora_stacker.py
+import os
+import logging
+import asyncio
+from ..services.lora_scanner import LoraScanner
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+async def get_lora_info(lora_name):
+    """Get the lora path and trigger words from cache"""
+    scanner = await LoraScanner.get_instance()
+    cache = await scanner.get_cached_data()
+    
+    for item in cache.raw_data:
+        if item.get('file_name') == lora_name:
+            file_path = item.get('file_path')
+            if file_path:
+                for root in config.loras_roots:
+                    root = root.replace(os.sep, '/')
+                    if file_path.startswith(root):
+                        relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
+                        # Get trigger words from civitai metadata
+                        civitai = item.get('civitai', {})
+                        trigger_words = civitai.get('trainedWords', []) if civitai else []
+                        return relative_path, trigger_words
+    return lora_name, []  # Fallback if not found
+
+def extract_lora_name(lora_path):
+    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
+    # Get the basename without extension
+    basename = os.path.basename(lora_path)
+    return os.path.splitext(basename)[0]
+
+def get_loras_list(kwargs):
+    """Helper to extract loras list from either old or new kwargs format"""
+    if 'loras' not in kwargs:
+        return []
+        
+    loras_data = kwargs['loras']
+    # Handle new format: {'loras': {'__value__': [...]}}
+    if isinstance(loras_data, dict) and '__value__' in loras_data:
+        return loras_data['__value__']
+    # Handle old format: {'loras': [...]}
+    elif isinstance(loras_data, list):
+        return loras_data
+    # Unexpected format
+    else:
+        logger.warning(f"Unexpected loras format: {type(loras_data)}")
+        return []

py/routes/api_routes.py

@@ -3,8 +3,10 @@ import json
 import logging
 from aiohttp import web
 from typing import Dict
+from server import PromptServer # type: ignore
 
 from ..utils.routes_common import ModelRouteUtils
+from ..nodes.utils import get_lora_info
 
 from ..config import config
 from ..services.websocket_manager import ws_manager
@@ -64,6 +66,9 @@ class ApiRoutes:
         app.router.add_get('/api/lora-civitai-url', routes.get_lora_civitai_url)  # Add new route for Civitai URL
         app.router.add_post('/api/rename_lora', routes.rename_lora)  # Add new route for renaming LoRA files
         app.router.add_get('/api/loras/scan', routes.scan_loras)  # Add new route for scanning LoRA files
+        
+        # Add the new trigger words route
+        app.router.add_post('/loramanager/get_trigger_words', routes.get_trigger_words)
 
         # Add update check routes
         UpdateRoutes.setup_routes(app)
@@ -120,6 +125,7 @@ class ApiRoutes:
             # Get filter parameters
             base_models = request.query.get('base_models', None)
             tags = request.query.get('tags', None)
+            favorites_only = request.query.get('favorites_only', 'false').lower() == 'true'  # New parameter
             
             # New parameters for recipe filtering
             lora_hash = request.query.get('lora_hash', None)
@@ -150,7 +156,8 @@ class ApiRoutes:
                 base_models=filters.get('base_model', None),
                 tags=filters.get('tags', None),
                 search_options=search_options,
-                hash_filters=hash_filters
+                hash_filters=hash_filters,
+                favorites_only=favorites_only  # Pass favorites_only parameter
             )
 
             # Get all available folders from cache
@@ -190,6 +197,7 @@ class ApiRoutes:
             "from_civitai": lora.get("from_civitai", True),
             "usage_tips": lora.get("usage_tips", ""),
             "notes": lora.get("notes", ""),
+            "favorite": lora.get("favorite", False),  # Include favorite status in response
             "civitai": ModelRouteUtils.filter_civitai_data(lora.get("civitai", {}))
         }
 
@@ -1021,4 +1029,35 @@ class ApiRoutes:
             return web.json_response({
                 'success': False,
                 'error': str(e)
+            }, status=500)
+
+    async def get_trigger_words(self, request: web.Request) -> web.Response:
+        """Get trigger words for specified LoRA models"""
+        try:
+            json_data = await request.json()
+            lora_names = json_data.get("lora_names", [])
+            node_ids = json_data.get("node_ids", [])
+            
+            all_trigger_words = []
+            for lora_name in lora_names:
+                _, trigger_words = await get_lora_info(lora_name)
+                all_trigger_words.extend(trigger_words)
+            
+            # Format the trigger words
+            trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+            
+            # Send update to all connected trigger word toggle nodes
+            for node_id in node_ids:
+                PromptServer.instance.send_sync("trigger_word_update", {
+                    "id": node_id,
+                    "message": trigger_words_text
+                })
+            
+            return web.json_response({"success": True})
+
+        except Exception as e:
+            logger.error(f"Error getting trigger words: {e}")
+            return web.json_response({
+                "success": False,
+                "error": str(e)
             }, status=500)

py/routes/checkpoints_routes.py

@@ -69,6 +69,7 @@ class CheckpointsRoutes:
             fuzzy_search = request.query.get('fuzzy_search', 'false').lower() == 'true'
             base_models = request.query.getall('base_model', [])
             tags = request.query.getall('tag', [])
+            favorites_only = request.query.get('favorites_only', 'false').lower() == 'true'  # Add favorites_only parameter
             
             # Process search options
             search_options = {
@@ -101,7 +102,8 @@ class CheckpointsRoutes:
                 base_models=base_models,
                 tags=tags,
                 search_options=search_options,
-                hash_filters=hash_filters
+                hash_filters=hash_filters,
+                favorites_only=favorites_only  # Pass favorites_only parameter
             )
             
             # Format response items
@@ -123,7 +125,8 @@ class CheckpointsRoutes:
     async def get_paginated_data(self, page, page_size, sort_by='name', 
                                folder=None, search=None, fuzzy_search=False,
                                base_models=None, tags=None,
-                               search_options=None, hash_filters=None):
+                               search_options=None, hash_filters=None,
+                               favorites_only=False):  # Add favorites_only parameter with default False
         """Get paginated and filtered checkpoint data"""
         cache = await self.scanner.get_cached_data()
 
@@ -181,6 +184,13 @@ class CheckpointsRoutes:
                 if not cp.get('preview_nsfw_level') or cp.get('preview_nsfw_level') < NSFW_LEVELS['R']
             ]
         
+        # Apply favorites filtering if enabled
+        if favorites_only:
+            filtered_data = [
+                cp for cp in filtered_data
+                if cp.get('favorite', False) is True
+            ]
+        
         # Apply folder filtering
         if folder is not None:
             if search_options.get('recursive', False):
@@ -276,6 +286,7 @@ class CheckpointsRoutes:
             "from_civitai": checkpoint.get("from_civitai", True),
             "notes": checkpoint.get("notes", ""),
             "model_type": checkpoint.get("model_type", "checkpoint"),
+            "favorite": checkpoint.get("favorite", False),
             "civitai": ModelRouteUtils.filter_civitai_data(checkpoint.get("civitai", {}))
         }
     

py/routes/recipe_routes.py

@@ -10,16 +10,25 @@ from typing import Dict
 import tempfile
 import json
 import asyncio
+import sys
 from ..utils.exif_utils import ExifUtils
 from ..utils.recipe_parsers import RecipeParserFactory
 from ..utils.constants import CARD_PREVIEW_WIDTH
 
 from ..config import config
-from ..metadata_collector import get_metadata  # Add MetadataCollector import
-from ..metadata_collector.metadata_processor import MetadataProcessor  # Add MetadataProcessor import
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
 from ..utils.utils import download_civitai_image
 from ..services.service_registry import ServiceRegistry  # Add ServiceRegistry import
-from ..metadata_collector.metadata_registry import MetadataRegistry
+
+# Only import MetadataRegistry in non-standalone mode
+if not standalone_mode:
+    # Import metadata_collector functions and classes conditionally
+    from ..metadata_collector import get_metadata  # Add MetadataCollector import
+    from ..metadata_collector.metadata_processor import MetadataProcessor  # Add MetadataProcessor import
+    from ..metadata_collector.metadata_registry import MetadataRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -74,6 +83,9 @@ class RecipeRoutes:
         
         # Add route to get recipes for a specific Lora
         app.router.add_get('/api/recipes/for-lora', routes.get_recipes_for_lora)
+        
+        # Add new endpoint for scanning and rebuilding the recipe cache
+        app.router.add_get('/api/recipes/scan', routes.scan_recipes)
     
     async def _init_cache(self, app):
         """Initialize cache on startup"""
@@ -801,8 +813,11 @@ class RecipeRoutes:
                 return web.json_response({"error": "No generation metadata found"}, status=400)
             
             # Get the most recent image from metadata registry instead of temp directory
-            metadata_registry = MetadataRegistry()
-            latest_image = metadata_registry.get_first_decoded_image()
+            if not standalone_mode:
+                metadata_registry = MetadataRegistry()
+                latest_image = metadata_registry.get_first_decoded_image()
+            else:
+                latest_image = None
             
             if not latest_image:
                 return web.json_response({"error": "No recent images found to use for recipe. Try generating an image first."}, status=400)
@@ -1255,3 +1270,24 @@ class RecipeRoutes:
         except Exception as e:
             logger.error(f"Error getting recipes for Lora: {str(e)}")
             return web.json_response({'success': False, 'error': str(e)}, status=500)
+
+    async def scan_recipes(self, request: web.Request) -> web.Response:
+        """API endpoint for scanning and rebuilding the recipe cache"""
+        try:
+            # Ensure services are initialized
+            await self.init_services()
+            
+            # Force refresh the recipe cache
+            logger.info("Manually triggering recipe cache rebuild")
+            await self.recipe_scanner.get_cached_data(force_refresh=True)
+            
+            return web.json_response({
+                'success': True,
+                'message': 'Recipe cache refreshed successfully'
+            })
+        except Exception as e:
+            logger.error(f"Error refreshing recipe cache: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/routes/usage_stats_routes.py

@@ -0,0 +1,69 @@
+import logging
+from aiohttp import web
+from ..utils.usage_stats import UsageStats
+
+logger = logging.getLogger(__name__)
+
+class UsageStatsRoutes:
+    """Routes for handling usage statistics updates"""
+    
+    @staticmethod
+    def setup_routes(app):
+        """Register usage stats routes"""
+        app.router.add_post('/loras/api/update-usage-stats', UsageStatsRoutes.update_usage_stats)
+        app.router.add_get('/loras/api/get-usage-stats', UsageStatsRoutes.get_usage_stats)
+    
+    @staticmethod
+    async def update_usage_stats(request):
+        """
+        Update usage statistics based on a prompt_id
+        
+        Expects a JSON body with:
+        {
+            "prompt_id": "string"
+        }
+        """
+        try:
+            # Parse the request body
+            data = await request.json()
+            prompt_id = data.get('prompt_id')
+            
+            if not prompt_id:
+                return web.json_response({
+                    'success': False,
+                    'error': 'Missing prompt_id'
+                }, status=400)
+            
+            # Call the UsageStats to process this prompt_id synchronously
+            usage_stats = UsageStats()
+            await usage_stats.process_execution(prompt_id)
+            
+            return web.json_response({
+                'success': True
+            })
+            
+        except Exception as e:
+            logger.error(f"Failed to update usage stats: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+    
+    @staticmethod
+    async def get_usage_stats(request):
+        """Get current usage statistics"""
+        try:
+            usage_stats = UsageStats()
+            stats = await usage_stats.get_stats()
+            
+            return web.json_response({
+                'success': True,
+                'data': stats
+            })
+            
+        except Exception as e:
+            logger.error(f"Failed to get usage stats: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/server_routes.py

@@ -0,0 +1,26 @@
+from aiohttp import web
+from server import PromptServer
+from .nodes.utils import get_lora_info
+
+@PromptServer.instance.routes.post("/loramanager/get_trigger_words")
+async def get_trigger_words(request):
+    json_data = await request.json()
+    lora_names = json_data.get("lora_names", [])
+    node_ids = json_data.get("node_ids", [])
+    
+    all_trigger_words = []
+    for lora_name in lora_names:
+        _, trigger_words = await get_lora_info(lora_name)
+        all_trigger_words.extend(trigger_words)
+    
+    # Format the trigger words
+    trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+    
+    # Send update to all connected trigger word toggle nodes
+    for node_id in node_ids:
+        PromptServer.instance.send_sync("trigger_word_update", {
+            "id": node_id,
+            "message": trigger_words_text
+        })
+    
+    return web.json_response({"success": True})

py/services/civitai_client.py

@@ -34,6 +34,7 @@ class CivitaiClient:
             'User-Agent': 'ComfyUI-LoRA-Manager/1.0'
         }
         self._session = None
+        self._session_created_at = None
         # Set default buffer size to 1MB for higher throughput
         self.chunk_size = 1024 * 1024
     
@@ -44,8 +45,8 @@ class CivitaiClient:
             # Optimize TCP connection parameters
             connector = aiohttp.TCPConnector(
                 ssl=True,
-                limit=10,  # Increase parallel connections
-                ttl_dns_cache=300,  # DNS cache time
+                limit=3,  # Further reduced from 5 to 3
+                ttl_dns_cache=0,  # Disabled DNS caching completely
                 force_close=False,  # Keep connections for reuse
                 enable_cleanup_closed=True
             )
@@ -57,7 +58,18 @@ class CivitaiClient:
                 trust_env=trust_env,
                 timeout=timeout
             )
+            self._session_created_at = datetime.now()
         return self._session
+    
+    async def _ensure_fresh_session(self):
+        """Refresh session if it's been open too long"""
+        if self._session is not None:
+            if not hasattr(self, '_session_created_at') or \
+               (datetime.now() - self._session_created_at).total_seconds() > 300:  # 5 minutes
+                await self.close()
+                self._session = None
+        
+        return await self.session
 
     def _parse_content_disposition(self, header: str) -> str:
         """Parse filename from content-disposition header"""
@@ -103,13 +115,15 @@ class CivitaiClient:
         Returns:
             Tuple[bool, str]: (success, save_path or error message)
         """
-        session = await self.session
+        logger.debug(f"Resolving DNS for: {url}")
+        session = await self._ensure_fresh_session()
         try:
             headers = self._get_request_headers()
             
             # Add Range header to allow resumable downloads
             headers['Accept-Encoding'] = 'identity'  # Disable compression for better chunked downloads
             
+            logger.debug(f"Starting download from: {url}")
             async with session.get(url, headers=headers, allow_redirects=True) as response:
                 if response.status != 200:
                     # Handle 401 unauthorized responses
@@ -124,6 +138,7 @@ class CivitaiClient:
                         return False, "Access forbidden: You don't have permission to download this file."
                     
                     # Generic error response for other status codes
+                    logger.error(f"Download failed for {url} with status {response.status}")
                     return False, f"Download failed with status {response.status}"
 
                 # Get filename from content-disposition header
@@ -170,7 +185,7 @@ class CivitaiClient:
 
     async def get_model_by_hash(self, model_hash: str) -> Optional[Dict]:
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             async with session.get(f"{self.base_url}/model-versions/by-hash/{model_hash}") as response:
                 if response.status == 200:
                     return await response.json()
@@ -181,7 +196,7 @@ class CivitaiClient:
 
     async def download_preview_image(self, image_url: str, save_path: str):
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             async with session.get(image_url) as response:
                 if response.status == 200:
                     content = await response.read()
@@ -196,7 +211,7 @@ class CivitaiClient:
     async def get_model_versions(self, model_id: str) -> List[Dict]:
         """Get all versions of a model with local availability info"""
         try:
-            session = await self.session  # 等待获取 session
+            session = await self._ensure_fresh_session()  # Use fresh session
             async with session.get(f"{self.base_url}/models/{model_id}") as response:
                 if response.status != 200:
                     return None
@@ -222,12 +237,14 @@ class CivitaiClient:
                 - An error message if there was an error, or None on success
         """
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             url = f"{self.base_url}/model-versions/{version_id}"
             headers = self._get_request_headers()
             
+            logger.debug(f"Resolving DNS for model version info: {url}")
             async with session.get(url, headers=headers) as response:
                 if response.status == 200:
+                    logger.debug(f"Successfully fetched model version info for: {version_id}")
                     return await response.json(), None
                 
                 # Handle specific error cases
@@ -242,6 +259,7 @@ class CivitaiClient:
                         return None, "Model not found (status 404)"
                 
                 # Other error cases
+                logger.error(f"Failed to fetch model info for {version_id} (status {response.status})")
                 return None, f"Failed to fetch model info (status {response.status})"
         except Exception as e:
             error_msg = f"Error fetching model version info: {e}"
@@ -260,7 +278,7 @@ class CivitaiClient:
                 - The HTTP status code from the request
         """
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             headers = self._get_request_headers()
             url = f"{self.base_url}/models/{model_id}"
             
@@ -304,10 +322,11 @@ class CivitaiClient:
     async def _get_hash_from_civitai(self, model_version_id: str) -> Optional[str]:
         """Get hash from Civitai API"""
         try:
-            if not self._session:
+            session = await self._ensure_fresh_session()
+            if not session:
                 return None
             
-            version_info = await self._session.get(f"{self.base_url}/model-versions/{model_version_id}")
+            version_info = await session.get(f"{self.base_url}/model-versions/{model_version_id}")
             
             if not version_info or not version_info.json().get('files'):
                 return None

py/services/download_manager.py

@@ -88,16 +88,16 @@ class DownloadManager:
             version_info = None
             error_msg = None
             
-            if download_url:
-                # Extract version ID from download URL
-                version_id = download_url.split('/')[-1]
-                version_info, error_msg = await civitai_client.get_model_version_info(version_id)
+            if model_hash:
+                # Get model by hash
+                version_info = await civitai_client.get_model_by_hash(model_hash)
             elif model_version_id:
                 # Use model version ID directly
                 version_info, error_msg = await civitai_client.get_model_version_info(model_version_id)
-            elif model_hash:
-                # Get model by hash
-                version_info = await civitai_client.get_model_by_hash(model_hash)
+            elif download_url:
+                # Extract version ID from download URL
+                version_id = download_url.split('/')[-1]
+                version_info, error_msg = await civitai_client.get_model_version_info(version_id)
 
             
             if not version_info:

py/services/lora_scanner.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Optional, Set
 from ..utils.models import LoraMetadata
 from ..config import config
 from .model_scanner import ModelScanner
-from .lora_hash_index import LoraHashIndex
+from .model_hash_index import ModelHashIndex  # Changed from LoraHashIndex to ModelHashIndex
 from .settings_manager import settings
 from ..utils.constants import NSFW_LEVELS
 from ..utils.utils import fuzzy_match
@@ -35,12 +35,12 @@ class LoraScanner(ModelScanner):
             # Define supported file extensions
             file_extensions = {'.safetensors'}
             
-            # Initialize parent class
+            # Initialize parent class with ModelHashIndex
             super().__init__(
                 model_type="lora",
                 model_class=LoraMetadata, 
                 file_extensions=file_extensions,
-                hash_index=LoraHashIndex()
+                hash_index=ModelHashIndex()  # Changed from LoraHashIndex to ModelHashIndex
             )
             self._initialized = True
     
@@ -122,7 +122,8 @@ class LoraScanner(ModelScanner):
     async def get_paginated_data(self, page: int, page_size: int, sort_by: str = 'name', 
                                folder: str = None, search: str = None, fuzzy_search: bool = False,
                                base_models: list = None, tags: list = None,
-                               search_options: dict = None, hash_filters: dict = None) -> Dict:
+                               search_options: dict = None, hash_filters: dict = None,
+                               favorites_only: bool = False) -> Dict:
         """Get paginated and filtered lora data
         
         Args:
@@ -136,6 +137,7 @@ class LoraScanner(ModelScanner):
             tags: List of tags to filter by
             search_options: Dictionary with search options (filename, modelname, tags, recursive)
             hash_filters: Dictionary with hash filtering options (single_hash or multiple_hashes)
+            favorites_only: Filter for favorite models only
         """
         cache = await self.get_cached_data()
 
@@ -194,6 +196,13 @@ class LoraScanner(ModelScanner):
                 if not lora.get('preview_nsfw_level') or lora.get('preview_nsfw_level') < NSFW_LEVELS['R']
             ]
         
+        # Apply favorites filtering if enabled
+        if favorites_only:
+            filtered_data = [
+                lora for lora in filtered_data
+                if lora.get('favorite', False) is True
+            ]
+        
         # Apply folder filtering
         if folder is not None:
             if search_options.get('recursive', False):

py/services/model_hash_index.py

@@ -1,11 +1,12 @@
 from typing import Dict, Optional, Set
+import os
 
 class ModelHashIndex:
     """Index for looking up models by hash or path"""
     
     def __init__(self):
         self._hash_to_path: Dict[str, str] = {}
-        self._path_to_hash: Dict[str, str] = {}
+        self._filename_to_hash: Dict[str, str] = {}  # Changed from path_to_hash to filename_to_hash
     
     def add_entry(self, sha256: str, file_path: str) -> None:
         """Add or update hash index entry"""
@@ -15,37 +16,47 @@ class ModelHashIndex:
         # Ensure hash is lowercase for consistency
         sha256 = sha256.lower()
         
+        # Extract filename without extension
+        filename = self._get_filename_from_path(file_path)
+        
         # Remove old path mapping if hash exists
         if sha256 in self._hash_to_path:
             old_path = self._hash_to_path[sha256]
-            if old_path in self._path_to_hash:
-                del self._path_to_hash[old_path]
+            old_filename = self._get_filename_from_path(old_path)
+            if old_filename in self._filename_to_hash:
+                del self._filename_to_hash[old_filename]
         
-        # Remove old hash mapping if path exists
-        if file_path in self._path_to_hash:
-            old_hash = self._path_to_hash[file_path]
+        # Remove old hash mapping if filename exists
+        if filename in self._filename_to_hash:
+            old_hash = self._filename_to_hash[filename]
             if old_hash in self._hash_to_path:
                 del self._hash_to_path[old_hash]
         
         # Add new mappings
         self._hash_to_path[sha256] = file_path
-        self._path_to_hash[file_path] = sha256
+        self._filename_to_hash[filename] = sha256
+    
+    def _get_filename_from_path(self, file_path: str) -> str:
+        """Extract filename without extension from path"""
+        return os.path.splitext(os.path.basename(file_path))[0]
     
     def remove_by_path(self, file_path: str) -> None:
         """Remove entry by file path"""
-        if file_path in self._path_to_hash:
-            hash_val = self._path_to_hash[file_path]
+        filename = self._get_filename_from_path(file_path)
+        if filename in self._filename_to_hash:
+            hash_val = self._filename_to_hash[filename]
             if hash_val in self._hash_to_path:
                 del self._hash_to_path[hash_val]
-            del self._path_to_hash[file_path]
+            del self._filename_to_hash[filename]
     
     def remove_by_hash(self, sha256: str) -> None:
         """Remove entry by hash"""
         sha256 = sha256.lower()
         if sha256 in self._hash_to_path:
             path = self._hash_to_path[sha256]
-            if path in self._path_to_hash:
-                del self._path_to_hash[path]
+            filename = self._get_filename_from_path(path)
+            if filename in self._filename_to_hash:
+                del self._filename_to_hash[filename]
             del self._hash_to_path[sha256]
     
     def has_hash(self, sha256: str) -> bool:
@@ -58,20 +69,27 @@ class ModelHashIndex:
     
     def get_hash(self, file_path: str) -> Optional[str]:
         """Get hash for a file path"""
-        return self._path_to_hash.get(file_path)
+        filename = self._get_filename_from_path(file_path)
+        return self._filename_to_hash.get(filename)
+    
+    def get_hash_by_filename(self, filename: str) -> Optional[str]:
+        """Get hash for a filename without extension"""
+        # Strip extension if present to make the function more flexible
+        filename = os.path.splitext(filename)[0]
+        return self._filename_to_hash.get(filename)
     
     def clear(self) -> None:
         """Clear all entries"""
         self._hash_to_path.clear()
-        self._path_to_hash.clear()
+        self._filename_to_hash.clear()
     
     def get_all_hashes(self) -> Set[str]:
         """Get all hashes in the index"""
         return set(self._hash_to_path.keys())
     
-    def get_all_paths(self) -> Set[str]:
-        """Get all file paths in the index"""
-        return set(self._path_to_hash.keys())
+    def get_all_filenames(self) -> Set[str]:
+        """Get all filenames in the index"""
+        return set(self._filename_to_hash.keys())
     
     def __len__(self) -> int:
         """Get number of entries"""

py/services/model_scanner.py

@@ -292,7 +292,7 @@ class ModelScanner:
             )
 
         # If force refresh is requested, initialize the cache directly
-        if force_refresh:
+        if (force_refresh):
             if self._cache is None:
                 # For initial creation, do a full initialization
                 await self._initialize_cache()
@@ -553,9 +553,36 @@ class ModelScanner:
                         logger.debug(f"Created metadata from .civitai.info for {file_path}")
                 except Exception as e:
                     logger.error(f"Error creating metadata from .civitai.info for {file_path}: {e}")
+        else:
+            # Check if metadata exists but civitai field is empty - try to restore from civitai.info
+            if metadata.civitai is None or metadata.civitai == {}:
+                civitai_info_path = f"{os.path.splitext(file_path)[0]}.civitai.info"
+                if os.path.exists(civitai_info_path):
+                    try:
+                        with open(civitai_info_path, 'r', encoding='utf-8') as f:
+                            version_info = json.load(f)
+                        
+                        logger.debug(f"Restoring missing civitai data from .civitai.info for {file_path}")
+                        metadata.civitai = version_info
+                        
+                        # Ensure tags are also updated if they're missing
+                        if (not metadata.tags or len(metadata.tags) == 0) and 'model' in version_info:
+                            if 'tags' in version_info['model']:
+                                metadata.tags = version_info['model']['tags']
+                        
+                        # Also restore description if missing
+                        if (not metadata.modelDescription or metadata.modelDescription == "") and 'model' in version_info:
+                            if 'description' in version_info['model']:
+                                metadata.modelDescription = version_info['model']['description']
+                        
+                        # Save the updated metadata
+                        await save_metadata(file_path, metadata)
+                        logger.debug(f"Updated metadata with civitai info for {file_path}")
+                    except Exception as e:
+                        logger.error(f"Error restoring civitai data from .civitai.info for {file_path}: {e}")
             
-            if metadata is None:
-                metadata = await self._get_file_info(file_path)
+        if metadata is None:
+            metadata = await self._get_file_info(file_path)
         
         model_data = metadata.to_dict()
         
@@ -709,6 +736,12 @@ class ModelScanner:
                 shutil.move(source_metadata, target_metadata)
                 metadata = await self._update_metadata_paths(target_metadata, target_file)
             
+            # Move civitai.info file if exists
+            source_civitai = os.path.join(source_dir, f"{base_name}.civitai.info")
+            if os.path.exists(source_civitai):
+                target_civitai = os.path.join(target_path, f"{base_name}.civitai.info")
+                shutil.move(source_civitai, target_civitai)
+            
             for ext in PREVIEW_EXTENSIONS:
                 source_preview = os.path.join(source_dir, f"{base_name}{ext}")
                 if os.path.exists(source_preview):
@@ -805,6 +838,10 @@ class ModelScanner:
     def get_hash_by_path(self, file_path: str) -> Optional[str]:
         """Get hash for a model by its file path"""
         return self._hash_index.get_hash(file_path)
+        
+    def get_hash_by_filename(self, filename: str) -> Optional[str]:
+        """Get hash for a model by its filename without path"""
+        return self._hash_index.get_hash_by_filename(filename)
 
     # TODO: Adjust this method to use metadata instead of finding the file    
     def get_preview_url_by_hash(self, sha256: str) -> Optional[str]:

py/utils/models.py

@@ -21,6 +21,8 @@ class BaseModelMetadata:
     civitai: Optional[Dict] = None  # Civitai API data if available
     tags: List[str] = None      # Model tags
     modelDescription: str = ""  # Full model description
+    civitai_deleted: bool = False  # Whether deleted from Civitai
+    favorite: bool = False      # Whether the model is a favorite
 
     def __post_init__(self):
         # Initialize empty lists to avoid mutable default parameter issue
@@ -64,6 +66,15 @@ class LoraMetadata(BaseModelMetadata):
         file_name = file_info['name']
         base_model = determine_base_model(version_info.get('baseModel', ''))
         
+        # Extract tags and description if available
+        tags = []
+        description = ""
+        if 'model' in version_info:
+            if 'tags' in version_info['model']:
+                tags = version_info['model']['tags']
+            if 'description' in version_info['model']:
+                description = version_info['model']['description']
+        
         return cls(
             file_name=os.path.splitext(file_name)[0],
             model_name=version_info.get('model').get('name', os.path.splitext(file_name)[0]),
@@ -75,7 +86,9 @@ class LoraMetadata(BaseModelMetadata):
             preview_url=None,  # Will be updated after preview download
             preview_nsfw_level=0, # Will be updated after preview download
             from_civitai=True,
-            civitai=version_info
+            civitai=version_info,
+            tags=tags,
+            modelDescription=description
         )
 
 @dataclass
@@ -90,6 +103,15 @@ class CheckpointMetadata(BaseModelMetadata):
         base_model = determine_base_model(version_info.get('baseModel', ''))
         model_type = version_info.get('type', 'checkpoint')
         
+        # Extract tags and description if available
+        tags = []
+        description = ""
+        if 'model' in version_info:
+            if 'tags' in version_info['model']:
+                tags = version_info['model']['tags']
+            if 'description' in version_info['model']:
+                description = version_info['model']['description']
+        
         return cls(
             file_name=os.path.splitext(file_name)[0],
             model_name=version_info.get('model').get('name', os.path.splitext(file_name)[0]),
@@ -102,6 +124,8 @@ class CheckpointMetadata(BaseModelMetadata):
             preview_nsfw_level=0,
             from_civitai=True,
             civitai=version_info,
-            model_type=model_type
+            model_type=model_type,
+            tags=tags,
+            modelDescription=description
         )
 

py/utils/recipe_parsers.py

@@ -45,14 +45,14 @@ class RecipeMetadataParser(ABC):
         """
         pass
     
-    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info: Dict[str, Any], 
+    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info_tuple: Tuple[Dict[str, Any], Optional[str]], 
                                          recipe_scanner=None, base_model_counts=None, hash_value=None) -> Dict[str, Any]:
         """
         Populate a lora entry with information from Civitai API response
         
         Args:
             lora_entry: The lora entry to populate
-            civitai_info: The response from Civitai API
+            civitai_info_tuple: The response tuple from Civitai API (data, error_msg)
             recipe_scanner: Optional recipe scanner for local file lookup
             base_model_counts: Optional dict to track base model counts
             hash_value: Optional hash value to use if not available in civitai_info
@@ -61,6 +61,9 @@ class RecipeMetadataParser(ABC):
             The populated lora_entry dict
         """
         try:
+            # Unpack the tuple to get the actual data
+            civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
+            
             if civitai_info and civitai_info.get("error") != "Model not found":
                 # Check if this is an early access lora
                 if civitai_info.get('earlyAccessEndsAt'):
@@ -94,8 +97,9 @@ class RecipeMetadataParser(ABC):
                 
                 # Process file information if available
                 if 'files' in civitai_info:
+                    # Find the primary model file (type="Model" and primary=true) in the files list
                     model_file = next((file for file in civitai_info.get('files', []) 
-                                    if file.get('type') == 'Model'), None)
+                                      if file.get('type') == 'Model' and file.get('primary') == True), None)
                     
                     if model_file:
                         # Get size
@@ -241,11 +245,11 @@ class RecipeFormatParser(RecipeMetadataParser):
                         # Try to get additional info from Civitai if we have a model version ID
                         if lora.get('modelVersionId') and civitai_client:
                             try:
-                                civitai_info = await civitai_client.get_model_version_info(lora['modelVersionId'])
+                                civitai_info_tuple = await civitai_client.get_model_version_info(lora['modelVersionId'])
                                 # Populate lora entry with Civitai info
                                 lora_entry = await self.populate_lora_from_civitai(
                                     lora_entry, 
-                                    civitai_info, 
+                                    civitai_info_tuple, 
                                     recipe_scanner,
                                     None,  # No need to track base model counts
                                     lora['hash']
@@ -336,12 +340,13 @@ class StandardMetadataParser(RecipeMetadataParser):
                 # Get additional info from Civitai if client is available
                 if civitai_client:
                     try:
-                        civitai_info = await civitai_client.get_model_version_info(model_version_id)
+                        civitai_info_tuple = await civitai_client.get_model_version_info(model_version_id)
                         # Populate lora entry with Civitai info
                         lora_entry = await self.populate_lora_from_civitai(
                             lora_entry, 
-                            civitai_info, 
-                            recipe_scanner
+                            civitai_info_tuple, 
+                            recipe_scanner,
+                            base_model_counts
                         )
                     except Exception as e:
                         logger.error(f"Error fetching Civitai info for LoRA: {e}")
@@ -398,27 +403,43 @@ class StandardMetadataParser(RecipeMetadataParser):
             
             # Extract Civitai resources
             if 'Civitai resources:' in user_comment:
-                resources_part = user_comment.split('Civitai resources:', 1)[1]
-                if '],' in resources_part:
-                    resources_json = resources_part.split('],', 1)[0] + ']'
-                    try:
-                        resources = json.loads(resources_json)
-                        # Filter loras and checkpoints
-                        for resource in resources:
-                            if resource.get('type') == 'lora':
-                                # 确保 weight 字段被正确保留
-                                lora_entry = resource.copy()
-                                # 如果找不到 weight，默认为 1.0
-                                if 'weight' not in lora_entry:
-                                    lora_entry['weight'] = 1.0
-                                # Ensure modelVersionName is included
-                                if 'modelVersionName' not in lora_entry:
-                                    lora_entry['modelVersionName'] = ''
-                                metadata['loras'].append(lora_entry)
-                            elif resource.get('type') == 'checkpoint':
-                                metadata['checkpoint'] = resource
-                    except json.JSONDecodeError:
-                        pass
+                resources_part = user_comment.split('Civitai resources:', 1)[1].strip()
+                
+                # Look for the opening and closing brackets to extract the JSON array
+                if resources_part.startswith('['):
+                    # Find the position of the closing bracket
+                    bracket_count = 0
+                    end_pos = -1
+                    
+                    for i, char in enumerate(resources_part):
+                        if char == '[':
+                            bracket_count += 1
+                        elif char == ']':
+                            bracket_count -= 1
+                            if bracket_count == 0:
+                                end_pos = i
+                                break
+                    
+                    if end_pos != -1:
+                        resources_json = resources_part[:end_pos+1]
+                        try:
+                            resources = json.loads(resources_json)
+                            # Filter loras and checkpoints
+                            for resource in resources:
+                                if resource.get('type') == 'lora':
+                                    # 确保 weight 字段被正确保留
+                                    lora_entry = resource.copy()
+                                    # 如果找不到 weight，默认为 1.0
+                                    if 'weight' not in lora_entry:
+                                        lora_entry['weight'] = 1.0
+                                    # Ensure modelVersionName is included
+                                    if 'modelVersionName' not in lora_entry:
+                                        lora_entry['modelVersionName'] = ''
+                                    metadata['loras'].append(lora_entry)
+                                elif resource.get('type') == 'checkpoint':
+                                    metadata['checkpoint'] = resource
+                        except json.JSONDecodeError:
+                            pass
             
             return metadata
         except Exception as e:
@@ -621,11 +642,11 @@ class ComfyMetadataParser(RecipeMetadataParser):
                 # Get additional info from Civitai if client is available
                 if civitai_client:
                     try:
-                        civitai_info = await civitai_client.get_model_version_info(model_version_id)
+                        civitai_info_tuple = await civitai_client.get_model_version_info(model_version_id)
                         # Populate lora entry with Civitai info
                         lora_entry = await self.populate_lora_from_civitai(
                             lora_entry, 
-                            civitai_info, 
+                            civitai_info_tuple, 
                             recipe_scanner
                         )
                     except Exception as e:
@@ -660,7 +681,8 @@ class ComfyMetadataParser(RecipeMetadataParser):
                         # Get additional checkpoint info from Civitai
                         if civitai_client:
                             try:
-                                civitai_info = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                civitai_info_tuple = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                civitai_info, _ = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
                                 # Populate checkpoint with Civitai info
                                 checkpoint = await self.populate_checkpoint_from_civitai(checkpoint, civitai_info)
                             except Exception as e:

py/utils/usage_stats.py

@@ -0,0 +1,273 @@
+import os
+import json
+import sys
+import time
+import asyncio
+import logging
+from typing import Dict, Set
+
+from ..config import config
+from ..services.service_registry import ServiceRegistry
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
+if not standalone_mode:
+    from ..metadata_collector.metadata_registry import MetadataRegistry
+    from ..metadata_collector.constants import MODELS, LORAS
+
+logger = logging.getLogger(__name__)
+
+class UsageStats:
+    """Track usage statistics for models and save to JSON"""
+    
+    _instance = None
+    _lock = asyncio.Lock()  # For thread safety
+    
+    # Default stats file name
+    STATS_FILENAME = "lora_manager_stats.json"
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+            
+        # Initialize stats storage
+        self.stats = {
+            "checkpoints": {},  # sha256 -> count
+            "loras": {},        # sha256 -> count
+            "total_executions": 0,
+            "last_save_time": 0
+        }
+        
+        # Queue for prompt_ids to process
+        self.pending_prompt_ids = set()
+        
+        # Load existing stats if available
+        self._stats_file_path = self._get_stats_file_path()
+        self._load_stats()
+        
+        # Save interval in seconds
+        self.save_interval = 90  # 1.5 minutes
+        
+        # Start background task to process queued prompt_ids
+        self._bg_task = asyncio.create_task(self._background_processor())
+        
+        self._initialized = True
+        logger.info("Usage statistics tracker initialized")
+    
+    def _get_stats_file_path(self) -> str:
+        """Get the path to the stats JSON file"""
+        if not config.loras_roots or len(config.loras_roots) == 0:
+            # Fallback to temporary directory if no lora roots
+            return os.path.join(config.temp_directory, self.STATS_FILENAME)
+        
+        # Use the first lora root
+        return os.path.join(config.loras_roots[0], self.STATS_FILENAME)
+    
+    def _load_stats(self):
+        """Load existing statistics from file"""
+        try:
+            if os.path.exists(self._stats_file_path):
+                with open(self._stats_file_path, 'r', encoding='utf-8') as f:
+                    loaded_stats = json.load(f)
+                
+                # Update our stats with loaded data
+                if isinstance(loaded_stats, dict):
+                    # Update individual sections to maintain structure
+                    if "checkpoints" in loaded_stats and isinstance(loaded_stats["checkpoints"], dict):
+                        self.stats["checkpoints"] = loaded_stats["checkpoints"]
+                    
+                    if "loras" in loaded_stats and isinstance(loaded_stats["loras"], dict):
+                        self.stats["loras"] = loaded_stats["loras"]
+                    
+                    if "total_executions" in loaded_stats:
+                        self.stats["total_executions"] = loaded_stats["total_executions"]
+                    
+                logger.info(f"Loaded usage statistics from {self._stats_file_path}")
+        except Exception as e:
+            logger.error(f"Error loading usage statistics: {e}")
+    
+    async def save_stats(self, force=False):
+        """Save statistics to file"""
+        try:
+            # Only save if it's been at least save_interval since last save or force is True
+            current_time = time.time()
+            if not force and (current_time - self.stats.get("last_save_time", 0)) < self.save_interval:
+                return False
+                
+            # Use a lock to prevent concurrent writes
+            async with self._lock:
+                # Update last save time
+                self.stats["last_save_time"] = current_time
+                
+                # Create directory if it doesn't exist
+                os.makedirs(os.path.dirname(self._stats_file_path), exist_ok=True)
+                
+                # Write to a temporary file first, then move it to avoid corruption
+                temp_path = f"{self._stats_file_path}.tmp"
+                with open(temp_path, 'w', encoding='utf-8') as f:
+                    json.dump(self.stats, f, indent=2, ensure_ascii=False)
+                
+                # Replace the old file with the new one
+                os.replace(temp_path, self._stats_file_path)
+                
+                logger.debug(f"Saved usage statistics to {self._stats_file_path}")
+                return True
+        except Exception as e:
+            logger.error(f"Error saving usage statistics: {e}", exc_info=True)
+            return False
+    
+    def register_execution(self, prompt_id):
+        """Register a completed execution by prompt_id for later processing"""
+        if prompt_id:
+            self.pending_prompt_ids.add(prompt_id)
+    
+    async def _background_processor(self):
+        """Background task to process queued prompt_ids"""
+        try:
+            while True:
+                # Wait a short interval before checking for new prompt_ids
+                await asyncio.sleep(5)  # Check every 5 seconds
+                
+                # Process any pending prompt_ids
+                if self.pending_prompt_ids:
+                    async with self._lock:
+                        # Get a copy of the set and clear original
+                        prompt_ids = self.pending_prompt_ids.copy()
+                        self.pending_prompt_ids.clear()
+                    
+                    # Process each prompt_id
+                    registry = MetadataRegistry()
+                    for prompt_id in prompt_ids:
+                        try:
+                            metadata = registry.get_metadata(prompt_id)
+                            await self._process_metadata(metadata)
+                        except Exception as e:
+                            logger.error(f"Error processing prompt_id {prompt_id}: {e}")
+                
+                # Periodically save stats
+                await self.save_stats()
+        except asyncio.CancelledError:
+            # Task was cancelled, clean up
+            await self.save_stats(force=True)
+        except Exception as e:
+            logger.error(f"Error in background processing task: {e}", exc_info=True)
+            # Restart the task after a delay if it fails
+            asyncio.create_task(self._restart_background_task())
+    
+    async def _restart_background_task(self):
+        """Restart the background task after a delay"""
+        await asyncio.sleep(30)  # Wait 30 seconds before restarting
+        self._bg_task = asyncio.create_task(self._background_processor())
+    
+    async def _process_metadata(self, metadata):
+        """Process metadata from an execution"""
+        if not metadata or not isinstance(metadata, dict):
+            return
+            
+        # Increment total executions count
+        self.stats["total_executions"] += 1
+        
+        # Process checkpoints
+        if MODELS in metadata and isinstance(metadata[MODELS], dict):
+            await self._process_checkpoints(metadata[MODELS])
+        
+        # Process loras
+        if LORAS in metadata and isinstance(metadata[LORAS], dict):
+            await self._process_loras(metadata[LORAS])
+    
+    async def _process_checkpoints(self, models_data):
+        """Process checkpoint models from metadata"""
+        try:
+            # Get checkpoint scanner service
+            checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
+            if not checkpoint_scanner:
+                logger.warning("Checkpoint scanner not available for usage tracking")
+                return
+            
+            for node_id, model_info in models_data.items():
+                if not isinstance(model_info, dict):
+                    continue
+                    
+                # Check if this is a checkpoint model
+                model_type = model_info.get("type")
+                if model_type == "checkpoint":
+                    model_name = model_info.get("name")
+                    if not model_name:
+                        continue
+                    
+                    # Clean up filename (remove extension if present)
+                    model_filename = os.path.splitext(os.path.basename(model_name))[0]
+                    
+                    # Get hash for this checkpoint
+                    model_hash = checkpoint_scanner.get_hash_by_filename(model_filename)
+                    if model_hash:
+                        # Update stats for this checkpoint
+                        self.stats["checkpoints"][model_hash] = self.stats["checkpoints"].get(model_hash, 0) + 1
+        except Exception as e:
+            logger.error(f"Error processing checkpoint usage: {e}", exc_info=True)
+    
+    async def _process_loras(self, loras_data):
+        """Process LoRA models from metadata"""
+        try:
+            # Get LoRA scanner service
+            lora_scanner = await ServiceRegistry.get_lora_scanner()
+            if not lora_scanner:
+                logger.warning("LoRA scanner not available for usage tracking")
+                return
+            
+            for node_id, lora_info in loras_data.items():
+                if not isinstance(lora_info, dict):
+                    continue
+                
+                # Get the list of LoRAs from standardized format
+                lora_list = lora_info.get("lora_list", [])
+                for lora in lora_list:
+                    if not isinstance(lora, dict):
+                        continue
+                        
+                    lora_name = lora.get("name")
+                    if not lora_name:
+                        continue
+                    
+                    # Get hash for this LoRA
+                    lora_hash = lora_scanner.get_hash_by_filename(lora_name)
+                    if lora_hash:
+                        # Update stats for this LoRA
+                        self.stats["loras"][lora_hash] = self.stats["loras"].get(lora_hash, 0) + 1
+        except Exception as e:
+            logger.error(f"Error processing LoRA usage: {e}", exc_info=True)
+    
+    async def get_stats(self):
+        """Get current usage statistics"""
+        return self.stats
+    
+    async def get_model_usage_count(self, model_type, sha256):
+        """Get usage count for a specific model by hash"""
+        if model_type == "checkpoint":
+            return self.stats["checkpoints"].get(sha256, 0)
+        elif model_type == "lora":
+            return self.stats["loras"].get(sha256, 0)
+        return 0
+    
+    async def process_execution(self, prompt_id):
+        """Process a prompt execution immediately (synchronous approach)"""
+        if not prompt_id:
+            return
+            
+        try:
+            # Process metadata for this prompt_id
+            registry = MetadataRegistry()
+            metadata = registry.get_metadata(prompt_id)
+            if metadata:
+                await self._process_metadata(metadata)
+                # Save stats if needed
+                await self.save_stats()
+        except Exception as e:
+            logger.error(f"Error processing prompt_id {prompt_id}: {e}", exc_info=True)

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "LoRA Manager for ComfyUI - Access it at http://localhost:8188/loras for managing LoRA models with previews and metadata integration."
-version = "0.8.7"
+version = "0.8.10"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",
@@ -12,7 +12,8 @@ dependencies = [
     "piexif",
     "Pillow",
     "olefile", # for getting rid of warning message
-    "requests"
+    "requests",
+    "toml"
 ]
 
 [project.urls]

requirements.txt

@@ -6,4 +6,7 @@ beautifulsoup4
 piexif
 Pillow
 olefile
-requests
+requests
+toml
+numpy
+torch

settings.json.example

@@ -0,0 +1,14 @@
+{
+  "civitai_api_key": "your_civitai_api_key_here",
+  "show_only_sfw": false,
+  "folder_paths": {
+    "loras": [
+      "C:/path/to/your/loras_folder",
+      "C:/path/to/another/loras_folder"
+    ],
+    "checkpoints": [
+      "C:/path/to/your/checkpoints_folder",
+      "C:/path/to/another/checkpoints_folder"
+    ]
+  }
+}

standalone.py

@@ -0,0 +1,347 @@
+import os
+import sys
+import json
+
+# Create mock folder_paths module BEFORE any other imports
+class MockFolderPaths:
+    @staticmethod
+    def get_folder_paths(folder_name):
+        # Load paths from settings.json
+        settings_path = os.path.join(os.path.dirname(__file__), 'settings.json')
+        try:
+            if os.path.exists(settings_path):
+                with open(settings_path, 'r', encoding='utf-8') as f:
+                    settings = json.load(f)
+                
+                # For diffusion_models, combine unet and diffusers paths
+                if folder_name == "diffusion_models":
+                    paths = []
+                    if 'folder_paths' in settings:
+                        if 'unet' in settings['folder_paths']:
+                            paths.extend(settings['folder_paths']['unet'])
+                        if 'diffusers' in settings['folder_paths']:
+                            paths.extend(settings['folder_paths']['diffusers'])
+                    # Filter out paths that don't exist
+                    valid_paths = [p for p in paths if os.path.exists(p)]
+                    if valid_paths:
+                        return valid_paths
+                    else:
+                        print(f"Warning: No valid paths found for {folder_name}")
+                # For other folder names, return their paths directly
+                elif 'folder_paths' in settings and folder_name in settings['folder_paths']:
+                    paths = settings['folder_paths'][folder_name]
+                    valid_paths = [p for p in paths if os.path.exists(p)]
+                    if valid_paths:
+                        return valid_paths
+                    else:
+                        print(f"Warning: No valid paths found for {folder_name}")
+        except Exception as e:
+            print(f"Error loading folder paths from settings: {e}")
+        
+        # Fallback to empty list if no paths found
+        return []
+    
+    @staticmethod
+    def get_temp_directory():
+        return os.path.join(os.path.dirname(__file__), 'temp')
+    
+    @staticmethod
+    def set_temp_directory(path):
+        os.makedirs(path, exist_ok=True)
+        return path
+
+# Create mock server module with PromptServer
+class MockPromptServer:
+    def __init__(self):
+        self.app = None
+        
+    def send_sync(self, *args, **kwargs):
+        pass
+
+# Create mock metadata_collector module
+class MockMetadataCollector:
+    def init(self):
+        pass
+    
+    def get_metadata(self, prompt_id=None):
+        return {}
+
+# Initialize basic mocks before any imports
+sys.modules['folder_paths'] = MockFolderPaths()
+sys.modules['server'] = type('server', (), {'PromptServer': MockPromptServer()})
+sys.modules['py.metadata_collector'] = MockMetadataCollector()
+
+# Now we can safely import modules that depend on folder_paths and server
+import argparse
+import asyncio
+import logging
+from aiohttp import web
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("lora-manager-standalone")
+
+# Configure aiohttp access logger to be less verbose
+logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+
+# Now we can import the global config from our local modules
+from py.config import config
+
+class StandaloneServer:
+    """Server implementation for standalone mode"""
+    
+    def __init__(self):
+        self.app = web.Application(logger=logger)
+        self.instance = self  # Make it compatible with PromptServer.instance pattern
+        
+        # Ensure the app's access logger is configured to reduce verbosity
+        self.app._subapps = []  # Ensure this exists to avoid AttributeError
+        
+        # Configure access logging for the app
+        self.app.on_startup.append(self._configure_access_logger)
+    
+    async def _configure_access_logger(self, app):
+        """Configure access logger to reduce verbosity"""
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+        
+        # If using aiohttp>=3.8.0, configure access logger through app directly
+        if hasattr(app, 'access_logger'):
+            app.access_logger.setLevel(logging.WARNING)
+    
+    async def setup(self):
+        """Set up the standalone server"""
+        # Create placeholders for compatibility with ComfyUI's implementation
+        self.last_prompt_id = None
+        self.last_node_id = None
+        self.client_id = None
+        
+        # Set up routes
+        self.setup_routes()
+        
+        # Add startup and shutdown handlers
+        self.app.on_startup.append(self.on_startup)
+        self.app.on_shutdown.append(self.on_shutdown)
+    
+    def setup_routes(self):
+        """Set up basic routes"""
+        # Add a simple status endpoint
+        self.app.router.add_get('/', self.handle_status)
+    
+    async def handle_status(self, request):
+        """Handle status request by redirecting to loras page"""
+        # Redirect to loras page instead of showing status
+        raise web.HTTPFound('/loras')
+        
+        # Original JSON response (commented out)
+        # return web.json_response({
+        #     "status": "running",
+        #     "mode": "standalone",
+        #     "loras_roots": config.loras_roots,
+        #     "checkpoints_roots": config.checkpoints_roots
+        # })
+    
+    async def on_startup(self, app):
+        """Startup handler"""
+        logger.info("LoRA Manager standalone server starting...")
+    
+    async def on_shutdown(self, app):
+        """Shutdown handler"""
+        logger.info("LoRA Manager standalone server shutting down...")
+    
+    def send_sync(self, event_type, data, sid=None):
+        """Stub for compatibility with PromptServer"""
+        # In standalone mode, we don't have the same websocket system
+        pass
+    
+    async def start(self, host='127.0.0.1', port=8188):
+        """Start the server"""
+        runner = web.AppRunner(self.app)
+        await runner.setup()
+        site = web.TCPSite(runner, host, port)
+        await site.start()
+
+        # Log the server address with a clickable localhost URL regardless of the actual binding
+        logger.info(f"Server started at http://127.0.0.1:{port}")
+        
+        # Keep the server running
+        while True:
+            await asyncio.sleep(3600)  # Sleep for a long time
+    
+    async def publish_loop(self):
+        """Stub for compatibility with PromptServer"""
+        # This method exists in ComfyUI's server but we don't need it
+        pass
+
+# After all mocks are in place, import LoraManager
+from py.lora_manager import LoraManager
+
+class StandaloneLoraManager(LoraManager):
+    """Extended LoraManager for standalone mode"""
+    
+    @classmethod
+    def add_routes(cls, server_instance):
+        """Initialize and register all routes for standalone mode"""
+        app = server_instance.app
+        
+        # Store app in a global-like location for compatibility
+        sys.modules['server'].PromptServer.instance = server_instance
+
+        # Configure aiohttp access logger to be less verbose
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+        
+        added_targets = set()  # Track already added target paths
+        
+        # Add static routes for each lora root
+        for idx, root in enumerate(config.loras_roots, start=1):
+            if not os.path.exists(root):
+                logger.warning(f"Lora root path does not exist: {root}")
+                continue
+                
+            preview_path = f'/loras_static/root{idx}/preview'
+            
+            # Check if this root is a link path in the mappings
+            real_root = root
+            for target, link in config._path_mappings.items():
+                if os.path.normpath(link) == os.path.normpath(root):
+                    # If so, route should point to the target (real path)
+                    real_root = target
+                    break
+            
+            # Normalize and standardize path display for consistency
+            display_root = real_root.replace('\\', '/')
+            
+            # Add static route for original path - use the normalized path
+            app.router.add_static(preview_path, real_root)
+            logger.info(f"Added static route {preview_path} -> {display_root}")
+            
+            # Record route mapping with normalized path
+            config.add_route_mapping(real_root, preview_path)
+            added_targets.add(os.path.normpath(real_root))
+        
+        # Add static routes for each checkpoint root
+        for idx, root in enumerate(config.checkpoints_roots, start=1):
+            if not os.path.exists(root):
+                logger.warning(f"Checkpoint root path does not exist: {root}")
+                continue
+                
+            preview_path = f'/checkpoints_static/root{idx}/preview'
+            
+            # Check if this root is a link path in the mappings
+            real_root = root
+            for target, link in config._path_mappings.items():
+                if os.path.normpath(link) == os.path.normpath(root):
+                    # If so, route should point to the target (real path)
+                    real_root = target
+                    break
+            
+            # Normalize and standardize path display for consistency
+            display_root = real_root.replace('\\', '/')
+            
+            # Add static route for original path
+            app.router.add_static(preview_path, real_root)
+            logger.info(f"Added static route {preview_path} -> {display_root}")
+            
+            # Record route mapping
+            config.add_route_mapping(real_root, preview_path)
+            added_targets.add(os.path.normpath(real_root))
+        
+        # Add static routes for symlink target paths that aren't already covered
+        link_idx = {
+            'lora': 1,
+            'checkpoint': 1
+        }
+        
+        for target_path, link_path in config._path_mappings.items():
+            norm_target = os.path.normpath(target_path)
+            if norm_target not in added_targets:
+                # Determine if this is a checkpoint or lora link based on path
+                is_checkpoint = any(os.path.normpath(cp_root) in os.path.normpath(link_path) for cp_root in config.checkpoints_roots)
+                is_checkpoint = is_checkpoint or any(os.path.normpath(cp_root) in norm_target for cp_root in config.checkpoints_roots)
+                
+                if is_checkpoint:
+                    route_path = f'/checkpoints_static/link_{link_idx["checkpoint"]}/preview'
+                    link_idx["checkpoint"] += 1
+                else:
+                    route_path = f'/loras_static/link_{link_idx["lora"]}/preview'
+                    link_idx["lora"] += 1
+                
+                # Display path with forward slashes for consistency
+                display_target = target_path.replace('\\', '/')
+                
+                app.router.add_static(route_path, target_path)
+                logger.info(f"Added static route for link target {route_path} -> {display_target}")
+                config.add_route_mapping(target_path, route_path)
+                added_targets.add(norm_target)
+        
+        # Add static route for plugin assets
+        app.router.add_static('/loras_static', config.static_path)
+        
+        # Setup feature routes
+        from py.routes.lora_routes import LoraRoutes
+        from py.routes.api_routes import ApiRoutes
+        from py.routes.recipe_routes import RecipeRoutes
+        from py.routes.checkpoints_routes import CheckpointsRoutes
+        from py.routes.update_routes import UpdateRoutes
+        from py.routes.usage_stats_routes import UsageStatsRoutes
+        
+        lora_routes = LoraRoutes()
+        checkpoints_routes = CheckpointsRoutes()
+        
+        # Initialize routes
+        lora_routes.setup_routes(app)
+        checkpoints_routes.setup_routes(app)
+        ApiRoutes.setup_routes(app)
+        RecipeRoutes.setup_routes(app)
+        UpdateRoutes.setup_routes(app)
+        UsageStatsRoutes.setup_routes(app)
+        
+        # Schedule service initialization
+        app.on_startup.append(lambda app: cls._initialize_services())
+        
+        # Add cleanup
+        app.on_shutdown.append(cls._cleanup)
+        app.on_shutdown.append(ApiRoutes.cleanup)
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="LoRA Manager Standalone Server")
+    parser.add_argument("--host", type=str, default="0.0.0.0", 
+                        help="Host address to bind the server to (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8188,
+                        help="Port to bind the server to (default: 8188, access via http://localhost:8188/loras)")
+    # parser.add_argument("--loras", type=str, nargs="+", 
+    #                     help="Additional paths to LoRA model directories (optional if settings.json has paths)")
+    # parser.add_argument("--checkpoints", type=str, nargs="+",
+    #                     help="Additional paths to checkpoint model directories (optional if settings.json has paths)")
+    parser.add_argument("--log-level", type=str, default="INFO",
+                        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+                        help="Logging level")
+    return parser.parse_args()
+
+async def main():
+    """Main entry point for standalone mode"""
+    args = parse_args()
+    
+    # Set log level
+    logging.getLogger().setLevel(getattr(logging, args.log_level))
+    
+    # Explicitly configure aiohttp access logger regardless of selected log level
+    logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+    
+    # Create the server instance
+    server = StandaloneServer()
+    
+    # Initialize routes via the standalone lora manager
+    StandaloneLoraManager.add_routes(server)
+    
+    # Set up and start the server
+    await server.setup()
+    await server.start(host=args.host, port=args.port)
+
+if __name__ == "__main__":
+    try:
+        # Run the main function
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")

static/css/base.css

@@ -59,6 +59,16 @@ html, body {
     --scrollbar-width: 8px; /* 添加滚动条宽度变量 */
 }
 
+html[data-theme="dark"] {
+    background-color: #1a1a1a !important;
+    color-scheme: dark;
+}
+
+html[data-theme="light"] {
+    background-color: #ffffff !important;
+    color-scheme: light;
+}
+
 [data-theme="dark"] {
     --bg-color: #1a1a1a;
     --text-color: #e0e0e0;

static/css/components/card.css

@@ -192,12 +192,43 @@
     margin-left: var(--space-1);
     cursor: pointer;
     color: white;
-    transition: opacity 0.2s;
-    font-size: 0.9em;
+    transition: opacity 0.2s, transform 0.15s ease;
+    font-size: 1.0em; /* Increased from 0.9em for better visibility */
+    width: 16px; /* Fixed width for consistent spacing */
+    height: 16px; /* Fixed height for larger touch target */
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    padding: 4px; /* Add padding to increase clickable area */
+    box-sizing: content-box; /* Ensure padding adds to dimensions */
+    position: relative; /* For proper positioning */
+    margin: 0; /* Reset margin */
+}
+
+.card-actions i::before {
+    position: absolute; /* Position the icon glyph */
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%); /* Center the icon */
+}
+
+.card-actions {
+    display: flex;
+    gap: var(--space-1); /* Use gap instead of margin for spacing between icons */
+    align-items: center;
 }
 
 .card-actions i:hover {
-    opacity: 0.8;
+    opacity: 0.9;
+    transform: scale(1.1);
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+/* Style for active favorites */
+.favorite-active {
+    color: #ffc107 !important; /* Gold color for favorites */
+    text-shadow: 0 0 5px rgba(255, 193, 7, 0.5);
 }
 
 /* 响应式设计 */

static/css/layout.css

@@ -81,6 +81,22 @@
     opacity: 1;
 }
 
+/* Controls */
+.control-group button.favorite-filter {
+    position: relative;
+    overflow: hidden;
+}
+
+.control-group button.favorite-filter.active {
+    background: var(--lora-accent);
+    color: white;
+}
+
+.control-group button.favorite-filter i {
+    margin-right: 4px;
+    color: #ffc107;
+}
+
 /* Active state for buttons that can be toggled */
 .control-group button.active {
     background: var(--lora-accent);

static/js/api/baseModelApi.js

@@ -45,6 +45,11 @@ export async function loadMoreModels(options = {}) {
             params.append('folder', pageState.activeFolder);
         }
 
+        // Add favorites filter parameter if enabled
+        if (pageState.showFavoritesOnly) {
+            params.append('favorites_only', 'true');
+        }
+
         // Add search parameters if there's a search term
         if (pageState.filters?.search) {
             params.append('search', pageState.filters.search);

static/js/api/checkpointApi.js

@@ -62,8 +62,13 @@ export async function refreshSingleCheckpointMetadata(filePath) {
     return refreshSingleModelMetadata(filePath, 'checkpoint');
 }
 
-// Save checkpoint metadata (similar to the Lora version)
-export async function saveCheckpointMetadata(filePath, data) {
+/**
+ * Save model metadata to the server
+ * @param {string} filePath - Path to the model file
+ * @param {Object} data - Metadata to save
+ * @returns {Promise} - Promise that resolves with the server response
+ */
+export async function saveModelMetadata(filePath, data) {
     const response = await fetch('/api/checkpoints/save-metadata', {
         method: 'POST',
         headers: {
@@ -79,5 +84,5 @@ export async function saveCheckpointMetadata(filePath, data) {
         throw new Error('Failed to save metadata');
     }
     
-    return await response.json();
+    return response.json();
 }

static/js/api/loraApi.js

@@ -9,6 +9,31 @@ import {
     refreshSingleModelMetadata
 } from './baseModelApi.js';
 
+/**
+ * Save model metadata to the server
+ * @param {string} filePath - File path
+ * @param {Object} data - Data to save
+ * @returns {Promise} Promise of the save operation
+ */
+export async function saveModelMetadata(filePath, data) {
+    const response = await fetch('/api/loras/save-metadata', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            file_path: filePath,
+            ...data
+        })
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to save metadata');
+    }
+    
+    return response.json();
+}
+
 export async function loadMoreLoras(resetPage = false, updateFolders = false) {
     return loadMoreModels({
         resetPage,

static/js/components/CheckpointCard.js

@@ -1,8 +1,8 @@
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { showCheckpointModal } from './checkpointModal/index.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
-import { replaceCheckpointPreview as apiReplaceCheckpointPreview } from '../api/checkpointApi.js';
+import { replaceCheckpointPreview as apiReplaceCheckpointPreview, saveModelMetadata } from '../api/checkpointApi.js';
 
 export function createCheckpointCard(checkpoint) {
     const card = document.createElement('div');
@@ -17,6 +17,7 @@ export function createCheckpointCard(checkpoint) {
     card.dataset.from_civitai = checkpoint.from_civitai;
     card.dataset.notes = checkpoint.notes || '';
     card.dataset.base_model = checkpoint.base_model || 'Unknown';
+    card.dataset.favorite = checkpoint.favorite ? 'true' : 'false';
 
     // Store metadata if available
     if (checkpoint.civitai) {
@@ -65,6 +66,9 @@ export function createCheckpointCard(checkpoint) {
     const isVideo = previewUrl.endsWith('.mp4');
     const videoAttrs = autoplayOnHover ? 'controls muted loop' : 'controls autoplay muted loop';
 
+    // Get favorite status from checkpoint data
+    const isFavorite = checkpoint.favorite === true;
+
     card.innerHTML = `
         <div class="card-preview ${shouldBlur ? 'blurred' : ''}">
             ${isVideo ? 
@@ -82,6 +86,9 @@ export function createCheckpointCard(checkpoint) {
                     ${checkpoint.base_model}
                 </span>
                 <div class="card-actions">
+                    <i class="${isFavorite ? 'fas fa-star favorite-active' : 'far fa-star'}" 
+                       title="${isFavorite ? 'Remove from favorites' : 'Add to favorites'}">
+                    </i>
                     <i class="fas fa-globe" 
                        title="${checkpoint.from_civitai ? 'View on Civitai' : 'Not available from Civitai'}"
                        ${!checkpoint.from_civitai ? 'style="opacity: 0.5; cursor: not-allowed"' : ''}>
@@ -198,27 +205,46 @@ export function createCheckpointCard(checkpoint) {
         });
     }
 
+    // Favorite button click event
+    card.querySelector('.fa-star')?.addEventListener('click', async e => {
+        e.stopPropagation();
+        const starIcon = e.currentTarget;
+        const isFavorite = starIcon.classList.contains('fas');
+        const newFavoriteState = !isFavorite;
+        
+        try {
+            // Save the new favorite state to the server
+            await saveModelMetadata(card.dataset.filepath, { 
+                favorite: newFavoriteState 
+            });
+
+            // Update the UI
+            if (newFavoriteState) {
+                starIcon.classList.remove('far');
+                starIcon.classList.add('fas', 'favorite-active');
+                starIcon.title = 'Remove from favorites';
+                card.dataset.favorite = 'true';
+                showToast('Added to favorites', 'success');
+            } else {
+                starIcon.classList.remove('fas', 'favorite-active');
+                starIcon.classList.add('far');
+                starIcon.title = 'Add to favorites';
+                card.dataset.favorite = 'false';
+                showToast('Removed from favorites', 'success');
+            }
+        } catch (error) {
+            console.error('Failed to update favorite status:', error);
+            showToast('Failed to update favorite status', 'error');
+        }
+    });
+
     // Copy button click event
     card.querySelector('.fa-copy')?.addEventListener('click', async e => {
         e.stopPropagation();
         const checkpointName = card.dataset.file_name;
         
         try {
-            // Modern clipboard API
-            if (navigator.clipboard && window.isSecureContext) {
-                await navigator.clipboard.writeText(checkpointName);
-            } else {
-                // Fallback for older browsers
-                const textarea = document.createElement('textarea');
-                textarea.value = checkpointName;
-                textarea.style.position = 'absolute';
-                textarea.style.left = '-99999px';
-                document.body.appendChild(textarea);
-                textarea.select();
-                document.execCommand('copy');
-                document.body.removeChild(textarea);
-            }
-            showToast('Checkpoint name copied', 'success');
+            await copyToClipboard(checkpointName, 'Checkpoint name copied');
         } catch (err) {
             console.error('Copy failed:', err);
             showToast('Copy failed', 'error');

static/js/components/ContextMenu/CheckpointContextMenu.js

@@ -1,5 +1,5 @@
 import { BaseContextMenu } from './BaseContextMenu.js';
-import { refreshSingleCheckpointMetadata, saveCheckpointMetadata } from '../../api/checkpointApi.js';
+import { refreshSingleCheckpointMetadata, saveModelMetadata } from '../../api/checkpointApi.js';
 import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 import { getStorageItem } from '../../utils/storageHelpers.js';
@@ -82,7 +82,7 @@ export class CheckpointContextMenu extends BaseContextMenu {
                 if (!filePath) return;
                 
                 try {
-                    await saveCheckpointMetadata(filePath, { preview_nsfw_level: level });
+                    await saveModelMetadata(filePath, { preview_nsfw_level: level });
                     
                     // Update card data
                     const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);

static/js/components/ContextMenu/LoraContextMenu.js

@@ -1,5 +1,5 @@
 import { BaseContextMenu } from './BaseContextMenu.js';
-import { refreshSingleLoraMetadata } from '../../api/loraApi.js';
+import { refreshSingleLoraMetadata, saveModelMetadata } from '../../api/loraApi.js';
 import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 import { getStorageItem } from '../../utils/storageHelpers.js';
@@ -111,22 +111,7 @@ export class LoraContextMenu extends BaseContextMenu {
     }
 
     async saveModelMetadata(filePath, data) {
-        const response = await fetch('/api/loras/save-metadata', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                file_path: filePath,
-                ...data
-            })
-        });
-    
-        if (!response.ok) {
-            throw new Error('Failed to save metadata');
-        }
-        
-        return await response.json();
+        return saveModelMetadata(filePath, data);
     }
 
     updateCardBlurEffect(card, level) {

static/js/components/LoraCard.js

@@ -1,9 +1,9 @@
-import { showToast, openCivitai } from '../utils/uiHelpers.js';
+import { showToast, openCivitai, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { showLoraModal } from './loraModal/index.js';
 import { bulkManager } from '../managers/BulkManager.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
-import { replacePreview, deleteModel } from '../api/loraApi.js'
+import { replacePreview, deleteModel, saveModelMetadata } from '../api/loraApi.js'
 
 export function createLoraCard(lora) {
     const card = document.createElement('div');
@@ -20,6 +20,7 @@ export function createLoraCard(lora) {
     card.dataset.usage_tips = lora.usage_tips;
     card.dataset.notes = lora.notes;
     card.dataset.meta = JSON.stringify(lora.civitai || {});
+    card.dataset.favorite = lora.favorite ? 'true' : 'false';
     
     // Store tags and model description
     if (lora.tags && Array.isArray(lora.tags)) {
@@ -65,6 +66,9 @@ export function createLoraCard(lora) {
     const isVideo = previewUrl.endsWith('.mp4');
     const videoAttrs = autoplayOnHover ? 'controls muted loop' : 'controls autoplay muted loop';
 
+    // Get favorite status from the lora data
+    const isFavorite = lora.favorite === true;
+
     card.innerHTML = `
         <div class="card-preview ${shouldBlur ? 'blurred' : ''}">
             ${isVideo ? 
@@ -82,6 +86,9 @@ export function createLoraCard(lora) {
                     ${lora.base_model}
                 </span>
                 <div class="card-actions">
+                    <i class="${isFavorite ? 'fas fa-star favorite-active' : 'far fa-star'}" 
+                       title="${isFavorite ? 'Remove from favorites' : 'Add to favorites'}">
+                    </i>
                     <i class="fas fa-globe" 
                        title="${lora.from_civitai ? 'View on Civitai' : 'Not available from Civitai'}"
                        ${!lora.from_civitai ? 'style="opacity: 0.5; cursor: not-allowed"' : ''}>
@@ -135,6 +142,7 @@ export function createLoraCard(lora) {
                 base_model: card.dataset.base_model,
                 usage_tips: card.dataset.usage_tips,
                 notes: card.dataset.notes,
+                favorite: card.dataset.favorite === 'true',
                 // Parse civitai metadata from the card's dataset
                 civitai: (() => {
                     try {
@@ -198,6 +206,39 @@ export function createLoraCard(lora) {
         });
     }
 
+    // Favorite button click event
+    card.querySelector('.fa-star')?.addEventListener('click', async e => {
+        e.stopPropagation();
+        const starIcon = e.currentTarget;
+        const isFavorite = starIcon.classList.contains('fas');
+        const newFavoriteState = !isFavorite;
+        
+        try {
+            // Save the new favorite state to the server
+            await saveModelMetadata(card.dataset.filepath, { 
+                favorite: newFavoriteState 
+            });
+
+            // Update the UI
+            if (newFavoriteState) {
+                starIcon.classList.remove('far');
+                starIcon.classList.add('fas', 'favorite-active');
+                starIcon.title = 'Remove from favorites';
+                card.dataset.favorite = 'true';
+                showToast('Added to favorites', 'success');
+            } else {
+                starIcon.classList.remove('fas', 'favorite-active');
+                starIcon.classList.add('far');
+                starIcon.title = 'Add to favorites';
+                card.dataset.favorite = 'false';
+                showToast('Removed from favorites', 'success');
+            }
+        } catch (error) {
+            console.error('Failed to update favorite status:', error);
+            showToast('Failed to update favorite status', 'error');
+        }
+    });
+
     // Copy button click event
     card.querySelector('.fa-copy')?.addEventListener('click', async e => {
         e.stopPropagation();
@@ -205,26 +246,7 @@ export function createLoraCard(lora) {
         const strength = usageTips.strength || 1;
         const loraSyntax = `<lora:${card.dataset.file_name}:${strength}>`;
         
-        try {
-            // Modern clipboard API
-            if (navigator.clipboard && window.isSecureContext) {
-                await navigator.clipboard.writeText(loraSyntax);
-            } else {
-                // Fallback for older browsers
-                const textarea = document.createElement('textarea');
-                textarea.value = loraSyntax;
-                textarea.style.position = 'absolute';
-                textarea.style.left = '-99999px';
-                document.body.appendChild(textarea);
-                textarea.select();
-                document.execCommand('copy');
-                document.body.removeChild(textarea);
-            }
-            showToast('LoRA syntax copied', 'success');
-        } catch (err) {
-            console.error('Copy failed:', err);
-            showToast('Copy failed', 'error');
-        }
+        await copyToClipboard(loraSyntax, 'LoRA syntax copied');
     });
 
     // Civitai button click event

static/js/components/RecipeCard.js

@@ -1,5 +1,5 @@
 // Recipe Card Component
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { modalManager } from '../managers/ModalManager.js';
 
 class RecipeCard {
@@ -109,14 +109,11 @@ class RecipeCard {
                 .then(response => response.json())
                 .then(data => {
                     if (data.success && data.syntax) {
-                        return navigator.clipboard.writeText(data.syntax);
+                        return copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
                     } else {
                         throw new Error(data.error || 'No syntax returned');
                     }
                 })
-                .then(() => {
-                    showToast('Recipe syntax copied to clipboard', 'success');
-                })
                 .catch(err => {
                     console.error('Failed to copy: ', err);
                     showToast('Failed to copy recipe syntax', 'error');
@@ -279,4 +276,4 @@ class RecipeCard {
     }
 }
 
-export { RecipeCard }; 
+export { RecipeCard };

static/js/components/RecipeModal.js

@@ -1,5 +1,5 @@
 // Recipe Modal Component
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { setSessionItem, removeSessionItem } from '../utils/storageHelpers.js';
 
@@ -747,9 +747,8 @@ class RecipeModal {
             const data = await response.json();
             
             if (data.success && data.syntax) {
-                // Copy to clipboard
-                await navigator.clipboard.writeText(data.syntax);
-                showToast('Recipe syntax copied to clipboard', 'success');
+                // Use the centralized copyToClipboard utility function
+                await copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
             } else {
                 throw new Error(data.error || 'No syntax returned from server');
             }
@@ -761,12 +760,7 @@ class RecipeModal {
     
     // Helper method to copy text to clipboard
     copyToClipboard(text, successMessage) {
-        navigator.clipboard.writeText(text).then(() => {
-            showToast(successMessage, 'success');
-        }).catch(err => {
-            console.error('Failed to copy text: ', err);
-            showToast('Failed to copy text', 'error');
-        });
+        copyToClipboard(text, successMessage);
     }
 
     // Add new method to handle downloading missing LoRAs

static/js/components/checkpointModal/ModelMetadata.js

@@ -5,31 +5,7 @@
 import { showToast } from '../../utils/uiHelpers.js';
 import { BASE_MODELS } from '../../utils/constants.js';
 import { updateCheckpointCard } from '../../utils/cardUpdater.js';
-
-/**
- * Save model metadata to the server
- * @param {string} filePath - Path to the model file
- * @param {Object} data - Metadata to save
- * @returns {Promise} - Promise that resolves with the server response
- */
-export async function saveModelMetadata(filePath, data) {
-    const response = await fetch('/api/checkpoints/save-metadata', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            file_path: filePath,
-            ...data
-        })
-    });
-
-    if (!response.ok) {
-        throw new Error('Failed to save metadata');
-    }
-    
-    return response.json();
-}
+import { saveModelMetadata } from '../../api/checkpointApi.js';
 
 /**
  * Set up model name editing functionality

static/js/components/checkpointModal/ShowcaseView.js

@@ -2,7 +2,7 @@
  * ShowcaseView.js
  * Handles showcase content (images, videos) display for checkpoint modal
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { state } from '../../state/index.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 
@@ -307,8 +307,7 @@ function initMetadataPanelHandlers(container) {
                 if (!promptElement) return;
                 
                 try {
-                    await navigator.clipboard.writeText(promptElement.textContent);
-                    showToast('Prompt copied to clipboard', 'success');
+                    await copyToClipboard(promptElement.textContent, 'Prompt copied to clipboard');
                 } catch (err) {
                     console.error('Copy failed:', err);
                     showToast('Copy failed', 'error');

static/js/components/checkpointModal/index.js

@@ -11,9 +11,9 @@ import { setupTabSwitching, loadModelDescription } from './ModelDescription.js';
 import { 
     setupModelNameEditing, 
     setupBaseModelEditing, 
-    setupFileNameEditing,
-    saveModelMetadata
+    setupFileNameEditing
 } from './ModelMetadata.js';
+import { saveModelMetadata } from '../../api/checkpointApi.js';
 import { renderCompactTags, setupTagTooltip, formatFileSize } from './utils.js';
 import { updateCheckpointCard } from '../../utils/cardUpdater.js';
 

static/js/components/controls/LorasControls.js

@@ -2,7 +2,6 @@
 import { PageControls } from './PageControls.js';
 import { loadMoreLoras, fetchCivitai, resetAndReload, refreshLoras } from '../../api/loraApi.js';
 import { getSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
-import { showToast } from '../../utils/uiHelpers.js';
 
 /**
  * LorasControls class - Extends PageControls for LoRA-specific functionality

static/js/components/controls/PageControls.js

@@ -1,6 +1,6 @@
 // PageControls.js - Manages controls for both LoRAs and Checkpoints pages
 import { state, getCurrentPageState, setCurrentPageType } from '../../state/index.js';
-import { getStorageItem, setStorageItem } from '../../utils/storageHelpers.js';
+import { getStorageItem, setStorageItem, getSessionItem, setSessionItem } from '../../utils/storageHelpers.js';
 import { showToast } from '../../utils/uiHelpers.js';
 
 /**
@@ -26,6 +26,9 @@ export class PageControls {
         // Initialize event listeners
         this.initEventListeners();
         
+        // Initialize favorites filter button state
+        this.initFavoritesFilter();
+        
         console.log(`PageControls initialized for ${pageType} page`);
     }
     
@@ -121,6 +124,12 @@ export class PageControls {
                 bulkButton.addEventListener('click', () => this.toggleBulkMode());
             }
         }
+        
+        // Favorites filter button handler
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        if (favoriteFilterBtn) {
+            favoriteFilterBtn.addEventListener('click', () => this.toggleFavoritesOnly());
+        }
     }
     
     /**
@@ -385,4 +394,50 @@ export class PageControls {
             showToast('Failed to clear custom filter: ' + error.message, 'error');
         }
     }
+    
+    /**
+     * Initialize the favorites filter button state
+     */
+    initFavoritesFilter() {
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        if (favoriteFilterBtn) {
+            // Get current state from session storage with page-specific key
+            const storageKey = `show_favorites_only_${this.pageType}`;
+            const showFavoritesOnly = getSessionItem(storageKey, false);
+            
+            // Update button state
+            if (showFavoritesOnly) {
+                favoriteFilterBtn.classList.add('active');
+            }
+            
+            // Update app state
+            this.pageState.showFavoritesOnly = showFavoritesOnly;
+        }
+    }
+    
+    /**
+     * Toggle favorites-only filter and reload models
+     */
+    async toggleFavoritesOnly() {
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        
+        // Toggle the filter state in storage
+        const storageKey = `show_favorites_only_${this.pageType}`;
+        const currentState = this.pageState.showFavoritesOnly;
+        const newState = !currentState;
+        
+        // Update session storage
+        setSessionItem(storageKey, newState);
+        
+        // Update state
+        this.pageState.showFavoritesOnly = newState;
+        
+        // Update button appearance
+        if (favoriteFilterBtn) {
+            favoriteFilterBtn.classList.toggle('active', newState);
+        }
+        
+        // Reload models with new filter
+        await this.resetAndReload(true);
+    }
 }

static/js/components/loraModal/ModelMetadata.js

@@ -5,31 +5,7 @@
 import { showToast } from '../../utils/uiHelpers.js';
 import { BASE_MODELS } from '../../utils/constants.js';
 import { updateLoraCard } from '../../utils/cardUpdater.js';
-
-/**
- * 保存模型元数据到服务器
- * @param {string} filePath - 文件路径
- * @param {Object} data - 要保存的数据
- * @returns {Promise} 保存操作的Promise
- */
-export async function saveModelMetadata(filePath, data) {
-    const response = await fetch('/api/loras/save-metadata', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            file_path: filePath,
-            ...data
-        })
-    });
-
-    if (!response.ok) {
-        throw new Error('Failed to save metadata');
-    }
-    
-    return response.json();
-}
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 设置模型名称编辑功能

static/js/components/loraModal/PresetTags.js

@@ -2,8 +2,7 @@
  * PresetTags.js
  * 处理LoRA模型预设参数标签相关的功能模块
  */
-import { saveModelMetadata } from './ModelMetadata.js';
-import { showToast } from '../../utils/uiHelpers.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 解析预设参数

static/js/components/loraModal/RecipeTab.js

@@ -1,7 +1,7 @@
 /**
  * RecipeTab - Handles the recipes tab in the Lora Modal
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { setSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
 
 /**
@@ -172,14 +172,11 @@ function copyRecipeSyntax(recipeId) {
         .then(response => response.json())
         .then(data => {
             if (data.success && data.syntax) {
-                return navigator.clipboard.writeText(data.syntax);
+                return copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
             } else {
                 throw new Error(data.error || 'No syntax returned');
             }
         })
-        .then(() => {
-            showToast('Recipe syntax copied to clipboard', 'success');
-        })
         .catch(err => {
             console.error('Failed to copy: ', err);
             showToast('Failed to copy recipe syntax', 'error');

static/js/components/loraModal/ShowcaseView.js

@@ -2,7 +2,7 @@
  * ShowcaseView.js
  * 处理LoRA模型展示内容（图片、视频）的功能模块
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { state } from '../../state/index.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 
@@ -311,8 +311,7 @@ function initMetadataPanelHandlers(container) {
                 if (!promptElement) return;
                 
                 try {
-                    await navigator.clipboard.writeText(promptElement.textContent);
-                    showToast('Prompt copied to clipboard', 'success');
+                    await copyToClipboard(promptElement.textContent, 'Prompt copied to clipboard');
                 } catch (err) {
                     console.error('Copy failed:', err);
                     showToast('Copy failed', 'error');

static/js/components/loraModal/TriggerWords.js

@@ -2,8 +2,8 @@
  * TriggerWords.js
  * 处理LoRA模型触发词相关的功能模块
  */
-import { showToast } from '../../utils/uiHelpers.js';
-import { saveModelMetadata } from './ModelMetadata.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 渲染触发词
@@ -336,23 +336,7 @@ async function saveTriggerWords() {
  */
 window.copyTriggerWord = async function(word) {
     try {
-        // Modern clipboard API - with fallback for non-secure contexts
-        if (navigator.clipboard && window.isSecureContext) {
-            await navigator.clipboard.writeText(word);
-        } else {
-            // Fallback for older browsers or non-secure contexts
-            const textarea = document.createElement('textarea');
-            textarea.value = word;
-            textarea.style.position = 'absolute';
-            textarea.style.left = '-99999px';
-            document.body.appendChild(textarea);
-            textarea.select();
-            const success = document.execCommand('copy');
-            document.body.removeChild(textarea);
-            
-            if (!success) throw new Error('Copy command failed');
-        }
-        showToast('Trigger word copied', 'success');
+        await copyToClipboard(word, 'Trigger word copied');
     } catch (err) {
         console.error('Copy failed:', err);
         showToast('Copy failed', 'error');

static/js/components/loraModal/index.js

@@ -3,8 +3,7 @@
  * 
  * 将原始的LoraModal.js拆分成多个功能模块后的主入口文件
  */
-import { showToast } from '../../utils/uiHelpers.js';
-import { state } from '../../state/index.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { modalManager } from '../../managers/ModalManager.js';
 import { renderShowcaseContent, toggleShowcase, setupShowcaseScroll, scrollToTop } from './ShowcaseView.js';
 import { setupTabSwitching, loadModelDescription } from './ModelDescription.js';
@@ -14,9 +13,9 @@ import { loadRecipesForLora } from './RecipeTab.js'; // Add import for recipe ta
 import { 
     setupModelNameEditing, 
     setupBaseModelEditing, 
-    setupFileNameEditing,
-    saveModelMetadata
+    setupFileNameEditing
 } from './ModelMetadata.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 import { renderCompactTags, setupTagTooltip, formatFileSize } from './utils.js';
 import { updateLoraCard } from '../../utils/cardUpdater.js';
 
@@ -174,8 +173,7 @@ export function showLoraModal(lora) {
 // Copy file name function
 window.copyFileName = async function(fileName) {
     try {
-        await navigator.clipboard.writeText(fileName);
-        showToast('File name copied', 'success');
+        await copyToClipboard(fileName, 'File name copied');
     } catch (err) {
         console.error('Copy failed:', err);
         showToast('Copy failed', 'error');

static/js/managers/BulkManager.js

@@ -1,5 +1,5 @@
 import { state } from '../state/index.js';
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { updateCardsForBulkMode } from '../components/LoraCard.js';
 
 export class BulkManager {
@@ -205,13 +205,7 @@ export class BulkManager {
             return;
         }
         
-        try {
-            await navigator.clipboard.writeText(loraSyntaxes.join(', '));
-            showToast(`Copied ${loraSyntaxes.length} LoRA syntaxes to clipboard`, 'success');
-        } catch (err) {
-            console.error('Copy failed:', err);
-            showToast('Copy failed', 'error');
-        }
+        await copyToClipboard(loraSyntaxes.join(', '), `Copied ${loraSyntaxes.length} LoRA syntaxes to clipboard`);
     }
     
     // Create and show the thumbnail strip of selected LoRAs

static/js/managers/ImportManager.js

@@ -146,6 +146,18 @@ export class ImportManager {
         if (totalSizeDisplay) {
             totalSizeDisplay.textContent = 'Calculating...';
         }
+        
+        // Remove any existing deleted LoRAs warning
+        const deletedLorasWarning = document.getElementById('deletedLorasWarning');
+        if (deletedLorasWarning) {
+            deletedLorasWarning.remove();
+        }
+        
+        // Remove any existing early access warning
+        const earlyAccessWarning = document.getElementById('earlyAccessWarning');
+        if (earlyAccessWarning) {
+            earlyAccessWarning.remove();
+        }
     }
 
     toggleImportMode(mode) {
@@ -532,17 +544,17 @@ export class ImportManager {
         const nextButton = document.querySelector('#detailsStep .primary-btn');
         if (!nextButton) return;
         
+        // Always clean up previous warnings first
+        const existingWarning = document.getElementById('deletedLorasWarning');
+        if (existingWarning) {
+            existingWarning.remove();
+        }
+        
         // Count deleted LoRAs
         const deletedLoras = this.recipeData.loras.filter(lora => lora.isDeleted).length;
         
         // If we have deleted LoRAs, show a warning and update button text
         if (deletedLoras > 0) {
-            // Remove any existing warning
-            const existingWarning = document.getElementById('deletedLorasWarning');
-            if (existingWarning) {
-                existingWarning.remove();
-            }
-            
             // Create a new warning container above the buttons
             const buttonsContainer = document.querySelector('#detailsStep .modal-actions') || nextButton.parentNode;
             const warningContainer = document.createElement('div');

static/js/recipes.js

@@ -268,6 +268,32 @@ class RecipeManager {
         }
     }
     
+    /**
+     * Refreshes the recipe list by first rebuilding the cache and then loading recipes
+     */
+    async refreshRecipes() {
+        try {           
+            // Call the new endpoint to rebuild the recipe cache
+            const response = await fetch('/api/recipes/scan');
+            
+            if (!response.ok) {
+                const data = await response.json();
+                throw new Error(data.error || 'Failed to refresh recipe cache');
+            }
+            
+            // After successful cache rebuild, load the recipes
+            await this.loadRecipes(true);
+            
+            appCore.showToast('Refresh complete', 'success');
+        } catch (error) {
+            console.error('Error refreshing recipes:', error);
+            appCore.showToast(error.message || 'Failed to refresh recipes', 'error');
+            
+            // Still try to load recipes even if scan failed
+            await this.loadRecipes(true);
+        }
+    }
+    
     async _loadSpecificRecipe(recipeId) {
         try {
             // Fetch specific recipe by ID

static/js/state/index.js

@@ -42,6 +42,7 @@ export const state = {
             bulkMode: false,
             selectedLoras: new Set(),
             loraMetadataCache: new Map(),
+            showFavoritesOnly: false,
         },
         
         recipes: {
@@ -61,7 +62,8 @@ export const state = {
                 tags: [],
                 search: ''
             },
-            pageSize: 20
+            pageSize: 20,
+            showFavoritesOnly: false,
         },
         
         checkpoints: {
@@ -80,7 +82,8 @@ export const state = {
             filters: {
                 baseModel: [],
                 tags: []
-            }
+            },
+            showFavoritesOnly: false,
         }
     },
     

static/js/utils/uiHelpers.js

@@ -2,6 +2,40 @@ import { state } from '../state/index.js';
 import { resetAndReload } from '../api/loraApi.js';
 import { getStorageItem, setStorageItem } from './storageHelpers.js';
 
+/**
+ * Utility function to copy text to clipboard with fallback for older browsers
+ * @param {string} text - The text to copy to clipboard
+ * @param {string} successMessage - Optional success message to show in toast
+ * @returns {Promise<boolean>} - Promise that resolves to true if copy was successful
+ */
+export async function copyToClipboard(text, successMessage = 'Copied to clipboard') {
+    try {
+        // Modern clipboard API
+        if (navigator.clipboard && window.isSecureContext) {
+            await navigator.clipboard.writeText(text);
+        } else {
+            // Fallback for older browsers
+            const textarea = document.createElement('textarea');
+            textarea.value = text;
+            textarea.style.position = 'absolute';
+            textarea.style.left = '-99999px';
+            document.body.appendChild(textarea);
+            textarea.select();
+            document.execCommand('copy');
+            document.body.removeChild(textarea);
+        }
+        
+        if (successMessage) {
+            showToast(successMessage, 'success');
+        }
+        return true;
+    } catch (err) {
+        console.error('Copy failed:', err);
+        showToast('Copy failed', 'error');
+        return false;
+    }
+}
+
 export function showToast(message, type = 'info') {
     const toast = document.createElement('div');
     toast.className = `toast toast-${type}`;
@@ -80,13 +114,55 @@ export function restoreFolderFilter() {
 }
 
 export function initTheme() {
-    document.body.dataset.theme = getStorageItem('theme') || 'dark';
+    const savedTheme = getStorageItem('theme') || 'auto';
+    applyTheme(savedTheme);
+    
+    // Update theme when system preference changes (for 'auto' mode)
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+        const currentTheme = getStorageItem('theme') || 'auto';
+        if (currentTheme === 'auto') {
+            applyTheme('auto');
+        }
+    });
 }
 
 export function toggleTheme() {
-    const theme = document.body.dataset.theme === 'light' ? 'dark' : 'light';
-    document.body.dataset.theme = theme;
-    setStorageItem('theme', theme);
+    const currentTheme = getStorageItem('theme') || 'auto';
+    let newTheme;
+    
+    if (currentTheme === 'dark') {
+        newTheme = 'light';
+    } else {
+        newTheme = 'dark';
+    }
+    
+    setStorageItem('theme', newTheme);
+    applyTheme(newTheme);
+    
+    // Force a repaint to ensure theme changes are applied immediately
+    document.body.style.display = 'none';
+    document.body.offsetHeight; // Trigger a reflow
+    document.body.style.display = '';
+    
+    return newTheme;
+}
+
+// Add a new helper function to apply the theme
+function applyTheme(theme) {
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const htmlElement = document.documentElement;
+    
+    // Remove any existing theme attributes
+    htmlElement.removeAttribute('data-theme');
+    
+    // Apply the appropriate theme
+    if (theme === 'dark' || (theme === 'auto' && prefersDark)) {
+        htmlElement.setAttribute('data-theme', 'dark');
+        document.body.dataset.theme = 'dark';
+    } else {
+        htmlElement.setAttribute('data-theme', 'light');
+        document.body.dataset.theme = 'light';
+    }
 }
 
 export function toggleFolder(tag) {
@@ -108,12 +184,6 @@ export function toggleFolder(tag) {
     resetAndReload();
 }
 
-export function copyTriggerWord(word) {
-    navigator.clipboard.writeText(word).then(() => {
-        showToast('Trigger word copied', 'success');
-    });
-}
-
 function filterByFolder(folderPath) {
     document.querySelectorAll('.lora-card').forEach(card => {
         card.style.display = card.dataset.folder === folderPath ? '' : 'none';

templates/base.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link rel="stylesheet" href="/loras_static/css/style.css">
     {% block page_css %}{% endblock %}
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css"
+    <link rel="stylesheet" href="/loras_static/vendor/font-awesome/css/all.min.css"
         crossorigin="anonymous" referrerpolicy="no-referrer">
     <link rel="icon" type="image/png" sizes="32x32" href="/loras_static/images/favicon-32x32.png">
     <link rel="icon" type="image/png" sizes="16x16" href="/loras_static/images/favicon-16x16.png">
@@ -17,7 +17,7 @@
     {% block preload %}{% endblock %}
 
     <!-- 优化字体加载 -->
-    <link rel="preload" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/webfonts/fa-solid-900.woff2"
+    <link rel="preload" href="/loras_static/vendor/font-awesome/webfonts/fa-solid-900.woff2"
         as="font" type="font/woff2" crossorigin>
 
     <!-- 添加性能监控 -->
@@ -35,7 +35,7 @@
 
     <!-- 添加资源加载策略 -->
     <link rel="preconnect" href="https://civitai.com">
-    <link rel="preconnect" href="https://cdnjs.cloudflare.com">
+    <!-- <link rel="preconnect" href="https://cdnjs.cloudflare.com"> -->
 
     <script>
         // 计算滚动条宽度并设置CSS变量
@@ -48,6 +48,20 @@
             document.documentElement.style.setProperty('--scrollbar-width', scrollbarWidth + 'px');
         });
     </script>
+    <script>
+      (function() {
+        // Apply theme immediately based on stored preference
+        const STORAGE_PREFIX = 'lora_manager_';
+        const savedTheme = localStorage.getItem(STORAGE_PREFIX + 'theme') || 'auto';
+        const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+        
+        if (savedTheme === 'dark' || (savedTheme === 'auto' && prefersDark)) {
+          document.documentElement.setAttribute('data-theme', 'dark');
+        } else {
+          document.documentElement.setAttribute('data-theme', 'light');
+        }
+      })();
+    </script>
     {% block head_scripts %}{% endblock %}
 </head>
 

templates/components/controls.html

@@ -35,6 +35,11 @@
                 </button>
             </div>
             {% endif %}
+            <div class="control-group">
+                <button id="favoriteFilterBtn" data-action="toggle-favorites" class="favorite-filter" title="Show favorites only">
+                    <i class="fas fa-star"></i> Favorites
+                </button>
+            </div>
             <div id="customFilterIndicator" class="control-group hidden">
                 <div class="filter-active">
                     <i class="fas fa-filter"></i> <span class="customFilterText" title=""></span>

templates/recipes.html

@@ -37,7 +37,7 @@
     <div class="controls">
         <div class="action-buttons">
             <div title="Refresh recipe list" class="control-group">
-                <button onclick="recipeManager.loadRecipes(true)"><i class="fas fa-sync"></i> Refresh</button>
+                <button onclick="recipeManager.refreshRecipes()"><i class="fas fa-sync"></i> Refresh</button>
             </div>
             <div title="Import recipes" class="control-group">
                 <button onclick="importManager.showImportModal()"><i class="fas fa-file-import"></i> Import</button>

web/comfyui/legacy_loras_widget.js

@@ -927,10 +927,6 @@ export function addLorasWidget(node, name, opts, callback) {
 // Function to directly save the recipe without dialog
 async function saveRecipeDirectly(widget) {
   try {
-    // Get the workflow data from the ComfyUI app
-    const prompt = await app.graphToPrompt();
-    console.log('Prompt:', prompt);
-    
     // Show loading toast
     if (app && app.extensionManager && app.extensionManager.toast) {
       app.extensionManager.toast.add({
@@ -941,14 +937,9 @@ async function saveRecipeDirectly(widget) {
       });
     }
     
-    // Prepare the data - only send workflow JSON
-    const formData = new FormData();
-    formData.append('workflow_json', JSON.stringify(prompt.output));
-    
     // Send the request
     const response = await fetch('/api/recipes/save-from-widget', {
-      method: 'POST',
-      body: formData
+      method: 'POST'
     });
     
     const result = await response.json();

web/comfyui/lora_loader.js

@@ -9,6 +9,54 @@ async function getLorasWidgetModule() {
     return await dynamicImportByVersion("./loras_widget.js", "./legacy_loras_widget.js");
 }
 
+// Function to get connected trigger toggle nodes
+function getConnectedTriggerToggleNodes(node) {
+    const connectedNodes = [];
+    
+    // Check if node has outputs
+    if (node.outputs && node.outputs.length > 0) {
+        // For each output slot
+        for (const output of node.outputs) {
+            // Check if this output has any links
+            if (output.links && output.links.length > 0) {
+                // For each link, get the target node
+                for (const linkId of output.links) {
+                    const link = app.graph.links[linkId];
+                    if (link) {
+                        const targetNode = app.graph.getNodeById(link.target_id);
+                        if (targetNode && targetNode.comfyClass === "TriggerWord Toggle (LoraManager)") {
+                            connectedNodes.push(targetNode.id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return connectedNodes;
+}
+
+// Function to update trigger words for connected toggle nodes
+function updateConnectedTriggerWords(node, text) {
+    const connectedNodeIds = getConnectedTriggerToggleNodes(node);
+    if (connectedNodeIds.length > 0) {
+        const loraNames = new Set();
+        let match;
+        LORA_PATTERN.lastIndex = 0;
+        while ((match = LORA_PATTERN.exec(text)) !== null) {
+            loraNames.add(match[1]);
+        }
+        
+        fetch("/loramanager/get_trigger_words", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                lora_names: Array.from(loraNames),
+                node_ids: connectedNodeIds
+            })
+        }).catch(err => console.error("Error fetching trigger words:", err));
+    }
+}
+
 function mergeLoras(lorasText, lorasArr) {
     const result = [];
     let match;
@@ -99,6 +147,9 @@ app.registerExtension({
                         newText = newText.replace(/\s+/g, ' ').trim();
                         
                         inputWidget.value = newText;
+                        
+                        // Add this line to update trigger words when lorasWidget changes cause inputWidget value to change
+                        updateConnectedTriggerWords(node, newText);
                     } finally {
                         isUpdating = false;
                     }
@@ -117,6 +168,9 @@ app.registerExtension({
                         const mergedLoras = mergeLoras(value, currentLoras);
                         
                         node.lorasWidget.value = mergedLoras;
+                        
+                        // Replace the existing trigger word update code with the new function
+                        updateConnectedTriggerWords(node, value);
                     } finally {
                         isUpdating = false;
                     }

web/comfyui/lora_stacker.js

@@ -1,9 +1,58 @@
 import { app } from "../../scripts/app.js";
-import { addLorasWidget } from "./loras_widget.js";
+import { dynamicImportByVersion } from "./utils.js";
 
 // Extract pattern into a constant for consistent use
 const LORA_PATTERN = /<lora:([^:]+):([-\d\.]+)>/g;
 
+// Function to get the appropriate loras widget based on ComfyUI version
+async function getLorasWidgetModule() {
+    return await dynamicImportByVersion("./loras_widget.js", "./legacy_loras_widget.js");
+}
+
+// Function to get connected trigger toggle nodes
+function getConnectedTriggerToggleNodes(node) {
+    const connectedNodes = [];
+    
+    if (node.outputs && node.outputs.length > 0) {
+        for (const output of node.outputs) {
+            if (output.links && output.links.length > 0) {
+                for (const linkId of output.links) {
+                    const link = app.graph.links[linkId];
+                    if (link) {
+                        const targetNode = app.graph.getNodeById(link.target_id);
+                        if (targetNode && targetNode.comfyClass === "TriggerWord Toggle (LoraManager)") {
+                            connectedNodes.push(targetNode.id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return connectedNodes;
+}
+
+// Function to update trigger words for connected toggle nodes
+function updateConnectedTriggerWords(node, text) {
+    const connectedNodeIds = getConnectedTriggerToggleNodes(node);
+    if (connectedNodeIds.length > 0) {
+        const loraNames = new Set();
+        let match;
+        LORA_PATTERN.lastIndex = 0;
+        while ((match = LORA_PATTERN.exec(text)) !== null) {
+            loraNames.add(match[1]);
+        }
+        
+        fetch("/loramanager/get_trigger_words", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                lora_names: Array.from(loraNames),
+                node_ids: connectedNodeIds
+            })
+        }).catch(err => console.error("Error fetching trigger words:", err));
+    }
+}
+
 function mergeLoras(lorasText, lorasArr) {
     const result = [];
     let match;
@@ -40,7 +89,7 @@ app.registerExtension({
             });
 
             // Wait for node to be properly initialized
-            requestAnimationFrame(() => {               
+            requestAnimationFrame(async () => {               
                 // Restore saved value if exists
                 let existingLoras = [];
                 if (node.widgets_values && node.widgets_values.length > 0) {
@@ -64,7 +113,10 @@ app.registerExtension({
                 // Add flag to prevent callback loops
                 let isUpdating = false;
                  
-                // Get the widget object directly from the returned object
+                // Dynamically load the appropriate widget module
+                const lorasModule = await getLorasWidgetModule();
+                const { addLorasWidget } = lorasModule;
+                
                 const result = addLorasWidget(node, "loras", {
                     defaultVal: mergedLoras  // Pass object directly
                 }, (value) => {
@@ -86,6 +138,9 @@ app.registerExtension({
                         newText = newText.replace(/\s+/g, ' ').trim();
                         
                         inputWidget.value = newText;
+                        
+                        // Update trigger words when lorasWidget changes
+                        updateConnectedTriggerWords(node, newText);
                     } finally {
                         isUpdating = false;
                     }
@@ -104,6 +159,9 @@ app.registerExtension({
                         const mergedLoras = mergeLoras(value, currentLoras);
                         
                         node.lorasWidget.value = mergedLoras;
+                        
+                        // Update trigger words when input changes
+                        updateConnectedTriggerWords(node, value);
                     } finally {
                         isUpdating = false;
                     }

web/comfyui/loras_widget.js

@@ -900,7 +900,7 @@ export function addLorasWidget(node, name, opts, callback) {
     });
     
     // Calculate height based on number of loras and fixed sizes
-    const calculatedHeight = CONTAINER_PADDING + HEADER_HEIGHT + (lorasData.length * LORA_ENTRY_HEIGHT);
+    const calculatedHeight = CONTAINER_PADDING + HEADER_HEIGHT + (Math.min(lorasData.length, 5) * LORA_ENTRY_HEIGHT);
     updateWidgetHeight(calculatedHeight);
   };
 

web/comfyui/usage_stats.js

@@ -0,0 +1,36 @@
+// ComfyUI extension to track model usage statistics
+import { app } from "../../scripts/app.js";
+import { api } from "../../scripts/api.js";
+
+// Register the extension
+app.registerExtension({
+    name: "ComfyUI-Lora-Manager.UsageStats",
+    
+    init() {
+        // Listen for successful executions
+        api.addEventListener("execution_success", ({ detail }) => {
+            if (detail && detail.prompt_id) {
+                this.updateUsageStats(detail.prompt_id);
+            }
+        });
+    },
+    
+    async updateUsageStats(promptId) {
+        try {
+            // Call backend endpoint with the prompt_id
+            const response = await fetch(`/loras/api/update-usage-stats`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ prompt_id: promptId }),
+            });
+            
+            if (!response.ok) {
+                console.warn("Failed to update usage statistics:", response.statusText);
+            }
+        } catch (error) {
+            console.error("Error updating usage statistics:", error);
+        }
+    }
+});