Bump version to v0.8.2

- Introduced new API endpoints for fetching Civitai model details by model version ID or hash.
- Enhanced the download manager to support downloading LoRAs using model version ID or hash, improving flexibility.
- Updated RecipeModal to handle missing LoRAs, allowing users to download them directly from the recipe interface.
- Added tooltip and click functionality for missing LoRAs status, enhancing user experience.
- Improved error handling for missing LoRAs download process, providing clearer feedback to users.

README.md

@@ -14,11 +14,26 @@ A comprehensive toolset that streamlines organizing, downloading, and applying L
 Watch this quick tutorial to learn how to use the new one-click LoRA integration feature:
 
 [![One-Click LoRA Integration Tutorial](https://img.youtube.com/vi/qS95OjX3e70/0.jpg)](https://youtu.be/qS95OjX3e70)
+[![LoRA Manager v0.8.0 - New Recipe Feature & Bulk Operations](https://img.youtube.com/vi/noN7f_ER7yo/0.jpg)](https://youtu.be/noN7f_ER7yo)
 
 ---
 
 ## Release Notes
 
+### v0.8.2  
+* **Faster Initialization for Forge Users** - Improved first-run efficiency by utilizing existing `.json` and `.civitai.info` files from Forge’s CivitAI helper extension, making migration smoother.  
+* **LoRA Filename Editing** - Added support for renaming LoRA files directly within LoRA Manager.  
+* **Recipe Editing** - Users can now edit recipe names and tags.  
+* **Retain Deleted LoRAs in Recipes** - Deleted LoRAs will remain listed in recipes, allowing future functionality to reconnect them once re-obtained.  
+* **Download Missing LoRAs from Recipes** - Easily fetch missing LoRAs associated with a recipe.
+
+### v0.8.1
+* **Base Model Correction** - Added support for modifying base model associations to fix incorrect metadata for non-CivitAI LoRAs
+* **LoRA Loader Flexibility** - Made CLIP input optional for model-only workflows like Hunyuan video generation
+* **Expanded Recipe Support** - Added compatibility with 3 additional recipe metadata formats
+* **Enhanced Showcase Images** - Generation parameters now displayed alongside LoRA preview images
+* **UI Improvements & Bug Fixes** - Various interface refinements and stability enhancements
+
 ### v0.8.0
 * **Introduced LoRA Recipes** - Create, import, save, and share your favorite LoRA combinations
 * **Recipe Management System** - Easily browse, search, and organize your LoRA recipes

py/nodes/lora_loader.py

@@ -18,7 +18,7 @@ class LoraManagerLoader:
         return {
             "required": {
                 "model": ("MODEL",),
-                "clip": ("CLIP",),
+                # "clip": ("CLIP",),
                 "text": (IO.STRING, {
                     "multiline": True, 
                     "dynamicPrompts": True, 
@@ -75,11 +75,12 @@ class LoraManagerLoader:
             logger.warning(f"Unexpected loras format: {type(loras_data)}")
             return []
     
-    def load_loras(self, model, clip, text, **kwargs):
+    def load_loras(self, model, text, **kwargs):
         """Loads multiple LoRAs based on the kwargs input and lora_stack."""
         loaded_loras = []
         all_trigger_words = []
         
+        clip = kwargs.get('clip', None)
         lora_stack = kwargs.get('lora_stack', None)
         # First process lora_stack if available
         if lora_stack:

py/nodes/lora_stacker.py

@@ -26,8 +26,8 @@ class LoraStacker:
             "optional": FlexibleOptionalInputType(any_type),
         }
 
-    RETURN_TYPES = ("LORA_STACK", IO.STRING)
-    RETURN_NAMES = ("LORA_STACK", "trigger_words")
+    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):
@@ -75,6 +75,7 @@ class LoraStacker:
     def stack_loras(self, text, **kwargs):
         """Stacks multiple LoRAs based on the kwargs input without loading them."""
         stack = []
+        active_loras = []
         all_trigger_words = []
         
         # Process existing lora_stack if available
@@ -103,11 +104,15 @@ class LoraStacker:
             # Add to stack without loading
             # replace '/' with os.sep to avoid different OS path format
             stack.append((lora_path.replace('/', os.sep), model_strength, clip_strength))
+            active_loras.append((lora_name, model_strength))
             
             # Add trigger words to collection
             all_trigger_words.extend(trigger_words)
         
         # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+        # Format active_loras as <lora:lora_name:strength> separated by spaces
+        active_loras_text = " ".join([f"<lora:{name}:{str(strength).strip()}>" 
+                                  for name, strength in active_loras])
 
-        return (stack, trigger_words_text)
+        return (stack, trigger_words_text, active_loras_text)

py/routes/api_routes.py

@@ -42,6 +42,8 @@ class ApiRoutes:
         app.router.add_get('/api/lora-roots', routes.get_lora_roots)
         app.router.add_get('/api/folders', routes.get_folders)
         app.router.add_get('/api/civitai/versions/{model_id}', routes.get_civitai_versions)
+        app.router.add_get('/api/civitai/model/{modelVersionId}', routes.get_civitai_model)
+        app.router.add_get('/api/civitai/model/{hash}', routes.get_civitai_model)
         app.router.add_post('/api/download-lora', routes.download_lora)
         app.router.add_post('/api/settings', routes.update_settings)
         app.router.add_post('/api/move_model', routes.move_model)
@@ -52,6 +54,7 @@ class ApiRoutes:
         app.router.add_get('/api/loras/top-tags', routes.get_top_tags)  # Add new route for top tags
         app.router.add_get('/api/loras/base-models', routes.get_base_models)  # Add new route for base models
         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
 
         # Add update check routes
         UpdateRoutes.setup_routes(app)
@@ -565,6 +568,23 @@ class ApiRoutes:
         except Exception as e:
             logger.error(f"Error fetching model versions: {e}")
             return web.Response(status=500, text=str(e))
+        
+    async def get_civitai_model(self, request: web.Request) -> web.Response:
+        """Get CivitAI model details by model version ID or hash"""
+        try:
+            model_version_id = request.match_info['modelVersionId']
+            if not model_version_id:
+                hash = request.match_info['hash']
+                model = await self.civitai_client.get_model_by_hash(hash)
+                return web.json_response(model)
+            
+            # Get model details from Civitai API    
+            model = await self.civitai_client.get_model_version_info(model_version_id)
+            return web.json_response(model)
+        except Exception as e:
+            logger.error(f"Error fetching model details: {e}")
+            return web.Response(status=500, text=str(e))
+    
 
     async def download_lora(self, request: web.Request) -> web.Response:
         async with self._download_lock:
@@ -578,8 +598,22 @@ class ApiRoutes:
                         'progress': progress
                     })
                 
+                # Check which identifier is provided
+                download_url = data.get('download_url')
+                model_hash = data.get('model_hash')
+                model_version_id = data.get('model_version_id')
+                
+                # Validate that at least one identifier is provided
+                if not any([download_url, model_hash, model_version_id]):
+                    return web.Response(
+                        status=400, 
+                        text="Missing required parameter: Please provide either 'download_url', 'hash', or 'modelVersionId'"
+                    )
+                
                 result = await self.download_manager.download_from_civitai(
-                    download_url=data.get('download_url'),
+                    download_url=download_url,
+                    model_hash=model_hash,
+                    model_version_id=model_version_id,
                     save_dir=data.get('lora_root'),
                     relative_path=data.get('relative_path'),
                     progress_callback=progress_callback
@@ -929,6 +963,149 @@ class ApiRoutes:
             })
         except Exception as e:
             logger.error(f"Error retrieving base models: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
+    def get_multipart_ext(self, filename):
+        parts = filename.split(".")
+        if len(parts) > 2:  # 如果包含多级扩展名
+            return "." + ".".join(parts[-2:])  # 取最后两部分，如 ".metadata.json"
+        return os.path.splitext(filename)[1]  # 否则取普通扩展名，如 ".safetensors"
+
+    async def rename_lora(self, request: web.Request) -> web.Response:
+        """Handle renaming a LoRA file and its associated files"""
+        try:
+            data = await request.json()
+            file_path = data.get('file_path')
+            new_file_name = data.get('new_file_name')
+            
+            if not file_path or not new_file_name:
+                return web.json_response({
+                    'success': False,
+                    'error': 'File path and new file name are required'
+                }, status=400)
+            
+            # Validate the new file name (no path separators or invalid characters)
+            invalid_chars = ['/', '\\', ':', '*', '?', '"', '<', '>', '|']
+            if any(char in new_file_name for char in invalid_chars):
+                return web.json_response({
+                    'success': False,
+                    'error': 'Invalid characters in file name'
+                }, status=400)
+            
+            # Get the directory and current file name
+            target_dir = os.path.dirname(file_path)
+            old_file_name = os.path.splitext(os.path.basename(file_path))[0]
+            
+            # Check if the target file already exists
+            new_file_path = os.path.join(target_dir, f"{new_file_name}.safetensors").replace(os.sep, '/')
+            if os.path.exists(new_file_path):
+                return web.json_response({
+                    'success': False,
+                    'error': 'A file with this name already exists'
+                }, status=400)
+            
+            # Define the patterns for associated files
+            patterns = [
+                f"{old_file_name}.safetensors",  # Required
+                f"{old_file_name}.metadata.json",
+                f"{old_file_name}.preview.png",
+                f"{old_file_name}.preview.jpg",
+                f"{old_file_name}.preview.jpeg",
+                f"{old_file_name}.preview.webp",
+                f"{old_file_name}.preview.mp4",
+                f"{old_file_name}.png",
+                f"{old_file_name}.jpg",
+                f"{old_file_name}.jpeg",
+                f"{old_file_name}.webp",
+                f"{old_file_name}.mp4"
+            ]
+            
+            # Find all matching files
+            existing_files = []
+            for pattern in patterns:
+                path = os.path.join(target_dir, pattern)
+                if os.path.exists(path):
+                    existing_files.append((path, pattern))
+            
+            # Get the hash from the main file to update hash index
+            hash_value = None
+            metadata = None
+            metadata_path = os.path.join(target_dir, f"{old_file_name}.metadata.json")
+            
+            if os.path.exists(metadata_path):
+                try:
+                    with open(metadata_path, 'r', encoding='utf-8') as f:
+                        metadata = json.load(f)
+                        hash_value = metadata.get('sha256')
+                except Exception as e:
+                    logger.error(f"Error loading metadata for rename: {e}")
+            
+            # Rename all files
+            renamed_files = []
+            new_metadata_path = None
+            
+            # Notify file monitor to ignore these events
+            main_file_path = os.path.join(target_dir, f"{old_file_name}.safetensors")
+            if os.path.exists(main_file_path) and self.download_manager.file_monitor:
+                # Add old and new paths to ignore list
+                file_size = os.path.getsize(main_file_path)
+                self.download_manager.file_monitor.handler.add_ignore_path(main_file_path, file_size)
+                self.download_manager.file_monitor.handler.add_ignore_path(new_file_path, file_size)
+            
+            for old_path, pattern in existing_files:
+                # Get the file extension like .safetensors or .metadata.json
+                ext = self.get_multipart_ext(pattern)
+
+                # Create the new path
+                new_path = os.path.join(target_dir, f"{new_file_name}{ext}").replace(os.sep, '/')
+                
+                # Rename the file
+                os.rename(old_path, new_path)
+                renamed_files.append(new_path)
+                
+                # Keep track of metadata path for later update
+                if ext == '.metadata.json':
+                    new_metadata_path = new_path
+            
+            # Update the metadata file with new file name and paths
+            if new_metadata_path and metadata:
+                # Update file_name, file_path and preview_url in metadata
+                metadata['file_name'] = new_file_name
+                metadata['file_path'] = new_file_path
+                
+                # Update preview_url if it exists
+                if 'preview_url' in metadata and metadata['preview_url']:
+                    old_preview = metadata['preview_url']
+                    ext = self.get_multipart_ext(old_preview)
+                    new_preview = os.path.join(target_dir, f"{new_file_name}{ext}").replace(os.sep, '/')
+                    metadata['preview_url'] = new_preview
+                
+                # Save updated metadata
+                with open(new_metadata_path, 'w', encoding='utf-8') as f:
+                    json.dump(metadata, f, indent=2, ensure_ascii=False)
+            
+            # Update the scanner cache
+            if metadata:
+                await self.scanner.update_single_lora_cache(file_path, new_file_path, metadata)
+                
+                # Update recipe files and cache if hash is available
+                if hash_value:
+                    recipe_scanner = RecipeScanner(self.scanner)
+                    recipes_updated, cache_updated = await recipe_scanner.update_lora_filename_by_hash(hash_value, new_file_name)
+                    logger.info(f"Updated {recipes_updated} recipe files and {cache_updated} cache entries for renamed LoRA")
+            
+            return web.json_response({
+                'success': True,
+                'new_file_path': new_file_path,
+                'renamed_files': renamed_files,
+                'reload_required': False
+            })
+            
+        except Exception as e:
+            logger.error(f"Error renaming LoRA: {e}", exc_info=True)
             return web.json_response({
                 'success': False,
                 'error': str(e)

py/routes/lora_routes.py

@@ -58,11 +58,13 @@ class LoraRoutes:
     async def handle_loras_page(self, request: web.Request) -> web.Response:
         """Handle GET /loras request"""
         try:
-            # 不等待缓存数据，直接检查缓存状态
+            # 检查缓存初始化状态，增强判断条件
             is_initializing = (
-                self.scanner._cache is None and 
+                self.scanner._cache is None or 
                 (self.scanner._initialization_task is not None and 
-                not self.scanner._initialization_task.done())
+                not self.scanner._initialization_task.done()) or
+                (self.scanner._cache is not None and len(self.scanner._cache.raw_data) == 0 and 
+                 self.scanner._initialization_task is not None)
             )
 
             if is_initializing:
@@ -74,16 +76,31 @@ class LoraRoutes:
                     settings=settings,  # Pass settings to template
                     request=request  # Pass the request object to the template
                 )
+                
+                logger.info("Loras page is initializing, returning loading page")
             else:
-                # 正常流程
-                cache = await self.scanner.get_cached_data()
-                template = self.template_env.get_template('loras.html')
-                rendered = template.render(
-                    folders=cache.folders,
-                    is_initializing=False,
-                    settings=settings,  # Pass settings to template
-                    request=request  # Pass the request object to the template
-                )
+                # 正常流程 - 但不要等待缓存刷新
+                try:
+                    cache = await self.scanner.get_cached_data(force_refresh=False)
+                    template = self.template_env.get_template('loras.html')
+                    rendered = template.render(
+                        folders=cache.folders,
+                        is_initializing=False,
+                        settings=settings,  # Pass settings to template
+                        request=request  # Pass the request object to the template
+                    )
+                    logger.info(f"Loras page loaded successfully with {len(cache.raw_data)} items")
+                except Exception as cache_error:
+                    logger.error(f"Error loading cache data: {cache_error}")
+                    # 如果获取缓存失败，也显示初始化页面
+                    template = self.template_env.get_template('loras.html')
+                    rendered = template.render(
+                        folders=[],
+                        is_initializing=True,
+                        settings=settings,
+                        request=request
+                    )
+                    logger.info("Cache error, returning initialization page")
             
             return web.Response(
                 text=rendered,

py/routes/recipe_routes.py

@@ -14,7 +14,7 @@ from ..services.recipe_scanner import RecipeScanner
 from ..services.lora_scanner import LoraScanner
 from ..config import config
 from ..workflow.parser import WorkflowParser
-from ..utils.utils import download_twitter_image
+from ..utils.utils import download_civitai_image
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +47,12 @@ class RecipeRoutes:
         app.router.add_get('/api/recipe/{recipe_id}/share', routes.share_recipe)
         app.router.add_get('/api/recipe/{recipe_id}/share/download', routes.download_shared_recipe)
         
+        # Add new endpoint for getting recipe syntax
+        app.router.add_get('/api/recipe/{recipe_id}/syntax', routes.get_recipe_syntax)
+        
+        # Add new endpoint for updating recipe metadata (name and tags)
+        app.router.add_put('/api/recipe/{recipe_id}/update', routes.update_recipe)
+        
         # Start cache initialization
         app.on_startup.append(routes._init_cache)
         
@@ -235,7 +241,7 @@ class RecipeRoutes:
                     }, status=400)
                 
                 # Download image from URL
-                temp_path = download_twitter_image(url)
+                temp_path = download_civitai_image(url)
                 
                 if not temp_path:
                     return web.json_response({
@@ -244,10 +250,10 @@ class RecipeRoutes:
                     }, status=400)
             
             # Extract metadata from the image using ExifUtils
-            user_comment = ExifUtils.extract_user_comment(temp_path)
+            metadata = ExifUtils.extract_image_metadata(temp_path)
             
             # If no metadata found, return a more specific error
-            if not user_comment:
+            if not metadata:
                 result = {
                     "error": "No metadata found in this image",
                     "loras": []  # Return empty loras array to prevent client-side errors
@@ -262,7 +268,7 @@ class RecipeRoutes:
                 return web.json_response(result, status=200)
             
             # Use the parser factory to get the appropriate parser
-            parser = RecipeParserFactory.create_parser(user_comment)
+            parser = RecipeParserFactory.create_parser(metadata)
 
             if parser is None:
                 result = {
@@ -280,7 +286,7 @@ class RecipeRoutes:
             
             # Parse the metadata
             result = await parser.parse_metadata(
-                user_comment, 
+                metadata, 
                 recipe_scanner=self.recipe_scanner, 
                 civitai_client=self.civitai_client
             )
@@ -387,8 +393,7 @@ class RecipeRoutes:
                         return web.json_response({"error": f"Invalid base64 image data: {str(e)}"}, status=400)
                 elif image_url:
                     # Download image from URL
-                    from ..utils.utils import download_twitter_image
-                    temp_path = download_twitter_image(image_url)
+                    temp_path = download_civitai_image(image_url)
                     if not temp_path:
                         return web.json_response({"error": "Failed to download image from URL"}, status=400)
                     
@@ -433,19 +438,20 @@ class RecipeRoutes:
             # Format loras data according to the recipe.json format
             loras_data = []
             for lora in metadata.get("loras", []):
-                # Skip deleted LoRAs if they're marked to be excluded
-                if lora.get("isDeleted", False) and lora.get("exclude", False):
-                    continue
+                # Modified: Always include deleted LoRAs in the recipe metadata
+                # Even if they're marked to be excluded, we still keep their identifying information
+                # The exclude flag will only be used to determine if they should be included in recipe syntax
                 
                 # Convert frontend lora format to recipe format
                 lora_entry = {
-                    "file_name": lora.get("file_name", "") or os.path.splitext(os.path.basename(lora.get("localPath", "")))[0],
+                    "file_name": lora.get("file_name", "") or os.path.splitext(os.path.basename(lora.get("localPath", "")))[0] if lora.get("localPath") else "",
                     "hash": lora.get("hash", "").lower() if lora.get("hash") else "",
                     "strength": float(lora.get("weight", 1.0)),
                     "modelVersionId": lora.get("id", ""),
                     "modelName": lora.get("name", ""),
                     "modelVersionName": lora.get("version", ""),
-                    "isDeleted": lora.get("isDeleted", False)  # Preserve deletion status in saved recipe
+                    "isDeleted": lora.get("isDeleted", False),  # Preserve deletion status in saved recipe
+                    "exclude": lora.get("exclude", False)  # Add exclude flag to the recipe
                 }
                 loras_data.append(lora_entry)
             
@@ -906,3 +912,110 @@ class RecipeRoutes:
         except Exception as e:
             logger.error(f"Error saving recipe from widget: {e}", exc_info=True)
             return web.json_response({"error": str(e)}, status=500)
+
+    async def get_recipe_syntax(self, request: web.Request) -> web.Response:
+        """Generate recipe syntax for LoRAs in the recipe, looking up proper file names using hash_index"""
+        try:
+            recipe_id = request.match_info['recipe_id']
+            
+            # Get all recipes from cache
+            cache = await self.recipe_scanner.get_cached_data()
+            
+            # Find the specific recipe
+            recipe = next((r for r in cache.raw_data if str(r.get('id', '')) == recipe_id), None)
+            
+            if not recipe:
+                return web.json_response({"error": "Recipe not found"}, status=404)
+            
+            # Get the loras from the recipe
+            loras = recipe.get('loras', [])
+            
+            if not loras:
+                return web.json_response({"error": "No LoRAs found in this recipe"}, status=400)
+            
+            # Generate recipe syntax for all LoRAs that:
+            # 1. Are in the library (not deleted) OR
+            # 2. Are deleted but not marked for exclusion
+            lora_syntax_parts = []
+            
+            # Access the hash_index from lora_scanner
+            hash_index = self.recipe_scanner._lora_scanner._hash_index
+            
+            for lora in loras:
+                # Skip loras that are deleted AND marked for exclusion
+                if lora.get("isDeleted", False):
+                    continue
+
+                if not self.recipe_scanner._lora_scanner.has_lora_hash(lora.get("hash", "")):
+                    continue
+                
+                # Get the strength
+                strength = lora.get("strength", 1.0)
+                
+                # Try to find the actual file name for this lora
+                file_name = None
+                hash_value = lora.get("hash", "").lower()
+                
+                if hash_value and hasattr(hash_index, "_hash_to_path"):
+                    # Look up the file path from the hash
+                    file_path = hash_index._hash_to_path.get(hash_value)
+                    
+                    if file_path:
+                        # Extract the file name without extension from the path
+                        file_name = os.path.splitext(os.path.basename(file_path))[0]
+                
+                # If hash lookup failed, fall back to modelVersionId lookup
+                if not file_name and lora.get("modelVersionId"):
+                    # Search for files with matching modelVersionId
+                    all_loras = await self.recipe_scanner._lora_scanner.get_cached_data()
+                    for cached_lora in all_loras.raw_data:
+                        if not cached_lora.get("civitai"):
+                            continue
+                        if cached_lora.get("civitai", {}).get("id") == lora.get("modelVersionId"):
+                            file_name = os.path.splitext(os.path.basename(cached_lora["path"]))[0]
+                            break
+                
+                # If all lookups failed, use the file_name from the recipe
+                if not file_name:
+                    file_name = lora.get("file_name", "unknown-lora")
+                
+                # Add to syntax parts
+                lora_syntax_parts.append(f"<lora:{file_name}:{strength}>")
+            
+            # Join the LoRA syntax parts
+            lora_syntax = " ".join(lora_syntax_parts)
+            
+            return web.json_response({
+                'success': True,
+                'syntax': lora_syntax
+            })
+        except Exception as e:
+            logger.error(f"Error generating recipe syntax: {e}", exc_info=True)
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def update_recipe(self, request: web.Request) -> web.Response:
+        """Update recipe metadata (name and tags)"""
+        try:
+            recipe_id = request.match_info['recipe_id']
+            data = await request.json()
+            
+            # Validate required fields
+            if 'title' not in data and 'tags' not in data:
+                return web.json_response({
+                    "error": "At least one field to update must be provided (title or tags)"
+                }, status=400)
+            
+            # Use the recipe scanner's update method
+            success = await self.recipe_scanner.update_recipe_metadata(recipe_id, data)
+            
+            if not success:
+                return web.json_response({"error": "Recipe not found or update failed"}, status=404)
+            
+            return web.json_response({
+                "success": True,
+                "recipe_id": recipe_id,
+                "updates": data
+            })
+        except Exception as e:
+            logger.error(f"Error updating recipe: {e}", exc_info=True)
+            return web.json_response({"error": str(e)}, status=500)

py/services/civitai_client.py

@@ -76,10 +76,11 @@ class CivitaiClient:
             headers = self._get_request_headers()
             async with session.get(url, headers=headers, allow_redirects=True) as response:
                 if response.status != 200:
-                    # Handle early access 401 unauthorized responses
+                    # Handle 401 unauthorized responses
                     if response.status == 401:
                         logger.warning(f"Unauthorized access to resource: {url} (Status 401)")
-                        return False, "Early access restriction: You must purchase early access to download this LoRA."
+                        
+                        return False, "Invalid or missing CivitAI API key, or early access restriction."
                     
                     # Handle other client errors that might be permission-related
                     if response.status == 403:
@@ -251,4 +252,4 @@ class CivitaiClient:
             return None
         except Exception as e:
             logger.error(f"Error getting hash from Civitai: {e}")
-            return None
+            return None

py/services/download_manager.py

@@ -13,8 +13,9 @@ class DownloadManager:
         self.civitai_client = CivitaiClient()
         self.file_monitor = file_monitor
 
-    async def download_from_civitai(self, download_url: str, save_dir: str, relative_path: str = '', 
-                                  progress_callback=None) -> Dict:
+    async def download_from_civitai(self, download_url: str = None, model_hash: str = None, 
+                                  model_version_id: str = None, save_dir: str = None, 
+                                  relative_path: str = '', progress_callback=None) -> Dict:
         try:
             # Update save directory with relative path if provided
             if relative_path:
@@ -22,14 +23,26 @@ class DownloadManager:
                 # Create directory if it doesn't exist
                 os.makedirs(save_dir, exist_ok=True)
 
-            # Get version info
-            version_id = download_url.split('/')[-1]
-            version_info = await self.civitai_client.get_model_version_info(version_id)
+            # Get version info based on the provided identifier
+            version_info = None
+            
+            if download_url:
+                # Extract version ID from download URL
+                version_id = download_url.split('/')[-1]
+                version_info = await self.civitai_client.get_model_version_info(version_id)
+            elif model_version_id:
+                # Use model version ID directly
+                version_info = await self.civitai_client.get_model_version_info(model_version_id)
+            elif model_hash:
+                # Get model by hash
+                version_info = await self.civitai_client.get_model_by_hash(model_hash)
+
+            
             if not version_info:
                 return {'success': False, 'error': 'Failed to fetch model metadata'}
 
             # Check if this is an early access LoRA
-            if 'earlyAccessEndsAt' in version_info:
+            if version_info.get('earlyAccessEndsAt'):
                 early_access_date = version_info.get('earlyAccessEndsAt', '')
                 # Convert to a readable date if possible
                 try:
@@ -89,7 +102,7 @@ class DownloadManager:
             
             # 6. 开始下载流程
             result = await self._execute_download(
-                download_url=download_url,
+                download_url=file_info.get('downloadUrl', ''),
                 save_dir=save_dir,
                 metadata=metadata,
                 version_info=version_info,

py/services/lora_scanner.py

@@ -3,11 +3,13 @@ import os
 import logging
 import asyncio
 import shutil
+import time
 from typing import List, Dict, Optional
-from dataclasses import dataclass
-from operator import itemgetter
+
+from ..utils.models import LoraMetadata
 from ..config import config
-from ..utils.file_utils import load_metadata, get_file_info
+from ..utils.file_utils import load_metadata, get_file_info, normalize_path, find_preview_file, save_metadata
+from ..utils.lora_metadata import extract_lora_metadata
 from .lora_cache import LoraCache
 from .lora_hash_index import LoraHashIndex
 from .settings_manager import settings
@@ -91,6 +93,7 @@ class LoraScanner:
     async def _initialize_cache(self) -> None:
         """Initialize or refresh the cache"""
         try:
+            start_time = time.time()
             # Clear existing hash index
             self._hash_index.clear()
             
@@ -122,7 +125,7 @@ class LoraScanner:
             await self._cache.resort()
 
             self._initialization_task = None
-            logger.info("LoRA Manager: Cache initialization completed")
+            logger.info(f"LoRA Manager: Cache initialization completed in {time.time() - start_time:.2f} seconds, found {len(raw_data)} loras")
         except Exception as e:
             logger.error(f"LoRA Manager: Error initializing cache: {e}")
             self._cache = LoraCache(
@@ -330,8 +333,30 @@ class LoraScanner:
         metadata = await load_metadata(file_path)
         
         if metadata is None:
-            # Create new metadata if none exists
-            metadata = await get_file_info(file_path)
+            # Try to find and use .civitai.info file first
+            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)
+                    
+                    file_info = next((f for f in version_info.get('files', []) if f.get('primary')), None)
+                    if file_info:
+                        # Create a minimal file_info with the required fields
+                        file_name = os.path.splitext(os.path.basename(file_path))[0]
+                        file_info['name'] = file_name
+                    
+                        # Use from_civitai_info to create metadata
+                        metadata = LoraMetadata.from_civitai_info(version_info, file_info, file_path)
+                        metadata.preview_url = find_preview_file(file_name, os.path.dirname(file_path))
+                        await save_metadata(file_path, metadata)
+                        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}")
+            
+            # If still no metadata, create new metadata using get_file_info
+            if metadata is None:
+                metadata = await get_file_info(file_path)
         
         # Convert to dict and add folder info
         lora_data = metadata.to_dict()
@@ -342,7 +367,7 @@ class LoraScanner:
         lora_data['folder'] = folder.replace(os.path.sep, '/')
         
         return lora_data
-
+            
     async def _fetch_missing_metadata(self, file_path: str, lora_data: Dict) -> None:
         """Fetch missing description and tags from Civitai if needed
         

py/services/recipe_cache.py

@@ -37,18 +37,18 @@ class RecipeCache:
         Returns:
             bool: True if the update was successful, False if the recipe wasn't found
         """
-        async with self._lock:
-            # Update in raw_data
-            for item in self.raw_data:
-                if item.get('id') == recipe_id:
-                    item.update(metadata)
-                    break
-            else:
-                return False  # Recipe not found
-                
-            # Resort to reflect changes
-            await self.resort()
-            return True
+
+        # Update in raw_data
+        for item in self.raw_data:
+            if item.get('id') == recipe_id:
+                item.update(metadata)
+                break
+        else:
+            return False  # Recipe not found
+            
+        # Resort to reflect changes
+        await self.resort()
+        return True
             
     async def add_recipe(self, recipe_data: Dict) -> None:
         """Add a new recipe to the cache

py/services/recipe_scanner.py

@@ -2,9 +2,7 @@ import os
 import logging
 import asyncio
 import json
-import re
-from typing import List, Dict, Optional, Any
-from datetime import datetime
+from typing import List, Dict, Optional, Any, Tuple
 from ..config import config
 from .recipe_cache import RecipeCache
 from .lora_scanner import LoraScanner
@@ -64,61 +62,44 @@ class RecipeScanner:
 
         # Try to acquire the lock with a timeout to prevent deadlocks
         try:
-            # Use a timeout for acquiring the lock
-            async with asyncio.timeout(1.0):
-                async with self._initialization_lock:
-                    # Check again after acquiring the lock
-                    if self._cache is not None and not force_refresh:
-                        return self._cache
+            async with self._initialization_lock:
+                # Check again after acquiring the lock
+                if self._cache is not None and not force_refresh:
+                    return self._cache
+                
+                # Mark as initializing to prevent concurrent initializations
+                self._is_initializing = True
+                
+                try:
+                    # Remove dependency on lora scanner initialization
+                    # Scan for recipe data directly
+                    raw_data = await self.scan_all_recipes()
                     
-                    # Mark as initializing to prevent concurrent initializations
-                    self._is_initializing = True
+                    # Update cache
+                    self._cache = RecipeCache(
+                        raw_data=raw_data,
+                        sorted_by_name=[],
+                        sorted_by_date=[]
+                    )
                     
-                    try:
-                        # First ensure the lora scanner is initialized
-                        if self._lora_scanner:
-                            try:
-                                lora_cache = await asyncio.wait_for(
-                                    self._lora_scanner.get_cached_data(), 
-                                    timeout=10.0
-                                )
-                            except asyncio.TimeoutError:
-                                logger.error("Timeout waiting for lora scanner initialization")
-                            except Exception as e:
-                                logger.error(f"Error waiting for lora scanner: {e}")
-                        
-                        # Scan for recipe data
-                        raw_data = await self.scan_all_recipes()
-                        
-                        # Update cache
-                        self._cache = RecipeCache(
-                            raw_data=raw_data,
-                            sorted_by_name=[],
-                            sorted_by_date=[]
-                        )
-                        
-                        # Resort cache
-                        await self._cache.resort()
-                        
-                        return self._cache
+                    # Resort cache
+                    await self._cache.resort()
                     
-                    except Exception as e:
-                        logger.error(f"Recipe Manager: Error initializing cache: {e}", exc_info=True)
-                        # Create empty cache on error
-                        self._cache = RecipeCache(
-                            raw_data=[],
-                            sorted_by_name=[],
-                            sorted_by_date=[]
-                        )
-                        return self._cache
-                    finally:
-                        # Mark initialization as complete
-                        self._is_initializing = False
+                    return self._cache
+                
+                except Exception as e:
+                    logger.error(f"Recipe Manager: Error initializing cache: {e}", exc_info=True)
+                    # Create empty cache on error
+                    self._cache = RecipeCache(
+                        raw_data=[],
+                        sorted_by_name=[],
+                        sorted_by_date=[]
+                    )
+                    return self._cache
+                finally:
+                    # Mark initialization as complete
+                    self._is_initializing = False
         
-        except asyncio.TimeoutError:
-            # If we can't acquire the lock in time, return the current cache or an empty one
-            logger.warning("Timeout acquiring initialization lock - returning current cache state")
-            return self._cache or RecipeCache(raw_data=[], sorted_by_name=[], sorted_by_date=[])
         except Exception as e:
             logger.error(f"Unexpected error in get_cached_data: {e}")
             return self._cache or RecipeCache(raw_data=[], sorted_by_name=[], sorted_by_date=[])
@@ -448,4 +429,136 @@ class RecipeScanner:
             'total_pages': (total_items + page_size - 1) // page_size
         }
         
-        return result 
+        return result
+
+    async def update_recipe_metadata(self, recipe_id: str, metadata: dict) -> bool:
+        """Update recipe metadata (like title and tags) in both file system and cache
+        
+        Args:
+            recipe_id: The ID of the recipe to update
+            metadata: Dictionary containing metadata fields to update (title, tags, etc.)
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        import os
+        import json
+        
+        # First, find the recipe JSON file path
+        recipe_json_path = os.path.join(self.recipes_dir, f"{recipe_id}.recipe.json")
+        
+        if not os.path.exists(recipe_json_path):
+            return False
+            
+        try:
+            # Load existing recipe data
+            with open(recipe_json_path, 'r', encoding='utf-8') as f:
+                recipe_data = json.load(f)
+                
+            # Update fields
+            for key, value in metadata.items():
+                recipe_data[key] = value
+                
+            # Save updated recipe
+            with open(recipe_json_path, 'w', encoding='utf-8') as f:
+                json.dump(recipe_data, f, indent=4, ensure_ascii=False)
+                
+            # Update the cache if it exists
+            if self._cache is not None:
+                await self._cache.update_recipe_metadata(recipe_id, metadata)
+                
+            # If the recipe has an image, update its EXIF metadata
+            from ..utils.exif_utils import ExifUtils
+            image_path = recipe_data.get('file_path')
+            if image_path and os.path.exists(image_path):
+                ExifUtils.append_recipe_metadata(image_path, recipe_data)
+                
+            return True
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).error(f"Error updating recipe metadata: {e}", exc_info=True)
+            return False
+
+    async def update_lora_filename_by_hash(self, hash_value: str, new_file_name: str) -> Tuple[int, int]:
+        """Update file_name in all recipes that contain a LoRA with the specified hash.
+        
+        Args:
+            hash_value: The SHA256 hash value of the LoRA
+            new_file_name: The new file_name to set
+            
+        Returns:
+            Tuple[int, int]: (number of recipes updated in files, number of recipes updated in cache)
+        """
+        if not hash_value or not new_file_name:
+            return 0, 0
+            
+        # Always use lowercase hash for consistency
+        hash_value = hash_value.lower()
+        
+        # Get recipes directory
+        recipes_dir = self.recipes_dir
+        if not recipes_dir or not os.path.exists(recipes_dir):
+            logger.warning(f"Recipes directory not found: {recipes_dir}")
+            return 0, 0
+            
+        # Check if cache is initialized
+        cache_initialized = self._cache is not None
+        cache_updated_count = 0
+        file_updated_count = 0
+        
+        # Get all recipe JSON files in the recipes directory
+        recipe_files = []
+        for root, _, files in os.walk(recipes_dir):
+            for file in files:
+                if file.lower().endswith('.recipe.json'):
+                    recipe_files.append(os.path.join(root, file))
+        
+        # Process each recipe file
+        for recipe_path in recipe_files:
+            try:
+                # Load the recipe data
+                with open(recipe_path, 'r', encoding='utf-8') as f:
+                    recipe_data = json.load(f)
+                
+                # Skip if no loras or invalid structure
+                if not recipe_data or not isinstance(recipe_data, dict) or 'loras' not in recipe_data:
+                    continue
+                
+                # Check if any lora has matching hash
+                file_updated = False
+                for lora in recipe_data.get('loras', []):
+                    if 'hash' in lora and lora['hash'].lower() == hash_value:
+                        # Update file_name
+                        old_file_name = lora.get('file_name', '')
+                        lora['file_name'] = new_file_name
+                        file_updated = True
+                        logger.info(f"Updated file_name in recipe {recipe_path}: {old_file_name} -> {new_file_name}")
+                
+                # If updated, save the file
+                if file_updated:
+                    with open(recipe_path, 'w', encoding='utf-8') as f:
+                        json.dump(recipe_data, f, indent=4, ensure_ascii=False)
+                    file_updated_count += 1
+                    
+                    # Also update in cache if it exists
+                    if cache_initialized:
+                        recipe_id = recipe_data.get('id')
+                        if recipe_id:
+                            for cache_item in self._cache.raw_data:
+                                if cache_item.get('id') == recipe_id:
+                                    # Replace loras array with updated version
+                                    cache_item['loras'] = recipe_data['loras']
+                                    cache_updated_count += 1
+                                    break
+            
+            except Exception as e:
+                logger.error(f"Error updating recipe file {recipe_path}: {e}")
+                import traceback
+                traceback.print_exc(file=sys.stderr)
+        
+        # Resort cache if updates were made
+        if cache_initialized and cache_updated_count > 0:
+            await self._cache.resort()
+            logger.info(f"Resorted recipe cache after updating {cache_updated_count} items")
+            
+        return file_updated_count, cache_updated_count

py/utils/exif_utils.py

@@ -45,6 +45,63 @@ class ExifUtils:
                 
         except Exception as e:
             return None
+
+    @staticmethod
+    def extract_image_metadata(image_path: str) -> Optional[str]:
+        """Extract metadata from image including UserComment or parameters field
+        
+        Args:
+            image_path (str): Path to the image file
+            
+        Returns:
+            Optional[str]: Extracted metadata or None if not found
+        """
+        try:
+            # First try to open the image
+            with Image.open(image_path) as img:
+                # Method 1: Check for parameters in image info
+                if hasattr(img, 'info') and 'parameters' in img.info:
+                    return img.info['parameters']
+                
+                # Method 2: Check EXIF UserComment field
+                if img.format not in ['JPEG', 'TIFF', 'WEBP']:
+                    # For non-JPEG/TIFF/WEBP images, try to get EXIF through PIL
+                    exif = img._getexif()
+                    if exif and piexif.ExifIFD.UserComment in exif:
+                        user_comment = exif[piexif.ExifIFD.UserComment]
+                        if isinstance(user_comment, bytes):
+                            if user_comment.startswith(b'UNICODE\0'):
+                                return user_comment[8:].decode('utf-16be')
+                            return user_comment.decode('utf-8', errors='ignore')
+                        return user_comment
+                
+                # For JPEG/TIFF/WEBP, use piexif
+                try:
+                    exif_dict = piexif.load(image_path)
+                    
+                    if piexif.ExifIFD.UserComment in exif_dict.get('Exif', {}):
+                        user_comment = exif_dict['Exif'][piexif.ExifIFD.UserComment]
+                        if isinstance(user_comment, bytes):
+                            if user_comment.startswith(b'UNICODE\0'):
+                                user_comment = user_comment[8:].decode('utf-16be')
+                            else:
+                                user_comment = user_comment.decode('utf-8', errors='ignore')
+                        return user_comment
+                except Exception as e:
+                    logger.debug(f"Error loading EXIF data: {e}")
+                
+                # Method 3: Check PNG metadata for workflow info (for ComfyUI images)
+                if img.format == 'PNG':
+                    # Look for workflow or prompt metadata in PNG chunks
+                    for key in img.info:
+                        if key in ['workflow', 'prompt', 'parameters']:
+                            return img.info[key]
+                
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error extracting image metadata: {e}", exc_info=True)
+            return None
     
     @staticmethod
     def update_user_comment(image_path: str, user_comment: str) -> str:
@@ -92,18 +149,78 @@ class ExifUtils:
         except Exception as e:
             logger.error(f"Error updating EXIF data in {image_path}: {e}")
             return image_path
+
+    @staticmethod
+    def update_image_metadata(image_path: str, metadata: str) -> str:
+        """Update metadata in image's EXIF data or parameters fields
+        
+        Args:
+            image_path (str): Path to the image file
+            metadata (str): Metadata string to save
+            
+        Returns:
+            str: Path to the updated image
+        """
+        try:
+            # Load the image and check its format
+            with Image.open(image_path) as img:
+                img_format = img.format
+                
+                # For PNG, try to update parameters directly
+                if img_format == 'PNG':
+                    # We'll save with parameters in the PNG info
+                    info_dict = {'parameters': metadata}
+                    img.save(image_path, format='PNG', pnginfo=info_dict)
+                    return image_path
+                
+                # For WebP format, use PIL's exif parameter directly
+                elif img_format == 'WEBP':
+                    exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
+                    exif_bytes = piexif.dump(exif_dict)
+                    
+                    # Save with the exif data
+                    img.save(image_path, format='WEBP', exif=exif_bytes, quality=85)
+                    return image_path
+                
+                # For other formats, use standard EXIF approach
+                else:
+                    try:
+                        exif_dict = piexif.load(img.info.get('exif', b''))
+                    except:
+                        exif_dict = {'0th':{}, 'Exif':{}, 'GPS':{}, 'Interop':{}, '1st':{}}
+                    
+                    # If no Exif dictionary exists, create one
+                    if 'Exif' not in exif_dict:
+                        exif_dict['Exif'] = {}
+                    
+                    # Update the UserComment field - use UNICODE format
+                    unicode_bytes = metadata.encode('utf-16be')
+                    metadata_bytes = b'UNICODE\0' + unicode_bytes
+                    
+                    exif_dict['Exif'][piexif.ExifIFD.UserComment] = metadata_bytes
+                    
+                    # Convert EXIF dict back to bytes
+                    exif_bytes = piexif.dump(exif_dict)
+                    
+                    # Save the image with updated EXIF data
+                    img.save(image_path, exif=exif_bytes)
+                    
+            return image_path
+        except Exception as e:
+            logger.error(f"Error updating metadata in {image_path}: {e}")
+            return image_path
             
     @staticmethod
     def append_recipe_metadata(image_path, recipe_data) -> str:
         """Append recipe metadata to an image's EXIF data"""
         try:
-            # First, extract existing user comment
-            user_comment = ExifUtils.extract_user_comment(image_path)
+            # First, extract existing metadata
+            metadata = ExifUtils.extract_image_metadata(image_path)
             
-            # Check if there's already recipe metadata in the user comment
-            if user_comment:
+            # Check if there's already recipe metadata
+            if metadata:
                 # Remove any existing recipe metadata
-                user_comment = ExifUtils.remove_recipe_metadata(user_comment)
+                metadata = ExifUtils.remove_recipe_metadata(metadata)
             
             # Prepare simplified loras data
             simplified_loras = []
@@ -133,11 +250,11 @@ class ExifUtils:
             # Create the recipe metadata marker
             recipe_metadata_marker = f"Recipe metadata: {recipe_metadata_json}"
             
-            # Append to existing user comment or create new one
-            new_user_comment = f"{user_comment} \n {recipe_metadata_marker}" if user_comment else recipe_metadata_marker
+            # Append to existing metadata or create new one
+            new_metadata = f"{metadata} \n {recipe_metadata_marker}" if metadata else recipe_metadata_marker
             
             # Write back to the image
-            return ExifUtils.update_user_comment(image_path, new_user_comment)
+            return ExifUtils.update_image_metadata(image_path, new_metadata)
         except Exception as e:
             logger.error(f"Error appending recipe metadata: {e}", exc_info=True)
             return image_path
@@ -184,11 +301,11 @@ class ExifUtils:
         """
         try:
             # Extract metadata if needed
-            user_comment = None
+            metadata = None
             if preserve_metadata:
                 if isinstance(image_data, str) and os.path.exists(image_data):
                     # It's a file path
-                    user_comment = ExifUtils.extract_user_comment(image_data)
+                    metadata = ExifUtils.extract_image_metadata(image_data)
                     img = Image.open(image_data)
                 else:
                     # It's binary data
@@ -199,7 +316,7 @@ class ExifUtils:
                     with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp_file:
                         temp_path = temp_file.name
                         temp_file.write(image_data)
-                    user_comment = ExifUtils.extract_user_comment(temp_path)
+                    metadata = ExifUtils.extract_image_metadata(temp_path)
                     os.unlink(temp_path)
             else:
                 # Just open the image without extracting metadata
@@ -239,14 +356,14 @@ class ExifUtils:
             optimized_data = output.getvalue()
             
             # If we need to preserve metadata, write it to a temporary file
-            if preserve_metadata and user_comment:
+            if preserve_metadata and metadata:
                 # For WebP format, we'll directly save with metadata
                 if format.lower() == 'webp':
                     # Create a new BytesIO with metadata
                     output_with_metadata = BytesIO()
                     
                     # Create EXIF data with user comment
-                    exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + user_comment.encode('utf-16be')}}
+                    exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
                     exif_bytes = piexif.dump(exif_dict)
                     
                     # Save with metadata
@@ -260,7 +377,7 @@ class ExifUtils:
                         temp_file.write(optimized_data)
                     
                     # Add the metadata back
-                    ExifUtils.update_user_comment(temp_path, user_comment)
+                    ExifUtils.update_image_metadata(temp_path, metadata)
                     
                     # Read the file with metadata
                     with open(temp_path, 'rb') as f:
@@ -466,14 +583,14 @@ class ExifUtils:
                                 workflow_data = img.info[key]
                                 break
                 
-                # If no workflow data found in PNG chunks, try EXIF as fallback
+                # If no workflow data found in PNG chunks, try extract_image_metadata as fallback
                 if not workflow_data:
-                    user_comment = ExifUtils.extract_user_comment(image_path)
-                    if user_comment and '{' in user_comment and '}' in user_comment:
+                    metadata = ExifUtils.extract_image_metadata(image_path)
+                    if metadata and '{' in metadata and '}' in metadata:
                         # Try to extract JSON part
-                        json_start = user_comment.find('{')
-                        json_end = user_comment.rfind('}') + 1
-                        workflow_data = user_comment[json_start:json_end]
+                        json_start = metadata.find('{')
+                        json_end = metadata.rfind('}') + 1
+                        workflow_data = metadata[json_start:json_end]
                 
                 # Parse workflow data if found
                 if workflow_data:

py/utils/file_utils.py

@@ -19,7 +19,7 @@ async def calculate_sha256(file_path: str) -> str:
             sha256_hash.update(byte_block)
     return sha256_hash.hexdigest()
 
-def _find_preview_file(base_name: str, dir_path: str) -> str:
+def find_preview_file(base_name: str, dir_path: str) -> str:
     """Find preview file for given base name in directory"""
     preview_patterns = [
         f"{base_name}.preview.png",
@@ -56,16 +56,33 @@ async def get_file_info(file_path: str) -> Optional[LoraMetadata]:
     base_name = os.path.splitext(os.path.basename(file_path))[0]
     dir_path = os.path.dirname(file_path)
     
-    preview_url = _find_preview_file(base_name, dir_path)
+    preview_url = find_preview_file(base_name, dir_path)
+    
+    # Check if a .json file exists with SHA256 hash to avoid recalculation
+    json_path = f"{os.path.splitext(file_path)[0]}.json"
+    sha256 = None
+    if os.path.exists(json_path):
+        try:
+            with open(json_path, 'r', encoding='utf-8') as f:
+                json_data = json.load(f)
+                if 'sha256' in json_data:
+                    sha256 = json_data['sha256'].lower()
+                    logger.debug(f"Using SHA256 from .json file for {file_path}")
+        except Exception as e:
+            logger.error(f"Error reading .json file for {file_path}: {e}")
 
     try:
+        # If we didn't get SHA256 from the .json file, calculate it
+        if not sha256:
+            sha256 = await calculate_sha256(real_path)
+            
         metadata = LoraMetadata(
             file_name=base_name,
             model_name=base_name,
             file_path=normalize_path(file_path),
             size=os.path.getsize(real_path),
             modified=os.path.getmtime(real_path),
-            sha256=await calculate_sha256(real_path),
+            sha256=sha256,
             base_model="Unknown",  # Will be updated later
             usage_tips="",
             notes="",
@@ -125,7 +142,7 @@ async def load_metadata(file_path: str) -> Optional[LoraMetadata]:
                 if not preview_url or not os.path.exists(preview_url):
                     base_name = os.path.splitext(os.path.basename(file_path))[0]
                     dir_path = os.path.dirname(file_path)
-                    new_preview_url = normalize_path(_find_preview_file(base_name, dir_path))
+                    new_preview_url = normalize_path(find_preview_file(base_name, dir_path))
                     if new_preview_url != preview_url:
                         data['preview_url'] = new_preview_url
                         needs_update = True

py/utils/recipe_parsers.py

@@ -44,6 +44,138 @@ class RecipeMetadataParser(ABC):
             Dict containing parsed recipe data with standardized format
         """
         pass
+    
+    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info: Dict[str, Any], 
+                                         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
+            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
+            
+        Returns:
+            The populated lora_entry dict
+        """
+        try:
+            if civitai_info and civitai_info.get("error") != "Model not found":
+                # Check if this is an early access lora
+                if civitai_info.get('earlyAccessEndsAt'):
+                    # Convert earlyAccessEndsAt to a human-readable date
+                    early_access_date = civitai_info.get('earlyAccessEndsAt', '')
+                    lora_entry['isEarlyAccess'] = True
+                    lora_entry['earlyAccessEndsAt'] = early_access_date
+                
+                # Update model name if available
+                if 'model' in civitai_info and 'name' in civitai_info['model']:
+                    lora_entry['name'] = civitai_info['model']['name']
+                
+                # Update version if available
+                if 'name' in civitai_info:
+                    lora_entry['version'] = civitai_info.get('name', '')
+                
+                # Get thumbnail URL from first image
+                if 'images' in civitai_info and civitai_info['images']:
+                    lora_entry['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
+                
+                # Get base model
+                current_base_model = civitai_info.get('baseModel', '')
+                lora_entry['baseModel'] = current_base_model
+                
+                # Update base model counts if tracking them
+                if base_model_counts is not None and current_base_model:
+                    base_model_counts[current_base_model] = base_model_counts.get(current_base_model, 0) + 1
+                
+                # Get download URL
+                lora_entry['downloadUrl'] = civitai_info.get('downloadUrl', '')
+                
+                # Process file information if available
+                if 'files' in civitai_info:
+                    model_file = next((file for file in civitai_info.get('files', []) 
+                                    if file.get('type') == 'Model'), None)
+                    
+                    if model_file:
+                        # Get size
+                        lora_entry['size'] = model_file.get('sizeKB', 0) * 1024
+                        
+                        # Get SHA256 hash
+                        sha256 = model_file.get('hashes', {}).get('SHA256', hash_value)
+                        if sha256:
+                            lora_entry['hash'] = sha256.lower()
+                        
+                        # Check if exists locally
+                        if recipe_scanner and lora_entry['hash']:
+                            lora_scanner = recipe_scanner._lora_scanner
+                            exists_locally = lora_scanner.has_lora_hash(lora_entry['hash'])
+                            if exists_locally:
+                                try:
+                                    local_path = lora_scanner.get_lora_path_by_hash(lora_entry['hash'])
+                                    lora_entry['existsLocally'] = True
+                                    lora_entry['localPath'] = local_path
+                                    lora_entry['file_name'] = os.path.splitext(os.path.basename(local_path))[0]
+                                    
+                                    # Get thumbnail from local preview if available
+                                    lora_cache = await lora_scanner.get_cached_data()
+                                    lora_item = next((item for item in lora_cache.raw_data 
+                                                     if item['sha256'].lower() == lora_entry['hash'].lower()), None)
+                                    if lora_item and 'preview_url' in lora_item:
+                                        lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
+                                except Exception as e:
+                                    logger.error(f"Error getting local lora path: {e}")
+                            else:
+                                # For missing LoRAs, get file_name from model_file.name
+                                file_name = model_file.get('name', '')
+                                lora_entry['file_name'] = os.path.splitext(file_name)[0] if file_name else ''
+            else:
+                # Model not found or deleted
+                lora_entry['isDeleted'] = True
+                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                
+        except Exception as e:
+            logger.error(f"Error populating lora from Civitai info: {e}")
+            
+        return lora_entry
+        
+    async def populate_checkpoint_from_civitai(self, checkpoint: Dict[str, Any], civitai_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Populate checkpoint information from Civitai API response
+        
+        Args:
+            checkpoint: The checkpoint entry to populate
+            civitai_info: The response from Civitai API
+            
+        Returns:
+            The populated checkpoint dict
+        """
+        try:
+            if civitai_info and civitai_info.get("error") != "Model not found":
+                # Update model name if available
+                if 'model' in civitai_info and 'name' in civitai_info['model']:
+                    checkpoint['name'] = civitai_info['model']['name']
+                
+                # Update version if available
+                if 'name' in civitai_info:
+                    checkpoint['version'] = civitai_info.get('name', '')
+                
+                # Get thumbnail URL from first image
+                if 'images' in civitai_info and civitai_info['images']:
+                    checkpoint['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
+                
+                # Get base model
+                checkpoint['baseModel'] = civitai_info.get('baseModel', '')
+                
+                # Get download URL
+                checkpoint['downloadUrl'] = civitai_info.get('downloadUrl', '')
+            else:
+                # Model not found or deleted
+                checkpoint['isDeleted'] = True
+        except Exception as e:
+            logger.error(f"Error populating checkpoint from Civitai info: {e}")
+            
+        return checkpoint
 
 
 class RecipeFormatParser(RecipeMetadataParser):
@@ -110,33 +242,14 @@ class RecipeFormatParser(RecipeMetadataParser):
                         if lora.get('modelVersionId') and civitai_client:
                             try:
                                 civitai_info = await civitai_client.get_model_version_info(lora['modelVersionId'])
-                                if civitai_info and civitai_info.get("error") != "Model not found":
-                                    # Check if this is an early access lora
-                                    if civitai_info.get('earlyAccessEndsAt'):
-                                        # Convert earlyAccessEndsAt to a human-readable date
-                                        early_access_date = civitai_info.get('earlyAccessEndsAt', '')
-                                        lora_entry['isEarlyAccess'] = True
-                                        lora_entry['earlyAccessEndsAt'] = early_access_date
-                                    
-                                    # Get thumbnail URL from first image
-                                    if 'images' in civitai_info and civitai_info['images']:
-                                        lora_entry['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
-                                    
-                                    # Get base model
-                                    lora_entry['baseModel'] = civitai_info.get('baseModel', '')
-                                    
-                                    # Get download URL
-                                    lora_entry['downloadUrl'] = civitai_info.get('downloadUrl', '')
-                                    
-                                    # Get size from files if available
-                                    if 'files' in civitai_info:
-                                        model_file = next((file for file in civitai_info.get('files', []) 
-                                                        if file.get('type') == 'Model'), None)
-                                        if model_file:
-                                            lora_entry['size'] = model_file.get('sizeKB', 0) * 1024
-                                else:
-                                    lora_entry['isDeleted'] = True
-                                    lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                                # Populate lora entry with Civitai info
+                                lora_entry = await self.populate_lora_from_civitai(
+                                    lora_entry, 
+                                    civitai_info, 
+                                    recipe_scanner,
+                                    None,  # No need to track base model counts
+                                    lora['hash']
+                                )
                             except Exception as e:
                                 logger.error(f"Error fetching Civitai info for LoRA: {e}")
                                 lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
@@ -222,57 +335,16 @@ class StandardMetadataParser(RecipeMetadataParser):
                 
                 # Get additional info from Civitai if client is available
                 if civitai_client:
-                    civitai_info = await civitai_client.get_model_version_info(model_version_id)
-
-                    # Check if this LoRA exists locally by SHA256 hash
-                    if civitai_info and civitai_info.get("error") != "Model not found":
-                        # Check if this is an early access lora
-                        if civitai_info.get('earlyAccessEndsAt'):
-                            # Convert earlyAccessEndsAt to a human-readable date
-                            early_access_date = civitai_info.get('earlyAccessEndsAt', '')
-                            lora_entry['isEarlyAccess'] = True
-                            lora_entry['earlyAccessEndsAt'] = early_access_date
-                        
-                        # LoRA exists on Civitai, process its information
-                        if 'files' in civitai_info:
-                            # Find the model file (type="Model") in the files list
-                            model_file = next((file for file in civitai_info.get('files', []) 
-                                            if file.get('type') == 'Model'), None)
-                            
-                            if model_file and recipe_scanner:
-                                sha256 = model_file.get('hashes', {}).get('SHA256', '')
-                                if sha256:
-                                    lora_scanner = recipe_scanner._lora_scanner
-                                    exists_locally = lora_scanner.has_lora_hash(sha256)
-                                    if exists_locally:
-                                        local_path = lora_scanner.get_lora_path_by_hash(sha256)
-                                        lora_entry['existsLocally'] = True
-                                        lora_entry['localPath'] = local_path
-                                        lora_entry['file_name'] = os.path.splitext(os.path.basename(local_path))[0]
-                                    else:
-                                        # For missing LoRAs, get file_name from model_file.name
-                                        file_name = model_file.get('name', '')
-                                        lora_entry['file_name'] = os.path.splitext(file_name)[0] if file_name else ''
-                                
-                                lora_entry['hash'] = sha256
-                                lora_entry['size'] = model_file.get('sizeKB', 0) * 1024
-                        
-                        # Get thumbnail URL from first image
-                        if 'images' in civitai_info and civitai_info['images']:
-                            lora_entry['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
-                        
-                        # Get base model and update counts
-                        current_base_model = civitai_info.get('baseModel', '')
-                        lora_entry['baseModel'] = current_base_model
-                        if current_base_model:
-                            base_model_counts[current_base_model] = base_model_counts.get(current_base_model, 0) + 1
-                        
-                        # Get download URL
-                        lora_entry['downloadUrl'] = civitai_info.get('downloadUrl', '')
-                    else:
-                        # LoRA is deleted from Civitai or not found
-                        lora_entry['isDeleted'] = True
-                        lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                    try:
+                        civitai_info = 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
+                        )
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA: {e}")
                 
                 loras.append(lora_entry)
             
@@ -394,7 +466,9 @@ class A1111MetadataParser(RecipeMetadataParser):
             # Extract LoRA information from prompt
             lora_weights = {}
             lora_matches = re.findall(self.LORA_PATTERN, prompt)
-            for lora_name, weight in lora_matches:
+            for lora_name, weights in lora_matches:
+                # Take only the first strength value (before the colon)
+                weight = weights.split(':')[0]
                 lora_weights[lora_name.strip()] = float(weight.strip())
             
             # Remove LoRA patterns from prompt
@@ -436,61 +510,18 @@ class A1111MetadataParser(RecipeMetadataParser):
                     'isDeleted': False
                 }
                 
-                # Get info from Civitai by hash
-                if civitai_client:
+                # Get info from Civitai by hash if available
+                if civitai_client and hash_value:
                     try:
                         civitai_info = await civitai_client.get_model_by_hash(hash_value)
-                        if civitai_info and civitai_info.get("error") != "Model not found":
-                            # Check if this is an early access lora
-                            if civitai_info.get('earlyAccessEndsAt'):
-                                # Convert earlyAccessEndsAt to a human-readable date
-                                early_access_date = civitai_info.get('earlyAccessEndsAt', '')
-                                lora_entry['isEarlyAccess'] = True
-                                lora_entry['earlyAccessEndsAt'] = early_access_date
-                            
-                            # Get model version ID
-                            lora_entry['id'] = civitai_info.get('id', '')
-                            
-                            # Get model name and version
-                            lora_entry['name'] = civitai_info.get('model', {}).get('name', lora_name)
-                            lora_entry['version'] = civitai_info.get('name', '')
-                            
-                            # Get thumbnail URL
-                            if 'images' in civitai_info and civitai_info['images']:
-                                lora_entry['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
-                            
-                            # Get base model and update counts
-                            current_base_model = civitai_info.get('baseModel', '')
-                            lora_entry['baseModel'] = current_base_model
-                            if current_base_model:
-                                base_model_counts[current_base_model] = base_model_counts.get(current_base_model, 0) + 1
-                            
-                            # Get download URL
-                            lora_entry['downloadUrl'] = civitai_info.get('downloadUrl', '')
-                            
-                            # Get file name and size from Civitai
-                            if 'files' in civitai_info:
-                                model_file = next((file for file in civitai_info.get('files', []) 
-                                                if file.get('type') == 'Model'), None)
-                                if model_file:
-                                    file_name = model_file.get('name', '')
-                                    lora_entry['file_name'] = os.path.splitext(file_name)[0] if file_name else lora_name
-                                    lora_entry['size'] = model_file.get('sizeKB', 0) * 1024
-                                    # Update hash to sha256
-                                    lora_entry['hash'] = model_file.get('hashes', {}).get('SHA256', hash_value).lower()
-                                    
-                            # Check if exists locally with sha256 hash
-                            if recipe_scanner and lora_entry['hash']:
-                                lora_scanner = recipe_scanner._lora_scanner
-                                exists_locally = lora_scanner.has_lora_hash(lora_entry['hash'])
-                                if exists_locally:
-                                    lora_cache = await lora_scanner.get_cached_data()
-                                    lora_item = next((item for item in lora_cache.raw_data if item['sha256'] == lora_entry['hash']), None)
-                                    if lora_item:
-                                        lora_entry['existsLocally'] = True
-                                        lora_entry['localPath'] = lora_item['file_path']
-                                        lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
-                                        
+                        # Populate lora entry with Civitai info
+                        lora_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info, 
+                            recipe_scanner,
+                            base_model_counts,
+                            hash_value
+                        )
                     except Exception as e:
                         logger.error(f"Error fetching Civitai info for LoRA hash {hash_value}: {e}")
                 
@@ -523,6 +554,499 @@ class A1111MetadataParser(RecipeMetadataParser):
             return {"error": str(e), "loras": []}
 
 
+class ComfyMetadataParser(RecipeMetadataParser):
+    """Parser for Civitai ComfyUI metadata JSON format"""
+    
+    METADATA_MARKER = r"class_type"
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the ComfyUI metadata format"""
+        try:
+            data = json.loads(user_comment)
+            # Check if it contains class_type nodes typical of ComfyUI workflow
+            return isinstance(data, dict) and any(isinstance(v, dict) and 'class_type' in v for v in data.values())
+        except (json.JSONDecodeError, TypeError):
+            return False
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from Civitai ComfyUI metadata format"""
+        try:
+            data = json.loads(user_comment)
+            loras = []
+            
+            # Find all LoraLoader nodes
+            lora_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'LoraLoader'}
+            
+            if not lora_nodes:
+                return {"error": "No LoRA information found in this ComfyUI workflow", "loras": []}
+            
+            # Process each LoraLoader node
+            for node_id, node in lora_nodes.items():
+                if 'inputs' not in node or 'lora_name' not in node['inputs']:
+                    continue
+                    
+                lora_name = node['inputs'].get('lora_name', '')
+                
+                # Parse the URN to extract model ID and version ID
+                # Format: "urn:air:sdxl:lora:civitai:1107767@1253442"
+                lora_id_match = re.search(r'civitai:(\d+)@(\d+)', lora_name)
+                if not lora_id_match:
+                    continue
+                    
+                model_id = lora_id_match.group(1)
+                model_version_id = lora_id_match.group(2)
+                
+                # Get strength from node inputs
+                weight = node['inputs'].get('strength_model', 1.0)
+                
+                # Initialize lora entry with default values
+                lora_entry = {
+                    'id': model_version_id,
+                    'modelId': model_id,
+                    'name': f"Lora {model_id}",  # Default name
+                    'version': '',
+                    'type': 'lora',
+                    'weight': weight,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': '',
+                    'hash': '',
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+                
+                # 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)
+                        # Populate lora entry with Civitai info
+                        lora_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info, 
+                            recipe_scanner
+                        )
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA: {e}")
+                
+                loras.append(lora_entry)
+            
+            # Find checkpoint info
+            checkpoint_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'CheckpointLoaderSimple'}
+            checkpoint = None
+            checkpoint_id = None
+            checkpoint_version_id = None
+            
+            if checkpoint_nodes:
+                # Get the first checkpoint node
+                checkpoint_node = next(iter(checkpoint_nodes.values()))
+                if 'inputs' in checkpoint_node and 'ckpt_name' in checkpoint_node['inputs']:
+                    checkpoint_name = checkpoint_node['inputs']['ckpt_name']
+                    # Parse checkpoint URN
+                    checkpoint_match = re.search(r'civitai:(\d+)@(\d+)', checkpoint_name)
+                    if checkpoint_match:
+                        checkpoint_id = checkpoint_match.group(1)
+                        checkpoint_version_id = checkpoint_match.group(2)
+                        checkpoint = {
+                            'id': checkpoint_version_id,
+                            'modelId': checkpoint_id,
+                            'name': f"Checkpoint {checkpoint_id}",
+                            'version': '',
+                            'type': 'checkpoint'
+                        }
+                        
+                        # Get additional checkpoint info from Civitai
+                        if civitai_client:
+                            try:
+                                civitai_info = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                # Populate checkpoint with Civitai info
+                                checkpoint = await self.populate_checkpoint_from_civitai(checkpoint, civitai_info)
+                            except Exception as e:
+                                logger.error(f"Error fetching Civitai info for checkpoint: {e}")
+            
+            # Extract generation parameters
+            gen_params = {}
+            
+            # First try to get from extraMetadata
+            if 'extraMetadata' in data:
+                try:
+                    # extraMetadata is a JSON string that needs to be parsed
+                    extra_metadata = json.loads(data['extraMetadata'])
+                    
+                    # Map fields from extraMetadata to our standard format
+                    mapping = {
+                        'prompt': 'prompt',
+                        'negativePrompt': 'negative_prompt',
+                        'steps': 'steps',
+                        'sampler': 'sampler',
+                        'cfgScale': 'cfg_scale',
+                        'seed': 'seed'
+                    }
+                    
+                    for src_key, dest_key in mapping.items():
+                        if src_key in extra_metadata:
+                            gen_params[dest_key] = extra_metadata[src_key]
+                    
+                    # If size info is available, format as "width x height"
+                    if 'width' in extra_metadata and 'height' in extra_metadata:
+                        gen_params['size'] = f"{extra_metadata['width']}x{extra_metadata['height']}"
+                    
+                except Exception as e:
+                    logger.error(f"Error parsing extraMetadata: {e}")
+            
+            # If extraMetadata doesn't have all the info, try to get from nodes
+            if not gen_params or len(gen_params) < 3:  # At least we want prompt, negative_prompt, and steps
+                # Find positive prompt node
+                positive_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and 
+                                v.get('class_type', '').endswith('CLIPTextEncode') and 
+                                v.get('_meta', {}).get('title') == 'Positive'}
+                
+                if positive_nodes:
+                    positive_node = next(iter(positive_nodes.values()))
+                    if 'inputs' in positive_node and 'text' in positive_node['inputs']:
+                        gen_params['prompt'] = positive_node['inputs']['text']
+                
+                # Find negative prompt node
+                negative_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and 
+                                v.get('class_type', '').endswith('CLIPTextEncode') and 
+                                v.get('_meta', {}).get('title') == 'Negative'}
+                
+                if negative_nodes:
+                    negative_node = next(iter(negative_nodes.values()))
+                    if 'inputs' in negative_node and 'text' in negative_node['inputs']:
+                        gen_params['negative_prompt'] = negative_node['inputs']['text']
+                
+                # Find KSampler node for other parameters
+                ksampler_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'KSampler'}
+                
+                if ksampler_nodes:
+                    ksampler_node = next(iter(ksampler_nodes.values()))
+                    if 'inputs' in ksampler_node:
+                        inputs = ksampler_node['inputs']
+                        if 'sampler_name' in inputs:
+                            gen_params['sampler'] = inputs['sampler_name']
+                        if 'steps' in inputs:
+                            gen_params['steps'] = inputs['steps']
+                        if 'cfg' in inputs:
+                            gen_params['cfg_scale'] = inputs['cfg']
+                        if 'seed' in inputs:
+                            gen_params['seed'] = inputs['seed']
+            
+            # Determine base model from loras info
+            base_model = None
+            if loras:
+                # Use the most common base model from loras
+                base_models = [lora['baseModel'] for lora in loras if lora.get('baseModel')]
+                if base_models:
+                    from collections import Counter
+                    base_model_counts = Counter(base_models)
+                    base_model = base_model_counts.most_common(1)[0][0]
+            
+            return {
+                'base_model': base_model,
+                'loras': loras,
+                'checkpoint': checkpoint,
+                'gen_params': gen_params,
+                'from_comfy_metadata': True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing ComfyUI metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}
+
+
+class MetaFormatParser(RecipeMetadataParser):
+    """Parser for images with meta format metadata (Lora_N Model hash format)"""
+    
+    METADATA_MARKER = r'Lora_\d+ Model hash:'
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the metadata format"""
+        return re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL) is not None
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from images with meta format metadata"""
+        try:
+            # Extract prompt and negative prompt
+            parts = user_comment.split('Negative prompt:', 1)
+            prompt = parts[0].strip()
+            
+            # Initialize metadata
+            metadata = {"prompt": prompt, "loras": []}
+            
+            # Extract negative prompt and parameters if available
+            if len(parts) > 1:
+                negative_and_params = parts[1]
+                
+                # Extract negative prompt - everything until the first parameter (usually "Steps:")
+                param_start = re.search(r'([A-Za-z]+): ', negative_and_params)
+                if param_start:
+                    neg_prompt = negative_and_params[:param_start.start()].strip()
+                    metadata["negative_prompt"] = neg_prompt
+                    params_section = negative_and_params[param_start.start():]
+                else:
+                    params_section = negative_and_params
+                
+                # Extract key-value parameters (Steps, Sampler, Seed, etc.)
+                param_pattern = r'([A-Za-z_0-9 ]+): ([^,]+)'
+                params = re.findall(param_pattern, params_section)
+                for key, value in params:
+                    clean_key = key.strip().lower().replace(' ', '_')
+                    metadata[clean_key] = value.strip()
+            
+            # Extract LoRA information
+            # Pattern to match lora entries: Lora_0 Model name: ArtVador I.safetensors, Lora_0 Model hash: 08f7133a58, etc.
+            lora_pattern = r'Lora_(\d+) Model name: ([^,]+), Lora_\1 Model hash: ([^,]+), Lora_\1 Strength model: ([^,]+), Lora_\1 Strength clip: ([^,]+)'
+            lora_matches = re.findall(lora_pattern, user_comment)
+            
+            # If the regular pattern doesn't match, try a more flexible approach
+            if not lora_matches:
+                # First find all Lora indices
+                lora_indices = set(re.findall(r'Lora_(\d+)', user_comment))
+                
+                # For each index, extract the information
+                for idx in lora_indices:
+                    lora_info = {}
+                    
+                    # Extract model name
+                    name_match = re.search(f'Lora_{idx} Model name: ([^,]+)', user_comment)
+                    if name_match:
+                        lora_info['name'] = name_match.group(1).strip()
+                    
+                    # Extract model hash
+                    hash_match = re.search(f'Lora_{idx} Model hash: ([^,]+)', user_comment)
+                    if hash_match:
+                        lora_info['hash'] = hash_match.group(1).strip()
+                    
+                    # Extract strength model
+                    strength_model_match = re.search(f'Lora_{idx} Strength model: ([^,]+)', user_comment)
+                    if strength_model_match:
+                        lora_info['strength_model'] = float(strength_model_match.group(1).strip())
+                    
+                    # Extract strength clip
+                    strength_clip_match = re.search(f'Lora_{idx} Strength clip: ([^,]+)', user_comment)
+                    if strength_clip_match:
+                        lora_info['strength_clip'] = float(strength_clip_match.group(1).strip())
+                    
+                    # Only add if we have at least name and hash
+                    if 'name' in lora_info and 'hash' in lora_info:
+                        lora_matches.append((idx, lora_info['name'], lora_info['hash'], 
+                                            str(lora_info.get('strength_model', 1.0)), 
+                                            str(lora_info.get('strength_clip', 1.0))))
+            
+            # Process LoRAs
+            base_model_counts = {}
+            loras = []
+            
+            for match in lora_matches:
+                if len(match) == 5:  # Regular pattern match
+                    idx, name, hash_value, strength_model, strength_clip = match
+                else:  # Flexible approach match
+                    continue  # Should not happen now
+                
+                # Clean up the values
+                name = name.strip()
+                if name.endswith('.safetensors'):
+                    name = name[:-12]  # Remove .safetensors extension
+                    
+                hash_value = hash_value.strip()
+                weight = float(strength_model)  # Use model strength as weight
+                
+                # Initialize lora entry with default values
+                lora_entry = {
+                    'name': name,
+                    'type': 'lora',
+                    'weight': weight,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': name,
+                    'hash': hash_value,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+                
+                # Get info from Civitai by hash if available
+                if civitai_client and hash_value:
+                    try:
+                        civitai_info = await civitai_client.get_model_by_hash(hash_value)
+                        # Populate lora entry with Civitai info
+                        lora_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info, 
+                            recipe_scanner,
+                            base_model_counts,
+                            hash_value
+                        )
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA hash {hash_value}: {e}")
+                
+                loras.append(lora_entry)
+            
+            # Extract model information
+            model = None
+            if 'model' in metadata:
+                model = metadata['model']
+            
+            # Set base_model to the most common one from civitai_info
+            base_model = None
+            if base_model_counts:
+                base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
+            
+            # Extract generation parameters for recipe metadata
+            gen_params = {}
+            for key in GEN_PARAM_KEYS:
+                if key in metadata:
+                    gen_params[key] = metadata.get(key, '')
+            
+            # Try to extract size information if available
+            if 'width' in metadata and 'height' in metadata:
+                gen_params['size'] = f"{metadata['width']}x{metadata['height']}"
+            
+            return {
+                'base_model': base_model,
+                'loras': loras,
+                'gen_params': gen_params,
+                'raw_metadata': metadata,
+                'from_meta_format': True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing meta format metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}
+
+
+class ImageSaverMetadataParser(RecipeMetadataParser):
+    """Parser for ComfyUI Image Saver plugin metadata format"""
+    
+    METADATA_MARKER = r'Hashes: \{"LORA:'
+    LORA_PATTERN = r'<lora:([^:]+):([^>]+)>'
+    HASH_PATTERN = r'Hashes: (\{.*?\})'
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the Image Saver metadata format"""
+        return re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL) is not None
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from Image Saver plugin format"""
+        try:
+            # Extract prompt and negative prompt
+            parts = user_comment.split('Negative prompt:', 1)
+            prompt = parts[0].strip()
+            
+            # Initialize metadata
+            metadata = {"prompt": prompt, "loras": []}
+            
+            # Extract negative prompt and parameters
+            if len(parts) > 1:
+                negative_and_params = parts[1]
+                
+                # Extract negative prompt
+                if "Steps:" in negative_and_params:
+                    neg_prompt = negative_and_params.split("Steps:", 1)[0].strip()
+                    metadata["negative_prompt"] = neg_prompt
+                
+                # Extract key-value parameters (Steps, Sampler, CFG scale, etc.)
+                param_pattern = r'([A-Za-z ]+): ([^,]+)'
+                params = re.findall(param_pattern, negative_and_params)
+                for key, value in params:
+                    clean_key = key.strip().lower().replace(' ', '_')
+                    metadata[clean_key] = value.strip()
+            
+            # Extract LoRA information from prompt
+            lora_weights = {}
+            lora_matches = re.findall(self.LORA_PATTERN, prompt)
+            for lora_name, weight in lora_matches:
+                lora_weights[lora_name.strip()] = float(weight.split(':')[0].strip())
+            
+            # Remove LoRA patterns from prompt
+            metadata["prompt"] = re.sub(self.LORA_PATTERN, '', prompt).strip()
+            
+            # Extract LoRA hashes from Hashes section
+            lora_hashes = {}
+            hash_match = re.search(self.HASH_PATTERN, user_comment)
+            if hash_match:
+                try:
+                    hashes = json.loads(hash_match.group(1))
+                    for key, hash_value in hashes.items():
+                        if key.startswith('LORA:'):
+                            lora_name = key[5:]  # Remove 'LORA:' prefix
+                            lora_hashes[lora_name] = hash_value.strip()
+                except json.JSONDecodeError:
+                    pass
+            
+            # Process LoRAs and collect base models
+            base_model_counts = {}
+            loras = []
+            
+            # Process each LoRA with hash and weight
+            for lora_name, hash_value in lora_hashes.items():
+                weight = lora_weights.get(lora_name, 1.0)
+                
+                # Initialize lora entry with default values
+                lora_entry = {
+                    'name': lora_name,
+                    'type': 'lora',
+                    'weight': weight,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': lora_name,
+                    'hash': hash_value,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+                
+                # Get info from Civitai by hash if available
+                if civitai_client and hash_value:
+                    try:
+                        civitai_info = await civitai_client.get_model_by_hash(hash_value)
+                        # Populate lora entry with Civitai info
+                        lora_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info, 
+                            recipe_scanner,
+                            base_model_counts,
+                            hash_value
+                        )
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA hash {hash_value}: {e}")
+                
+                loras.append(lora_entry)
+
+            # Set base_model to the most common one from civitai_info
+            base_model = None
+            if base_model_counts:
+                base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
+            
+            # Extract generation parameters for recipe metadata
+            gen_params = {}
+            for key in GEN_PARAM_KEYS:
+                if key in metadata:
+                    gen_params[key] = metadata.get(key, '')
+            
+            # Add model information if available
+            if 'model' in metadata:
+                gen_params['checkpoint'] = metadata['model']
+            
+            return {
+                'base_model': base_model,
+                'loras': loras,
+                'gen_params': gen_params,
+                'raw_metadata': metadata
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing Image Saver metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}
+
+
 class RecipeParserFactory:
     """Factory for creating recipe metadata parsers"""
     
@@ -537,11 +1061,23 @@ class RecipeParserFactory:
         Returns:
             Appropriate RecipeMetadataParser implementation
         """
+        # Try ComfyMetadataParser first since it requires valid JSON
+        try:
+            if ComfyMetadataParser().is_metadata_matching(user_comment):
+                return ComfyMetadataParser()
+        except Exception:
+            # If JSON parsing fails, move on to other parsers
+            pass
+            
         if RecipeFormatParser().is_metadata_matching(user_comment):
             return RecipeFormatParser()
         elif StandardMetadataParser().is_metadata_matching(user_comment):
             return StandardMetadataParser()
         elif A1111MetadataParser().is_metadata_matching(user_comment):
             return A1111MetadataParser()
+        elif MetaFormatParser().is_metadata_matching(user_comment):
+            return MetaFormatParser()
+        elif ImageSaverMetadataParser().is_metadata_matching(user_comment):
+            return ImageSaverMetadataParser()
         else:
-            return None
+            return None

py/utils/utils.py

@@ -40,7 +40,45 @@ def download_twitter_image(url):
     except Exception as e:
         print(f"Error downloading twitter image: {e}")
         return None
+
+def download_civitai_image(url):
+    """Download image from a URL containing avatar image with specific class and style attributes
     
+    Args:
+        url (str): The URL to download image from
+        
+    Returns:
+        str: Path to downloaded temporary image file
+    """
+    try:
+        # Download page content
+        response = requests.get(url)
+        response.raise_for_status()
+        
+        # Parse HTML
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Find image with specific class and style attributes
+        image = soup.select_one('img.EdgeImage_image__iH4_q.max-h-full.w-auto.max-w-full')
+        
+        if not image or 'src' not in image.attrs:
+            return None
+            
+        image_url = image['src']
+        
+        # Download image
+        image_response = requests.get(image_url)
+        image_response.raise_for_status()
+        
+        # Save to temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
+            temp_file.write(image_response.content)
+            return temp_file.name
+            
+    except Exception as e:
+        print(f"Error downloading civitai avatar: {e}")
+        return None
+
 def fuzzy_match(text: str, pattern: str, threshold: float = 0.7) -> bool:
         """
         Check if text matches pattern using fuzzy matching.

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.0"
+version = "0.8.2"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",

refs/civitai_api_model_by_versionId.json

@@ -95,7 +95,6 @@
             "onSite": false,
             "remixOfId": null
         }
-        // more images here
     ],
     "downloadUrl": "https://civitai.com/api/download/models/1387174"
 }

refs/civitai_comfy_metadata.json

@@ -0,0 +1,153 @@
+{
+    "resource-stack": {
+      "class_type": "CheckpointLoaderSimple",
+      "inputs": { "ckpt_name": "urn:air:sdxl:checkpoint:civitai:827184@1410435" }
+    },
+    "resource-stack-1": {
+      "class_type": "LoraLoader",
+      "inputs": {
+        "lora_name": "urn:air:sdxl:lora:civitai:1107767@1253442",
+        "strength_model": 1,
+        "strength_clip": 1,
+        "model": ["resource-stack", 0],
+        "clip": ["resource-stack", 1]
+      }
+    },
+    "resource-stack-2": {
+      "class_type": "LoraLoader",
+      "inputs": {
+        "lora_name": "urn:air:sdxl:lora:civitai:1342708@1516344",
+        "strength_model": 1,
+        "strength_clip": 1,
+        "model": ["resource-stack-1", 0],
+        "clip": ["resource-stack-1", 1]
+      }
+    },
+    "resource-stack-3": {
+      "class_type": "LoraLoader",
+      "inputs": {
+        "lora_name": "urn:air:sdxl:lora:civitai:122359@135867",
+        "strength_model": 1.55,
+        "strength_clip": 1,
+        "model": ["resource-stack-2", 0],
+        "clip": ["resource-stack-2", 1]
+      }
+    },
+    "6": {
+      "class_type": "smZ CLIPTextEncode",
+      "inputs": {
+        "text": "masterpiece, best quality, amazing quality, detailed setting, detailed background, 1girl, yunyun (konosuba), nude, red eyes, hair ornament, braid, hair between eyes,low twintails, pink ribbon, bow, hair bow, pussy, frilled skirt, layered skirt, belt, pink thighhighs, (pussy juice), large insertion, vaginal tugging, pussy grip, detailed skin, detailed soles, stretched pussy, feet in stockings, ass, nipples, medium breasts, french kiss, anus, shocked, nervous, penis awe,  BREAK Professor\u0027s office, college student, pornographic, 1boy, close eyes, (musscular male, detailed large cock), vaginal sex, college office setting, ass grab, fucking, riding, cowgirl, erotic, side view, deep fucking",
+        "parser": "comfy",
+        "text_g": "",
+        "text_l": "",
+        "ascore": 2.5,
+        "width": 0,
+        "height": 0,
+        "crop_w": 0,
+        "crop_h": 0,
+        "target_width": 0,
+        "target_height": 0,
+        "smZ_steps": 1,
+        "mean_normalization": true,
+        "multi_conditioning": true,
+        "use_old_emphasis_implementation": false,
+        "with_SDXL": false,
+        "clip": ["resource-stack-3", 1]
+      },
+      "_meta": { "title": "Positive" }
+    },
+    "7": {
+      "class_type": "smZ CLIPTextEncode",
+      "inputs": {
+        "text": "bad quality,worst quality,worst detail,sketch,censor",
+        "parser": "comfy",
+        "text_g": "",
+        "text_l": "",
+        "ascore": 2.5,
+        "width": 0,
+        "height": 0,
+        "crop_w": 0,
+        "crop_h": 0,
+        "target_width": 0,
+        "target_height": 0,
+        "smZ_steps": 1,
+        "mean_normalization": true,
+        "multi_conditioning": true,
+        "use_old_emphasis_implementation": false,
+        "with_SDXL": false,
+        "clip": ["resource-stack-3", 1]
+      },
+      "_meta": { "title": "Negative" }
+    },
+    "20": {
+      "class_type": "UpscaleModelLoader",
+      "inputs": { "model_name": "urn:air:other:upscaler:civitai:147759@164821" },
+      "_meta": { "title": "Load Upscale Model" }
+    },
+    "17": {
+      "class_type": "LoadImage",
+      "inputs": {
+        "image": "https://orchestration.civitai.com/v2/consumer/blobs/5KZ6358TW8CNEGPZKD08NVDB30",
+        "upload": "image"
+      },
+      "_meta": { "title": "Image Load" }
+    },
+    "19": {
+      "class_type": "ImageUpscaleWithModel",
+      "inputs": { "upscale_model": ["20", 0], "image": ["17", 0] },
+      "_meta": { "title": "Upscale Image (using Model)" }
+    },
+    "23": {
+      "class_type": "ImageScale",
+      "inputs": {
+        "upscale_method": "nearest-exact",
+        "crop": "disabled",
+        "width": 1280,
+        "height": 1856,
+        "image": ["19", 0]
+      },
+      "_meta": { "title": "Upscale Image" }
+    },
+    "21": {
+      "class_type": "VAEEncode",
+      "inputs": { "pixels": ["23", 0], "vae": ["resource-stack", 2] },
+      "_meta": { "title": "VAE Encode" }
+    },
+    "11": {
+      "class_type": "KSampler",
+      "inputs": {
+        "sampler_name": "euler_ancestral",
+        "scheduler": "normal",
+        "seed": 2088370631,
+        "steps": 47,
+        "cfg": 6.5,
+        "denoise": 0.3,
+        "model": ["resource-stack-3", 0],
+        "positive": ["6", 0],
+        "negative": ["7", 0],
+        "latent_image": ["21", 0]
+      },
+      "_meta": { "title": "KSampler" }
+    },
+    "13": {
+      "class_type": "VAEDecode",
+      "inputs": { "samples": ["11", 0], "vae": ["resource-stack", 2] },
+      "_meta": { "title": "VAE Decode" }
+    },
+    "12": {
+      "class_type": "SaveImage",
+      "inputs": { "filename_prefix": "ComfyUI", "images": ["13", 0] },
+      "_meta": { "title": "Save Image" }
+    },
+    "extra": {
+      "airs": [
+        "urn:air:other:upscaler:civitai:147759@164821",
+        "urn:air:sdxl:checkpoint:civitai:827184@1410435",
+        "urn:air:sdxl:lora:civitai:1107767@1253442",
+        "urn:air:sdxl:lora:civitai:1342708@1516344",
+        "urn:air:sdxl:lora:civitai:122359@135867"
+      ]
+    },
+    "extraMetadata": "{\u0022prompt\u0022:\u0022masterpiece, best quality, amazing quality, detailed setting, detailed background, 1girl, yunyun (konosuba), nude, red eyes, hair ornament, braid, hair between eyes,low twintails, pink ribbon, bow, hair bow, pussy, frilled skirt, layered skirt, belt, pink thighhighs, (pussy juice), large insertion, vaginal tugging, pussy grip, detailed skin, detailed soles, stretched pussy, feet in stockings, ass, nipples, medium breasts, french kiss, anus, shocked, nervous, penis awe,  BREAK Professor\u0027s office, college student, pornographic, 1boy, close eyes, (musscular male, detailed large cock), vaginal sex, college office setting, ass grab, fucking, riding, cowgirl, erotic, side view, deep fucking\u0022,\u0022negativePrompt\u0022:\u0022bad quality,worst quality,worst detail,sketch,censor\u0022,\u0022steps\u0022:47,\u0022cfgScale\u0022:6.5,\u0022sampler\u0022:\u0022euler_ancestral\u0022,\u0022workflowId\u0022:\u0022img2img-hires\u0022,\u0022resources\u0022:[{\u0022modelVersionId\u0022:1410435,\u0022strength\u0022:1},{\u0022modelVersionId\u0022:1410435,\u0022strength\u0022:1},{\u0022modelVersionId\u0022:1253442,\u0022strength\u0022:1},{\u0022modelVersionId\u0022:1516344,\u0022strength\u0022:1},{\u0022modelVersionId\u0022:135867,\u0022strength\u0022:1.55}],\u0022remixOfId\u0022:32140259}"
+  }
+  

refs/jpeg_civitai_exif_userComment_example

@@ -12,18 +12,10 @@ holographic skin, holofoil glitter, faint, glowing, ethereal, neon hair, glowing
 Negative prompt: score_6, score_5, score_4, bad quality, worst quality, worst detail, sketch, censorship, furry, window, headphones,
 Steps: 30, Sampler: Euler a, Schedule type: Simple, CFG scale: 7, Seed: 1405717592, Size: 832x1216, Model hash: 1ad6ca7f70, Model: waiNSFWIllustrious_v100, Denoising strength: 0.35, Hires CFG Scale: 5, Hires upscale: 1.3, Hires steps: 20, Hires upscaler: 4x-AnimeSharp, Lora hashes: "ck-shadow-circuit-IL: 88e247aa8c3d, ck-nc-cyberpunk-IL-000011: 935e6755554c, ck-neon-retrowave-IL: edafb9df7da1, ck-yoneyama-mai-IL-000014: 1b9305692a2e", Version: f2.0.1v1.10.1-1.10.1, Diffusion in Low Bits: Automatic (fp16 LoRA)
 
-masterpiece, best quality,high quality, newest, highres,8K,HDR,absurdres, 1girl, solo, steampunk aesthetic, mechanical monocle, long trench coat, leather gloves, brass accessories, intricate clockwork rifle, aiming at viewer, wind-blown scarf, high boots, fingerless gloves, pocket watch, corset, brown and gold color scheme, industrial cityscape, smoke and gears, atmospheric lighting, depth of field, dynamic pose, dramatic composition, detailed background, foreshortening, detailed background, dynamic pose, dynamic composition,dutch angle, detailed backgroud,foreshortening,blurry edges <lora:iLLMythAn1m3Style:1> MythAn1m3
-Negative prompt: worst quality, normal quality, anatomical nonsense, bad anatomy,interlocked fingers, extra fingers,watermark,simple background, loli,
-Steps: 35, Sampler: DPM++ 2M SDE, Schedule type: Karras, CFG scale: 4, Seed: 3537159932, Size: 1072x1376, Model hash: c364bbdae9, Model: waiNSFWIllustrious_v110, Clip skip: 2, ADetailer model: face_yolov8n.pt, ADetailer confidence: 0.3, ADetailer dilate erode: 4, ADetailer mask blur: 4, ADetailer denoising strength: 0.4, ADetailer inpaint only masked: True, ADetailer inpaint padding: 32, ADetailer version: 24.8.0, Lora hashes: "iLLMythAn1m3Style: d3480076057b", Version: f2.0.1v1.10.1-previous-519-g44eb4ea8, Module 1: sdxl.vae
-
 Masterpiece, best quality, high quality, newest, highres, 8K, HDR, absurdres, 1girl, solo, futuristic warrior, sleek exosuit with glowing energy cores, long braided hair flowing behind, gripping a high-tech bow with an energy arrow drawn, standing on a floating platform overlooking a massive space station, planets and nebulae in the distance, soft glow from distant stars, cinematic depth, foreshortening, dynamic pose, dramatic sci-fi lighting.
 Negative prompt: worst quality, normal quality, anatomical nonsense, bad anatomy,interlocked fingers, extra fingers,watermark,simple background, loli,
 Steps: 20, Sampler: euler_ancestral_karras, CFG scale: 8.0, Seed: 691121152183439, Model: il\waiNSFWIllustrious_v110.safetensors, Model hash: c3688ee04c, Lora_0 Model name: iLLMythAn1m3Style.safetensors, Lora_0 Model hash: ba7a040786, Lora_0 Strength model: 1.0, Lora_0 Strength clip: 1.0, Hashes: {"model": "c3688ee04c", "lora:iLLMythAn1m3Style": "ba7a040786"}
 
-Masterpiece, best quality, high quality, newest, highres, 8K, HDR, absurdres, 1boy, solo, gothic horror, pale vampire lord in regal, intricately detailed robes, crimson eyes glowing under the dim candlelight of a grand but decayed castle hall, holding a silver goblet filled with an unknown substance, a massive stained-glass window shattered behind him, cold mist rolling in, dramatic lighting, dark yet elegant aesthetic, foreshortening, cinematic perspective.
-Negative prompt: worst quality, normal quality, anatomical nonsense, bad anatomy,interlocked fingers, extra fingers,watermark,simple background, loli,
-Steps: 20, Sampler: euler_ancestral_karras, CFG scale: 8.0, Seed: 290117945770094, Model: il\waiNSFWIllustrious_v110.safetensors, Model hash: c3688ee04c, Lora_0 Model name: iLLMythAn1m3Style.safetensors, Lora_0 Model hash: ba7a040786, Lora_0 Strength model: 0.6, Lora_0 Strength clip: 0.7000000000000001, Hashes: {"model": "c3688ee04c", "lora:iLLMythAn1m3Style": "ba7a040786"}
-
-bo-exposure, An impressionistic oil painting in the style of J.M.W. Turner, depicting a ghostly ship sailing through a sea of swirling golden mist. The waves crash and dissolve into abstract, fiery strokes of orange and deep indigo, blurring the line between ocean and sky. The ship appears almost ethereal, as if drifting between worlds, lost in the ever-changing tides of memory and myth. The dynamic brushstrokes capture the relentless power of nature and the fleeting essence of time.
+Immerse yourself in the enchanting journey, where harmonious transmutation of Bauhaus art unites photographic precision and contemporary illustration, capturing an enthralling blend between vivid abstract nature and urban landscapes. Let your eyes be captivated by a kaleidoscope of rich, deep reds and yellows, entwined with intriguing shades that beckon a somber atmosphere. As your spirit ventures along this haunting path, witness the mysterious, high-angle perspective dominated by scattered clouds – granting you a mesmerizing glimpse into the ever-transforming realm of metamorphosing environments. ,<lora:flux/fav/ck-charcoal-drawing-000014.safetensors:1.0:1.0>   
 Negative prompt:
-Steps: 25, Sampler: DPM++ 2M, CFG scale: 3.5, Seed: 1024252061321625, Size: 832x1216, Clip skip: 1, Model hash: , Model: flux_dev, Hashes: {"model": ""}, Version: ComfyUI
+Steps: 20, Sampler: Euler, CFG scale: 3.5, Seed: 885491426361006, Size: 832x1216, Model hash: 4610115bb0, Model: flux_dev, Hashes: {"LORA:flux/fav/ck-charcoal-drawing-000014.safetensors": "34d36c17c1", "model": "4610115bb0"}, Version: ComfyUI

refs/meta_format.txt

@@ -0,0 +1,3 @@
+In this ethereal masterpiece, metallic sculptures juxtapose effortlessly against a subtle backdrop of misty neutral hues. Exquisite curvatures and geometric shapes converge harmoniously, creating an illuminating realm of polished metallic surfaces. Shimmering copper, gleaming silver, and lustrous gold hues dance in perfect balance, highlighting the intricate play of light and shadow cast upon these celestial forms.  A halo of diffused radiance envelops each piece, enhancing their textured depths and metallic brilliance while allowing delicate details to emerge from obscurity. The composition conveys a serene yet mesmerizing atmosphere, as if suspended in a dreamlike limbo between reality and fantasy. The tantalizing interplay of colors within this transcendent realm creates a profound sense of depth and grandeur that invites the viewer into an enchanting voyage through abstract metallic beauty.  This captivating artwork evokes emotions of boundless curiosity and reverence reminiscent of the timeless works by artists such as Giorgio de Chirico or Paul Klee, while asserting a unique, modern artistic sensibility. With every observation, a new nuance unfolds, as if a never-ending story waiting to be discovered through the lens of metallic artistry.
+Negative prompt:
+Steps: 25, Sampler: dpmpp_2m_sgm_uniform, Seed: 471889513588087, Model: Fluxmania V5P.safetensors, Model hash: 8ae0583b06, VAE: ae.sft, VAE hash: afc8e28272, Lora_0 Model name: ArtVador I.safetensors, Lora_0 Model hash: 08f7133a58, Lora_0 Strength model: 0.65, Lora_0 Strength clip: 0.65, Lora_1 Model name: Kaoru Yamada.safetensors, Lora_1 Model hash: d4893f7202, Lora_1 Strength model: 0.75, Lora_1 Strength clip: 0.75, Hashes: {"model": "8ae0583b06", "vae": "afc8e28272", "lora:ArtVador I": "08f7133a58", "lora:Kaoru Yamada": "d4893f7202"}

static/css/components/lora-modal.css

@@ -99,6 +99,7 @@
     width: 100%;
     background: var(--lora-surface);
     margin-bottom: var(--space-2);
+    overflow: hidden; /* Ensure metadata panel is contained */
 }
 
 .media-wrapper:last-child {
@@ -542,25 +543,53 @@
     display: flex;
     align-items: center;
     gap: 8px;
-    cursor: pointer;
     padding: 4px;
     border-radius: var(--border-radius-xs);
     transition: background-color 0.2s;
+    position: relative;
 }
 
 .file-name-wrapper:hover {
     background: oklch(var(--lora-accent) / 0.1);
 }
 
-.file-name-wrapper i {
-    color: var(--text-color);
-    opacity: 0.5;
-    transition: opacity 0.2s;
+.file-name-content {
+    padding: 2px 4px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid transparent;
+    flex: 1;
 }
 
-.file-name-wrapper:hover i {
-    opacity: 1;
-    color: var(--lora-accent);
+.file-name-wrapper.editing .file-name-content {
+    border: 1px solid var(--lora-accent);
+    background: var(--bg-color);
+    outline: none;
+}
+
+.edit-file-name-btn {
+    background: transparent;
+    border: none;
+    color: var(--text-color);
+    opacity: 0;
+    cursor: pointer;
+    padding: 2px 5px;
+    border-radius: var(--border-radius-xs);
+    transition: all 0.2s ease;
+    margin-left: var(--space-1);
+}
+
+.edit-file-name-btn.visible,
+.file-name-wrapper:hover .edit-file-name-btn {
+    opacity: 0.5;
+}
+
+.edit-file-name-btn:hover {
+    opacity: 0.8 !important;
+    background: rgba(0, 0, 0, 0.05);
+}
+
+[data-theme="dark"] .edit-file-name-btn:hover {
+    background: rgba(255, 255, 255, 0.05);
 }
 
 /* Base Model and Size combined styles */
@@ -573,6 +602,59 @@
     flex: 2;  /* 分配更多空间给base model */
 }
 
+/* Base model display and editing styles */
+.base-model-display {
+    display: flex;
+    align-items: center;
+    position: relative;
+}
+
+.base-model-content {
+    padding: 2px 4px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid transparent;
+    color: var(--text-color);
+    flex: 1;
+}
+
+.edit-base-model-btn {
+    background: transparent;
+    border: none;
+    color: var(--text-color);
+    opacity: 0;
+    cursor: pointer;
+    padding: 2px 5px;
+    border-radius: var(--border-radius-xs);
+    transition: all 0.2s ease;
+    margin-left: var(--space-1);
+}
+
+.edit-base-model-btn.visible,
+.base-model-display:hover .edit-base-model-btn {
+    opacity: 0.5;
+}
+
+.edit-base-model-btn:hover {
+    opacity: 0.8 !important;
+    background: rgba(0, 0, 0, 0.05);
+}
+
+[data-theme="dark"] .edit-base-model-btn:hover {
+    background: rgba(255, 255, 255, 0.05);
+}
+
+.base-model-selector {
+    width: 100%;
+    padding: 3px 5px;
+    background: var(--bg-color);
+    border: 1px solid var(--lora-accent);
+    border-radius: var(--border-radius-xs);
+    color: var(--text-color);
+    font-size: 0.9em;
+    outline: none;
+    margin-right: var(--space-1);
+}
+
 .size-wrapper {
     flex: 1;
     border-left: 1px solid var(--lora-border);
@@ -1030,4 +1112,172 @@
 /* Make sure media wrapper maintains position: relative for absolute positioning of children */
 .carousel .media-wrapper {
     position: relative;
+}
+
+/* Image Metadata Panel Styles */
+.image-metadata-panel {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: var(--bg-color);
+    border-top: 1px solid var(--border-color);
+    padding: var(--space-2);
+    transform: translateY(100%);
+    transition: transform 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275), opacity 0.25s ease;
+    z-index: 5;
+    max-height: 50%; /* Reduced to take less space */
+    overflow-y: auto;
+    box-shadow: 0 -2px 8px rgba(0, 0, 0, 0.1);
+    opacity: 0;
+    pointer-events: none;
+}
+
+/* Show metadata panel only on hover */
+.media-wrapper:hover .image-metadata-panel {
+    transform: translateY(0);
+    opacity: 0.98;
+    pointer-events: auto;
+}
+
+/* Adjust to dark theme */
+[data-theme="dark"] .image-metadata-panel {
+    background: var(--card-bg);
+    box-shadow: 0 -2px 8px rgba(0, 0, 0, 0.3);
+}
+
+.metadata-content {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+/* Styling for parameters tags */
+.params-tags {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    margin-bottom: var(--space-1);
+    padding-bottom: var(--space-1);
+    border-bottom: 1px solid var(--lora-border);
+}
+
+.param-tag {
+    display: inline-flex;
+    align-items: center;
+    background: var(--lora-surface);
+    border: 1px solid var(--lora-border);
+    border-radius: var(--border-radius-xs);
+    padding: 2px 6px;
+    font-size: 0.8em;
+    line-height: 1.2;
+    white-space: nowrap;
+}
+
+.param-tag .param-name {
+    font-weight: 600;
+    color: var(--text-color);
+    margin-right: 4px;
+    opacity: 0.8;
+}
+
+.param-tag .param-value {
+    color: var(--lora-accent);
+}
+
+/* Special styling for prompt row */
+.metadata-row.prompt-row {
+    flex-direction: column;
+    padding-top: 0;
+}
+
+.metadata-row.prompt-row + .metadata-row.prompt-row {
+    margin-top: var(--space-2);
+}
+
+.metadata-label {
+    font-weight: 600;
+    color: var(--text-color);
+    opacity: 0.8;
+    font-size: 0.85em;
+    display: block;
+    margin-bottom: 4px;
+}
+
+.metadata-prompt-wrapper {
+    position: relative;
+    background: var(--lora-surface);
+    border: 1px solid var(--lora-border);
+    border-radius: var(--border-radius-xs);
+    padding: 6px 30px 6px 8px;
+    margin-top: 2px;
+    max-height: 80px; /* Reduced from 120px */
+    overflow-y: auto;
+    word-break: break-word;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.metadata-prompt {
+    color: var(--text-color);
+    font-family: monospace;
+    font-size: 0.85em;
+    white-space: pre-wrap;
+}
+
+.copy-prompt-btn {
+    position: absolute;
+    top: 6px;
+    right: 6px;
+    background: transparent;
+    border: none;
+    color: var(--text-color);
+    opacity: 0.6;
+    cursor: pointer;
+    padding: 3px;
+    transition: all 0.2s ease;
+}
+
+.copy-prompt-btn:hover {
+    opacity: 1;
+    color: var(--lora-accent);
+}
+
+/* Scrollbar styling for metadata panel */
+.image-metadata-panel::-webkit-scrollbar {
+    width: 6px;
+}
+
+.image-metadata-panel::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.image-metadata-panel::-webkit-scrollbar-thumb {
+    background-color: var(--border-color);
+    border-radius: 3px;
+}
+
+/* For Firefox */
+.image-metadata-panel {
+    scrollbar-width: thin;
+    scrollbar-color: var(--border-color) transparent;
+}
+
+/* No metadata message styling */
+.no-metadata-message {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: var(--space-2);
+    color: var(--text-color);
+    opacity: 0.7;
+    text-align: center;
+    font-style: italic;
+    gap: 8px;
+}
+
+.no-metadata-message i {
+    font-size: 1.1em;
+    color: var(--lora-accent);
+    opacity: 0.8;
 }

static/css/components/recipe-modal.css

@@ -18,6 +18,110 @@
     display: -webkit-box;
     -webkit-line-clamp: 2;
     -webkit-box-orient: vertical;
+    width: calc(100% - 20px);
+}
+
+/* Editable content styles */
+.editable-content {
+    position: relative;
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.editable-content.hide {
+    display: none;
+}
+
+.editable-content .content-text {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.edit-icon {
+    background: none;
+    border: none;
+    color: var(--text-color);
+    opacity: 0;
+    cursor: pointer;
+    padding: 4px 8px;
+    margin-left: 8px;
+    border-radius: var(--border-radius-xs);
+    transition: all 0.2s;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.editable-content:hover .edit-icon {
+    opacity: 0.6;
+}
+
+.edit-icon:hover {
+    opacity: 1 !important;
+    background: var(--lora-surface);
+}
+
+/* Content editor styles */
+.content-editor {
+    display: none;
+    width: 100%;
+    padding: 4px 0;
+}
+
+.content-editor.active {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.content-editor input {
+    flex: 1;
+    background: var(--bg-color);
+    border: 1px solid var(--lora-border);
+    border-radius: var(--border-radius-xs);
+    padding: 6px 8px;
+    font-size: 1em;
+    color: var(--text-color);
+    min-width: 0;
+}
+
+.content-editor.tags-editor input {
+    font-size: 0.9em;
+}
+
+/* 删除不再需要的按钮样式 */
+.editor-actions {
+    display: none;
+}
+
+/* Special styling for tags content */
+.tags-content {
+    display: flex;
+    align-items: center;
+    flex-wrap: nowrap;
+    gap: 8px;
+}
+
+.tags-display {
+    display: flex;
+    flex-wrap: nowrap;
+    gap: 6px;
+    align-items: center;
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+}
+
+.no-tags {
+    font-size: 0.85em;
+    color: var(--text-color);
+    opacity: 0.6;
+    font-style: italic;
 }
 
 /* Recipe Tags styles */
@@ -129,7 +233,14 @@
     justify-content: center;
 }
 
-.recipe-preview-container img {
+.recipe-preview-container img,
+.recipe-preview-container video {
+    max-width: 100%;
+    max-height: 100%;
+    object-fit: contain;
+}
+
+.recipe-preview-media {
     max-width: 100%;
     max-height: 100%;
     object-fit: contain;
@@ -333,6 +444,12 @@
     border-left: 4px solid var(--lora-error);
 }
 
+.recipe-lora-item.is-deleted {
+    background: rgba(127, 127, 127, 0.05);
+    border-left: 4px solid #777;
+    opacity: 0.8;
+}
+
 .recipe-lora-thumbnail {
     width: 46px;
     height: 46px;
@@ -340,9 +457,19 @@
     border-radius: var(--border-radius-xs);
     overflow: hidden;
     background: var(--bg-color);
+    display: flex;
+    align-items: center;
+    justify-content: center;
 }
 
-.recipe-lora-thumbnail img {
+.recipe-lora-thumbnail img,
+.recipe-lora-thumbnail video {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.thumbnail-video {
     width: 100%;
     height: 100%;
     object-fit: cover;
@@ -457,6 +584,38 @@
     font-size: 0.9em;
 }
 
+/* Deleted badge */
+.deleted-badge {
+    display: inline-flex;
+    align-items: center;
+    background: #777;
+    color: white;
+    padding: 3px 6px;
+    border-radius: var(--border-radius-xs);
+    font-size: 0.75em;
+    font-weight: 500;
+    white-space: nowrap;
+    flex-shrink: 0;
+}
+
+.deleted-badge i {
+    margin-right: 4px;
+    font-size: 0.9em;
+}
+
+/* Recipe status partial state */
+.recipe-status.partial {
+    background: rgba(127, 127, 127, 0.1);
+    color: #777;
+}
+
+/* 标题输入框特定的样式 */
+.title-input {
+    font-size: 1.2em !important; /* 调整为更合适的大小 */
+    line-height: 1.2;
+    font-weight: 500;
+}
+
 /* Responsive adjustments */
 @media (max-width: 768px) {
     .recipe-top-section {
@@ -485,7 +644,8 @@
 
 /* Update the local-badge and missing-badge to be positioned within the badge-container */
 .badge-container .local-badge, 
-.badge-container .missing-badge {
+.badge-container .missing-badge,
+.badge-container .deleted-badge {
     position: static; /* Override absolute positioning */
     transform: none; /* Remove the transform */
 }
@@ -495,3 +655,46 @@
     position: fixed; /* Keep as fixed for Chrome */
     z-index: 100;
 }
+
+/* Add styles for missing LoRAs download feature */
+.recipe-status.missing {
+    position: relative;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+}
+
+.recipe-status.missing:hover {
+    background-color: rgba(var(--lora-warning-rgb, 255, 165, 0), 0.2);
+}
+
+.recipe-status.missing .missing-tooltip {
+    position: absolute;
+    display: none;
+    background-color: var(--card-bg);
+    color: var(--text-color);
+    padding: 8px 12px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid var(--border-color);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    z-index: var(--z-overlay);
+    width: max-content;
+    max-width: 200px;
+    font-size: 0.85rem;
+    font-weight: normal;
+    margin-left: -100px;
+    margin-top: -65px;
+}
+
+.recipe-status.missing:hover .missing-tooltip {
+    display: block;
+}
+
+.recipe-status.clickable {
+    cursor: pointer;
+    padding: 4px 8px;
+    border-radius: var(--border-radius-xs);
+}
+
+.recipe-status.clickable:hover {
+    background-color: rgba(var(--lora-warning-rgb, 255, 165, 0), 0.2);
+}

static/js/components/LoraModal.js

@@ -1,7 +1,7 @@
 import { showToast } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { modalManager } from '../managers/ModalManager.js';
-import { NSFW_LEVELS } from '../utils/constants.js';
+import { NSFW_LEVELS, BASE_MODELS } from '../utils/constants.js';
 
 export function showLoraModal(lora) {
     const escapedWords = lora.civitai?.trainedWords?.length ? 
@@ -29,9 +29,11 @@ export function showLoraModal(lora) {
                         </div>
                         <div class="info-item">
                             <label>File Name</label>
-                            <div class="file-name-wrapper" onclick="copyFileName('${lora.file_name}')">
-                                <span id="file-name">${lora.file_name || 'N/A'}</span>
-                                <i class="fas fa-copy" title="Copy file name"></i>
+                            <div class="file-name-wrapper">
+                                <span id="file-name" class="file-name-content">${lora.file_name || 'N/A'}</span>
+                                <button class="edit-file-name-btn" title="Edit file name">
+                                    <i class="fas fa-pencil-alt"></i>
+                                </button>
                             </div>
                         </div>
                         <div class="info-item location-size">
@@ -43,7 +45,12 @@ export function showLoraModal(lora) {
                         <div class="info-item base-size">
                             <div class="base-wrapper">
                                 <label>Base Model</label>
-                                <span>${lora.base_model || 'N/A'}</span>
+                                <div class="base-model-display">
+                                    <span class="base-model-content">${lora.base_model || 'N/A'}</span>
+                                    <button class="edit-base-model-btn" title="Edit base model">
+                                        <i class="fas fa-pencil-alt"></i>
+                                    </button>
+                                </div>
                             </div>
                             <div class="size-wrapper">
                                 <label>Size</label>
@@ -124,6 +131,8 @@ export function showLoraModal(lora) {
     setupTagTooltip();
     setupTriggerWordsEditMode();
     setupModelNameEditing();
+    setupBaseModelEditing();
+    setupFileNameEditing();
     
     // If we have a model ID but no description, fetch it
     if (lora.civitai?.modelId && !lora.modelDescription) {
@@ -202,61 +211,165 @@ function renderShowcaseContent(images) {
                         nsfwText = "R-rated Content";
                     }
                     
-                    if (img.type === 'video') {
-                        return `
-                            <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
-                                ${shouldBlur ? `
-                                    <button class="toggle-blur-btn showcase-toggle-btn" title="Toggle blur">
-                                        <i class="fas fa-eye"></i>
-                                    </button>
-                                ` : ''}
-                                <video controls autoplay muted loop crossorigin="anonymous" 
-                                       referrerpolicy="no-referrer" data-src="${img.url}"
-                                       class="lazy ${shouldBlur ? 'blurred' : ''}">
-                                    <source data-src="${img.url}" type="video/mp4">
-                                    Your browser does not support video playback
-                                </video>
-                                ${shouldBlur ? `
-                                    <div class="nsfw-overlay">
-                                        <div class="nsfw-warning">
-                                            <p>${nsfwText}</p>
-                                            <button class="show-content-btn">Show</button>
-                                        </div>
-                                    </div>
-                                ` : ''}
-                            </div>
-                        `;
-                    }
-                    return `
-                        <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
-                            ${shouldBlur ? `
-                                <button class="toggle-blur-btn showcase-toggle-btn" title="Toggle blur">
-                                    <i class="fas fa-eye"></i>
-                                </button>
-                            ` : ''}
-                            <img data-src="${img.url}" 
-                                alt="Preview" 
-                                crossorigin="anonymous" 
-                                referrerpolicy="no-referrer"
-                                width="${img.width}"
-                                height="${img.height}"
-                                class="lazy ${shouldBlur ? 'blurred' : ''}"> 
-                            ${shouldBlur ? `
-                                <div class="nsfw-overlay">
-                                    <div class="nsfw-warning">
-                                        <p>${nsfwText}</p>
-                                        <button class="show-content-btn">Show</button>
+                    // Extract metadata from the image
+                    const meta = img.meta || {};
+                    const prompt = meta.prompt || '';
+                    const negativePrompt = meta.negative_prompt || meta.negativePrompt || '';
+                    const size = meta.Size || `${img.width}x${img.height}`;
+                    const seed = meta.seed || '';
+                    const model = meta.Model || '';
+                    const steps = meta.steps || '';
+                    const sampler = meta.sampler || '';
+                    const cfgScale = meta.cfgScale || '';
+                    const clipSkip = meta.clipSkip || '';
+                    
+                    // Check if we have any meaningful generation parameters
+                    const hasParams = seed || model || steps || sampler || cfgScale || clipSkip;
+                    const hasPrompts = prompt || negativePrompt;
+                    
+                    // If no metadata available, show a message
+                    if (!hasParams && !hasPrompts) {
+                        const metadataPanel = `
+                            <div class="image-metadata-panel">
+                                <div class="metadata-content">
+                                    <div class="no-metadata-message">
+                                        <i class="fas fa-info-circle"></i>
+                                        <span>No generation parameters available</span>
                                     </div>
                                 </div>
-                            ` : ''}
+                            </div>
+                        `;
+                        
+                        if (img.type === 'video') {
+                            return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                        }
+                        return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                    }
+                    
+                    // Create a data attribute with the prompt for copying instead of trying to handle it in the onclick
+                    // This avoids issues with quotes and special characters
+                    const promptIndex = Math.random().toString(36).substring(2, 15);
+                    const negPromptIndex = Math.random().toString(36).substring(2, 15);
+                    
+                    // Create parameter tags HTML
+                    const paramTags = `
+                        <div class="params-tags">
+                            ${size ? `<div class="param-tag"><span class="param-name">Size:</span><span class="param-value">${size}</span></div>` : ''}
+                            ${seed ? `<div class="param-tag"><span class="param-name">Seed:</span><span class="param-value">${seed}</span></div>` : ''}
+                            ${model ? `<div class="param-tag"><span class="param-name">Model:</span><span class="param-value">${model}</span></div>` : ''}
+                            ${steps ? `<div class="param-tag"><span class="param-name">Steps:</span><span class="param-value">${steps}</span></div>` : ''}
+                            ${sampler ? `<div class="param-tag"><span class="param-name">Sampler:</span><span class="param-value">${sampler}</span></div>` : ''}
+                            ${cfgScale ? `<div class="param-tag"><span class="param-name">CFG:</span><span class="param-value">${cfgScale}</span></div>` : ''}
+                            ${clipSkip ? `<div class="param-tag"><span class="param-name">Clip Skip:</span><span class="param-value">${clipSkip}</span></div>` : ''}
                         </div>
                     `;
+                    
+                    // Metadata panel HTML
+                    const metadataPanel = `
+                        <div class="image-metadata-panel">
+                            <div class="metadata-content">
+                                ${hasParams ? paramTags : ''}
+                                ${!hasParams && !hasPrompts ? `
+                                <div class="no-metadata-message">
+                                    <i class="fas fa-info-circle"></i>
+                                    <span>No generation parameters available</span>
+                                </div>
+                                ` : ''}
+                                ${prompt ? `
+                                <div class="metadata-row prompt-row">
+                                    <span class="metadata-label">Prompt:</span>
+                                    <div class="metadata-prompt-wrapper">
+                                        <div class="metadata-prompt">${prompt}</div>
+                                        <button class="copy-prompt-btn" data-prompt-index="${promptIndex}">
+                                            <i class="fas fa-copy"></i>
+                                        </button>
+                                    </div>
+                                </div>
+                                <div class="hidden-prompt" id="prompt-${promptIndex}" style="display:none;">${prompt}</div>
+                                ` : ''}
+                                ${negativePrompt ? `
+                                <div class="metadata-row prompt-row">
+                                    <span class="metadata-label">Negative Prompt:</span>
+                                    <div class="metadata-prompt-wrapper">
+                                        <div class="metadata-prompt">${negativePrompt}</div>
+                                        <button class="copy-prompt-btn" data-prompt-index="${negPromptIndex}">
+                                            <i class="fas fa-copy"></i>
+                                        </button>
+                                    </div>
+                                </div>
+                                <div class="hidden-prompt" id="prompt-${negPromptIndex}" style="display:none;">${negativePrompt}</div>
+                                ` : ''}
+                            </div>
+                        </div>
+                    `;
+                    
+                    if (img.type === 'video') {
+                        return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                    }
+                    return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
                 }).join('')}
             </div>
         </div>
     `;
 }
 
+// Helper function to generate video wrapper HTML
+function generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+    return `
+        <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
+            ${shouldBlur ? `
+                <button class="toggle-blur-btn showcase-toggle-btn" title="Toggle blur">
+                    <i class="fas fa-eye"></i>
+                </button>
+            ` : ''}
+            <video controls autoplay muted loop crossorigin="anonymous" 
+                referrerpolicy="no-referrer" data-src="${img.url}"
+                class="lazy ${shouldBlur ? 'blurred' : ''}">
+                <source data-src="${img.url}" type="video/mp4">
+                Your browser does not support video playback
+            </video>
+            ${shouldBlur ? `
+                <div class="nsfw-overlay">
+                    <div class="nsfw-warning">
+                        <p>${nsfwText}</p>
+                        <button class="show-content-btn">Show</button>
+                    </div>
+                </div>
+            ` : ''}
+            ${metadataPanel}
+        </div>
+    `;
+}
+
+// Helper function to generate image wrapper HTML
+function generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+    return `
+        <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
+            ${shouldBlur ? `
+                <button class="toggle-blur-btn showcase-toggle-btn" title="Toggle blur">
+                    <i class="fas fa-eye"></i>
+                </button>
+            ` : ''}
+            <img data-src="${img.url}" 
+                alt="Preview" 
+                crossorigin="anonymous" 
+                referrerpolicy="no-referrer"
+                width="${img.width}"
+                height="${img.height}"
+                class="lazy ${shouldBlur ? 'blurred' : ''}"> 
+            ${shouldBlur ? `
+                <div class="nsfw-overlay">
+                    <div class="nsfw-warning">
+                        <p>${nsfwText}</p>
+                        <button class="show-content-btn">Show</button>
+                    </div>
+                </div>
+            ` : ''}
+            ${metadataPanel}
+        </div>
+    `;
+}
+
 // New function to handle tab switching
 function setupTabSwitching() {
     const tabButtons = document.querySelectorAll('.showcase-tabs .tab-btn');
@@ -620,13 +733,74 @@ export function toggleShowcase(element) {
         
         // Initialize NSFW content blur toggle handlers
         initNsfwBlurHandlers(carousel);
+        
+        // Initialize metadata panel interaction handlers
+        initMetadataPanelHandlers(carousel);
     } else {
         const count = carousel.querySelectorAll('.media-wrapper').length;
         indicator.textContent = `Scroll or click to show ${count} examples`;
         icon.classList.replace('fa-chevron-up', 'fa-chevron-down');
+        
+        // Make sure any open metadata panels get closed
+        const carouselContainer = carousel.querySelector('.carousel-container');
+        if (carouselContainer) {
+            carouselContainer.style.height = '0';
+            setTimeout(() => {
+                carouselContainer.style.height = '';
+            }, 300);
+        }
     }
 }
 
+// Function to initialize metadata panel interactions
+function initMetadataPanelHandlers(container) {
+    // Find all media wrappers
+    const mediaWrappers = container.querySelectorAll('.media-wrapper');
+    
+    mediaWrappers.forEach(wrapper => {
+        // Get the metadata panel
+        const metadataPanel = wrapper.querySelector('.image-metadata-panel');
+        if (!metadataPanel) return;
+        
+        // Prevent events from the metadata panel from bubbling
+        metadataPanel.addEventListener('click', (e) => {
+            e.stopPropagation();
+        });
+        
+        // Handle copy prompt button clicks
+        const copyBtns = metadataPanel.querySelectorAll('.copy-prompt-btn');
+        copyBtns.forEach(copyBtn => {
+            const promptIndex = copyBtn.dataset.promptIndex;
+            const promptElement = wrapper.querySelector(`#prompt-${promptIndex}`);
+            
+            copyBtn.addEventListener('click', async (e) => {
+                e.stopPropagation(); // Prevent bubbling
+                
+                if (!promptElement) return;
+                
+                try {
+                    await navigator.clipboard.writeText(promptElement.textContent);
+                    showToast('Prompt copied to clipboard', 'success');
+                } catch (err) {
+                    console.error('Copy failed:', err);
+                    showToast('Copy failed', 'error');
+                }
+            });
+        });
+        
+        // Prevent scrolling in the metadata panel from scrolling the whole modal
+        metadataPanel.addEventListener('wheel', (e) => {
+            const isAtTop = metadataPanel.scrollTop === 0;
+            const isAtBottom = metadataPanel.scrollHeight - metadataPanel.scrollTop === metadataPanel.clientHeight;
+            
+            // Only prevent default if scrolling would cause the panel to scroll
+            if ((e.deltaY < 0 && !isAtTop) || (e.deltaY > 0 && !isAtBottom)) {
+                e.stopPropagation();
+            }
+        }, { passive: true });
+    });
+}
+
 // New function to initialize blur toggle handlers for showcase images/videos
 function initNsfwBlurHandlers(container) {
     // Handle toggle blur buttons
@@ -1225,3 +1399,335 @@ function setupModelNameEditing() {
         }
     });
 }
+
+// Add save model base model function
+window.saveBaseModel = async function(filePath, originalValue) {
+    const baseModelElement = document.querySelector('.base-model-content');
+    const newBaseModel = baseModelElement.textContent.trim();
+    
+    // Only save if the value has actually changed
+    if (newBaseModel === originalValue) {
+        return; // No change, no need to save
+    }
+    
+    try {
+        await saveModelMetadata(filePath, { base_model: newBaseModel });
+        
+        // Update the corresponding lora card's dataset
+        const loraCard = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+        if (loraCard) {
+            loraCard.dataset.base_model = newBaseModel;
+        }
+        
+        showToast('Base model updated successfully', 'success');
+    } catch (error) {
+        showToast('Failed to update base model', 'error');
+    }
+};
+
+// New function to handle base model editing
+function setupBaseModelEditing() {
+    const baseModelContent = document.querySelector('.base-model-content');
+    const editBtn = document.querySelector('.edit-base-model-btn');
+    
+    if (!baseModelContent || !editBtn) return;
+    
+    // Show edit button on hover
+    const baseModelDisplay = document.querySelector('.base-model-display');
+    baseModelDisplay.addEventListener('mouseenter', () => {
+        editBtn.classList.add('visible');
+    });
+    
+    baseModelDisplay.addEventListener('mouseleave', () => {
+        if (!baseModelDisplay.classList.contains('editing')) {
+            editBtn.classList.remove('visible');
+        }
+    });
+    
+    // Handle edit button click
+    editBtn.addEventListener('click', () => {
+        baseModelDisplay.classList.add('editing');
+        
+        // Store the original value to check for changes later
+        const originalValue = baseModelContent.textContent.trim();
+        
+        // Create dropdown selector to replace the base model content
+        const currentValue = originalValue;
+        const dropdown = document.createElement('select');
+        dropdown.className = 'base-model-selector';
+        
+        // Flag to track if a change was made
+        let valueChanged = false;
+        
+        // Add options from BASE_MODELS constants
+        const baseModelCategories = {
+            'Stable Diffusion 1.x': [BASE_MODELS.SD_1_4, BASE_MODELS.SD_1_5, BASE_MODELS.SD_1_5_LCM, BASE_MODELS.SD_1_5_HYPER],
+            'Stable Diffusion 2.x': [BASE_MODELS.SD_2_0, BASE_MODELS.SD_2_1],
+            'Stable Diffusion 3.x': [BASE_MODELS.SD_3, BASE_MODELS.SD_3_5, BASE_MODELS.SD_3_5_MEDIUM, BASE_MODELS.SD_3_5_LARGE, BASE_MODELS.SD_3_5_LARGE_TURBO],
+            'SDXL': [BASE_MODELS.SDXL, BASE_MODELS.SDXL_LIGHTNING, BASE_MODELS.SDXL_HYPER],
+            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
+            'Other Models': [
+                BASE_MODELS.FLUX_1_D, BASE_MODELS.FLUX_1_S, BASE_MODELS.AURAFLOW,
+                BASE_MODELS.PIXART_A, BASE_MODELS.PIXART_E, BASE_MODELS.HUNYUAN_1,
+                BASE_MODELS.LUMINA, BASE_MODELS.KOLORS, BASE_MODELS.NOOBAI,
+                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.UNKNOWN
+            ]
+        };
+        
+        // Create option groups for better organization
+        Object.entries(baseModelCategories).forEach(([category, models]) => {
+            const group = document.createElement('optgroup');
+            group.label = category;
+            
+            models.forEach(model => {
+                const option = document.createElement('option');
+                option.value = model;
+                option.textContent = model;
+                option.selected = model === currentValue;
+                group.appendChild(option);
+            });
+            
+            dropdown.appendChild(group);
+        });
+        
+        // Replace content with dropdown
+        baseModelContent.style.display = 'none';
+        baseModelDisplay.insertBefore(dropdown, editBtn);
+        
+        // Hide edit button during editing
+        editBtn.style.display = 'none';
+        
+        // Focus the dropdown
+        dropdown.focus();
+        
+        // Handle dropdown change
+        dropdown.addEventListener('change', function() {
+            const selectedModel = this.value;
+            baseModelContent.textContent = selectedModel;
+            
+            // Mark that a change was made if the value differs from original
+            if (selectedModel !== originalValue) {
+                valueChanged = true;
+            } else {
+                valueChanged = false;
+            }
+        });
+        
+        // Function to save changes and exit edit mode
+        const saveAndExit = function() {
+            // Check if dropdown still exists and remove it
+            if (dropdown && dropdown.parentNode === baseModelDisplay) {
+                baseModelDisplay.removeChild(dropdown);
+            }
+            
+            // Show the content and edit button
+            baseModelContent.style.display = '';
+            editBtn.style.display = '';
+            
+            // Remove editing class
+            baseModelDisplay.classList.remove('editing');
+            
+            // Only save if the value has actually changed
+            if (valueChanged || baseModelContent.textContent.trim() !== originalValue) {
+                // Get file path for saving
+                const filePath = document.querySelector('#loraModal .modal-content')
+                    .querySelector('.file-path').textContent + 
+                    document.querySelector('#loraModal .modal-content')
+                    .querySelector('#file-name').textContent + '.safetensors';
+                
+                // Save the changes, passing the original value for comparison
+                saveBaseModel(filePath, originalValue);
+            }
+            
+            // Remove this event listener
+            document.removeEventListener('click', outsideClickHandler);
+        };
+        
+        // Handle outside clicks to save and exit
+        const outsideClickHandler = function(e) {
+            // If click is outside the dropdown and base model display
+            if (!baseModelDisplay.contains(e.target)) {
+                saveAndExit();
+            }
+        };
+        
+        // Add delayed event listener for outside clicks
+        setTimeout(() => {
+            document.addEventListener('click', outsideClickHandler);
+        }, 0);
+        
+        // Also handle dropdown blur event
+        dropdown.addEventListener('blur', function(e) {
+            // Only save if the related target is not the edit button or inside the baseModelDisplay
+            if (!baseModelDisplay.contains(e.relatedTarget)) {
+                saveAndExit();
+            }
+        });
+    });
+}
+
+// New function to handle file name editing
+function setupFileNameEditing() {
+    const fileNameContent = document.querySelector('.file-name-content');
+    const editBtn = document.querySelector('.edit-file-name-btn');
+    
+    if (!fileNameContent || !editBtn) return;
+    
+    // Show edit button on hover
+    const fileNameWrapper = document.querySelector('.file-name-wrapper');
+    fileNameWrapper.addEventListener('mouseenter', () => {
+        editBtn.classList.add('visible');
+    });
+    
+    fileNameWrapper.addEventListener('mouseleave', () => {
+        if (!fileNameWrapper.classList.contains('editing')) {
+            editBtn.classList.remove('visible');
+        }
+    });
+    
+    // Handle edit button click
+    editBtn.addEventListener('click', () => {
+        fileNameWrapper.classList.add('editing');
+        fileNameContent.setAttribute('contenteditable', 'true');
+        fileNameContent.focus();
+        
+        // Store original value for comparison later
+        fileNameContent.dataset.originalValue = fileNameContent.textContent.trim();
+        
+        // Place cursor at the end
+        const range = document.createRange();
+        const sel = window.getSelection();
+        range.selectNodeContents(fileNameContent);
+        range.collapse(false);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        
+        editBtn.classList.add('visible');
+    });
+    
+    // Handle keyboard events in edit mode
+    fileNameContent.addEventListener('keydown', function(e) {
+        if (!this.getAttribute('contenteditable')) return;
+        
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            this.blur(); // Trigger save on Enter
+        } else if (e.key === 'Escape') {
+            e.preventDefault();
+            // Restore original value
+            this.textContent = this.dataset.originalValue;
+            exitEditMode();
+        }
+    });
+    
+    // Handle input validation
+    fileNameContent.addEventListener('input', function() {
+        if (!this.getAttribute('contenteditable')) return;
+        
+        // Replace invalid characters for filenames
+        const invalidChars = /[\\/:*?"<>|]/g;
+        if (invalidChars.test(this.textContent)) {
+            const cursorPos = window.getSelection().getRangeAt(0).startOffset;
+            this.textContent = this.textContent.replace(invalidChars, '');
+            
+            // Restore cursor position
+            const range = document.createRange();
+            const sel = window.getSelection();
+            const newPos = Math.min(cursorPos, this.textContent.length);
+            
+            if (this.firstChild) {
+                range.setStart(this.firstChild, newPos);
+                range.collapse(true);
+                sel.removeAllRanges();
+                sel.addRange(range);
+            }
+            
+            showToast('Invalid characters removed from filename', 'warning');
+        }
+    });
+    
+    // Handle focus out - save changes
+    fileNameContent.addEventListener('blur', async function() {
+        if (!this.getAttribute('contenteditable')) return;
+        
+        const newFileName = this.textContent.trim();
+        const originalValue = this.dataset.originalValue;
+        
+        // Basic validation
+        if (!newFileName) {
+            // Restore original value if empty
+            this.textContent = originalValue;
+            showToast('File name cannot be empty', 'error');
+            exitEditMode();
+            return;
+        }
+        
+        if (newFileName === originalValue) {
+            // No changes, just exit edit mode
+            exitEditMode();
+            return;
+        }
+        
+        try {
+            // Get the full file path
+            const filePath = document.querySelector('#loraModal .modal-content')
+                .querySelector('.file-path').textContent + originalValue + '.safetensors';
+                
+            // Call API to rename the file
+            const response = await fetch('/api/rename_lora', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    file_path: filePath,
+                    new_file_name: newFileName
+                })
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                showToast('File name updated successfully', 'success');
+                
+                // Update card in the gallery
+                const loraCard = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+                if (loraCard) {
+                    // Update the card's filepath attribute to the new path
+                    loraCard.dataset.filepath = result.new_file_path;
+                    loraCard.dataset.file_name = newFileName;
+                    
+                    // Update the filename display in the card
+                    const cardFileName = loraCard.querySelector('.card-filename');
+                    if (cardFileName) {
+                        cardFileName.textContent = newFileName;
+                    }
+                }
+                
+                // Handle the case where we need to reload the page
+                if (result.reload_required) {
+                    showToast('Reloading page to apply changes...', 'info');
+                    setTimeout(() => {
+                        window.location.reload();
+                    }, 1500);
+                }
+            } else {
+                // Show error and restore original filename
+                showToast(result.error || 'Failed to update file name', 'error');
+                this.textContent = originalValue;
+            }
+        } catch (error) {
+            console.error('Error saving filename:', error);
+            showToast('Failed to update file name', 'error');
+            this.textContent = originalValue;
+        } finally {
+            exitEditMode();
+        }
+    });
+    
+    function exitEditMode() {
+        fileNameContent.removeAttribute('contenteditable');
+        fileNameWrapper.classList.remove('editing');
+        editBtn.classList.remove('visible');
+    }
+}

static/js/components/RecipeCard.js

@@ -25,7 +25,7 @@ class RecipeCard {
         const lorasCount = loras.length;
         
         // Check if all LoRAs are available in the library
-        const missingLorasCount = loras.filter(lora => !lora.inLibrary).length;
+        const missingLorasCount = loras.filter(lora => !lora.inLibrary && !lora.isDeleted).length;
         const allLorasAvailable = missingLorasCount === 0 && lorasCount > 0;
         
         // Ensure file_url exists, fallback to file_path if needed
@@ -96,22 +96,24 @@ class RecipeCard {
     
     copyRecipeSyntax() {
         try {
-            // Generate recipe syntax in the format <lora:file_name:strength> separated by spaces
-            const loras = this.recipe.loras || [];
-            if (loras.length === 0) {
-                showToast('No LoRAs in this recipe to copy', 'warning');
+            // Get recipe ID
+            const recipeId = this.recipe.id;
+            if (!recipeId) {
+                showToast('Cannot copy recipe syntax: Missing recipe ID', 'error');
                 return;
             }
+
             
-            const syntax = loras.map(lora => {
-                // Use file_name if available, otherwise use empty placeholder
-                const fileName = lora.file_name || '[missing-lora]';
-                const strength = lora.strength || 1.0;
-                return `<lora:${fileName}:${strength}>`;
-            }).join(' ');
-            
-            // Copy to clipboard
-            navigator.clipboard.writeText(syntax)
+            // Fallback if button not found
+            fetch(`/api/recipe/${recipeId}/syntax`)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success && data.syntax) {
+                        return navigator.clipboard.writeText(data.syntax);
+                    } else {
+                        throw new Error(data.error || 'No syntax returned');
+                    }
+                })
                 .then(() => {
                     showToast('Recipe syntax copied to clipboard', 'success');
                 })

static/js/components/RecipeModal.js

@@ -1,5 +1,6 @@
 // Recipe Modal Component
 import { showToast } from '../utils/uiHelpers.js';
+import { state } from '../state/index.js';
 
 class RecipeModal {
     constructor() {
@@ -12,6 +13,25 @@ class RecipeModal {
         document.addEventListener('DOMContentLoaded', () => {
             this.setupTooltipPositioning();
         });
+        
+        // Set up document click handler to close edit fields
+        document.addEventListener('click', (event) => {
+            // Handle title edit
+            const titleEditor = document.getElementById('recipeTitleEditor');
+            if (titleEditor && titleEditor.classList.contains('active') && 
+                !titleEditor.contains(event.target) && 
+                !event.target.closest('.edit-icon')) {
+                this.saveTitleEdit();
+            }
+            
+            // Handle tags edit
+            const tagsEditor = document.getElementById('recipeTagsEditor');
+            if (tagsEditor && tagsEditor.classList.contains('active') && 
+                !tagsEditor.contains(event.target) && 
+                !event.target.closest('.edit-icon')) {
+                this.saveTagsEdit();
+            }
+        });
     }
     
     // Add tooltip positioning handler to ensure correct positioning of fixed tooltips
@@ -31,73 +51,153 @@ class RecipeModal {
                     tooltip.style.left = (badgeRect.right - tooltip.offsetWidth) + 'px';
                 }
             }
+            
+            // Add tooltip positioning for missing badge
+            if (event.target.closest('.recipe-status.missing')) {
+                const badge = event.target.closest('.recipe-status.missing');
+                const tooltip = badge.querySelector('.missing-tooltip');
+                
+                if (tooltip) {
+                    // Get badge position
+                    const badgeRect = badge.getBoundingClientRect();
+                    
+                    // Position the tooltip
+                    tooltip.style.top = (badgeRect.bottom + 4) + 'px';
+                    tooltip.style.left = (badgeRect.left) + 'px';
+                }
+            }
         }, true);
     }
     
     showRecipeDetails(recipe) {
-        // Set modal title
+        // Store the full recipe for editing
+        this.currentRecipe = JSON.parse(JSON.stringify(recipe)); // 深拷贝以避免对原始对象的修改
+        
+        // Set modal title with edit icon
         const modalTitle = document.getElementById('recipeModalTitle');
         if (modalTitle) {
-            modalTitle.textContent = recipe.title || 'Recipe Details';
+            modalTitle.innerHTML = `
+                <div class="editable-content">
+                    <span class="content-text">${recipe.title || 'Recipe Details'}</span>
+                    <button class="edit-icon" title="Edit recipe name"><i class="fas fa-pencil-alt"></i></button>
+                </div>
+                <div id="recipeTitleEditor" class="content-editor">
+                    <input type="text" class="title-input" value="${recipe.title || ''}">
+                </div>
+            `;
+            
+            // Add event listener for title editing
+            const editIcon = modalTitle.querySelector('.edit-icon');
+            editIcon.addEventListener('click', () => this.showTitleEditor());
+            
+            // Add key event listener for Enter key
+            const titleInput = modalTitle.querySelector('.title-input');
+            titleInput.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    this.saveTitleEdit();
+                } else if (e.key === 'Escape') {
+                    e.preventDefault();
+                    this.cancelTitleEdit();
+                }
+            });
         }
         
+        // Store the recipe ID for copy syntax API call
+        this.recipeId = recipe.id;
+        
         // Set recipe tags if they exist
         const tagsCompactElement = document.getElementById('recipeTagsCompact');
         const tagsTooltipContent = document.getElementById('recipeTagsTooltipContent');
         
-        if (tagsCompactElement && tagsTooltipContent && recipe.tags && recipe.tags.length > 0) {
-            // Clear previous tags
-            tagsCompactElement.innerHTML = '';
-            tagsTooltipContent.innerHTML = '';
+        if (tagsCompactElement) {
+            // Add tags container with edit functionality
+            tagsCompactElement.innerHTML = `
+                <div class="editable-content tags-content">
+                    <div class="tags-display"></div>
+                    <button class="edit-icon" title="Edit tags"><i class="fas fa-pencil-alt"></i></button>
+                </div>
+                <div id="recipeTagsEditor" class="content-editor tags-editor">
+                    <input type="text" class="tags-input" placeholder="Enter tags separated by commas">
+                </div>
+            `;
             
-            // Limit displayed tags to 5, show a "+X more" button if needed
-            const maxVisibleTags = 5;
-            const visibleTags = recipe.tags.slice(0, maxVisibleTags);
-            const remainingTags = recipe.tags.length > maxVisibleTags ? recipe.tags.slice(maxVisibleTags) : [];
+            const tagsDisplay = tagsCompactElement.querySelector('.tags-display');
             
-            // Add visible tags
-            visibleTags.forEach(tag => {
-                const tagElement = document.createElement('div');
-                tagElement.className = 'recipe-tag-compact';
-                tagElement.textContent = tag;
-                tagsCompactElement.appendChild(tagElement);
-            });
-            
-            // Add "more" button if needed
-            if (remainingTags.length > 0) {
-                const moreButton = document.createElement('div');
-                moreButton.className = 'recipe-tag-more';
-                moreButton.textContent = `+${remainingTags.length} more`;
-                tagsCompactElement.appendChild(moreButton);
+            if (recipe.tags && recipe.tags.length > 0) {
+                // Limit displayed tags to 5, show a "+X more" button if needed
+                const maxVisibleTags = 5;
+                const visibleTags = recipe.tags.slice(0, maxVisibleTags);
+                const remainingTags = recipe.tags.length > maxVisibleTags ? recipe.tags.slice(maxVisibleTags) : [];
                 
-                // Add tooltip functionality
-                moreButton.addEventListener('mouseenter', () => {
-                    document.getElementById('recipeTagsTooltip').classList.add('visible');
+                // Add visible tags
+                visibleTags.forEach(tag => {
+                    const tagElement = document.createElement('div');
+                    tagElement.className = 'recipe-tag-compact';
+                    tagElement.textContent = tag;
+                    tagsDisplay.appendChild(tagElement);
                 });
                 
-                moreButton.addEventListener('mouseleave', () => {
-                    setTimeout(() => {
-                        if (!document.getElementById('recipeTagsTooltip').matches(':hover')) {
-                            document.getElementById('recipeTagsTooltip').classList.remove('visible');
-                        }
-                    }, 300);
-                });
-                
-                document.getElementById('recipeTagsTooltip').addEventListener('mouseleave', () => {
-                    document.getElementById('recipeTagsTooltip').classList.remove('visible');
-                });
-                
-                // Add all tags to tooltip
-                recipe.tags.forEach(tag => {
-                    const tooltipTag = document.createElement('div');
-                    tooltipTag.className = 'tooltip-tag';
-                    tooltipTag.textContent = tag;
-                    tagsTooltipContent.appendChild(tooltipTag);
-                });
+                // Add "more" button if needed
+                if (remainingTags.length > 0) {
+                    const moreButton = document.createElement('div');
+                    moreButton.className = 'recipe-tag-more';
+                    moreButton.textContent = `+${remainingTags.length} more`;
+                    tagsDisplay.appendChild(moreButton);
+                    
+                    // Add tooltip functionality
+                    moreButton.addEventListener('mouseenter', () => {
+                        document.getElementById('recipeTagsTooltip').classList.add('visible');
+                    });
+                    
+                    moreButton.addEventListener('mouseleave', () => {
+                        setTimeout(() => {
+                            if (!document.getElementById('recipeTagsTooltip').matches(':hover')) {
+                                document.getElementById('recipeTagsTooltip').classList.remove('visible');
+                            }
+                        }, 300);
+                    });
+                    
+                    document.getElementById('recipeTagsTooltip').addEventListener('mouseleave', () => {
+                        document.getElementById('recipeTagsTooltip').classList.remove('visible');
+                    });
+                    
+                    // Add all tags to tooltip
+                    if (tagsTooltipContent) {
+                        tagsTooltipContent.innerHTML = '';
+                        recipe.tags.forEach(tag => {
+                            const tooltipTag = document.createElement('div');
+                            tooltipTag.className = 'tooltip-tag';
+                            tooltipTag.textContent = tag;
+                            tagsTooltipContent.appendChild(tooltipTag);
+                        });
+                    }
+                }
+            } else {
+                tagsDisplay.innerHTML = '<div class="no-tags">No tags</div>';
             }
-        } else if (tagsCompactElement) {
-            // No tags to display
-            tagsCompactElement.innerHTML = '';
+            
+            // Add event listeners for tags editing
+            const editTagsIcon = tagsCompactElement.querySelector('.edit-icon');
+            const tagsInput = tagsCompactElement.querySelector('.tags-input');
+            
+            // Set current tags in the input
+            if (recipe.tags && recipe.tags.length > 0) {
+                tagsInput.value = recipe.tags.join(', ');
+            }
+            
+            editTagsIcon.addEventListener('click', () => this.showTagsEditor());
+            
+            // Add key event listener for Enter key
+            tagsInput.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    this.saveTagsEdit();
+                } else if (e.key === 'Escape') {
+                    e.preventDefault();
+                    this.cancelTagsEdit();
+                }
+            });
         }
         
         // Set recipe image
@@ -107,8 +207,33 @@ class RecipeModal {
             const imageUrl = recipe.file_url || 
                             (recipe.file_path ? `/loras_static/root1/preview/${recipe.file_path.split('/').pop()}` : 
                             '/loras_static/images/no-preview.png');
-            modalImage.src = imageUrl;
-            modalImage.alt = recipe.title || 'Recipe Preview';
+            
+            // Check if the file is a video (mp4)
+            const isVideo = imageUrl.toLowerCase().endsWith('.mp4');
+            
+            // Replace the image element with appropriate media element
+            const mediaContainer = modalImage.parentElement;
+            mediaContainer.innerHTML = '';
+            
+            if (isVideo) {
+                const videoElement = document.createElement('video');
+                videoElement.id = 'recipeModalVideo';
+                videoElement.src = imageUrl;
+                videoElement.controls = true;
+                videoElement.autoplay = false;
+                videoElement.loop = true;
+                videoElement.muted = true;
+                videoElement.className = 'recipe-preview-media';
+                videoElement.alt = recipe.title || 'Recipe Preview';
+                mediaContainer.appendChild(videoElement);
+            } else {
+                const imgElement = document.createElement('img');
+                imgElement.id = 'recipeModalImage';
+                imgElement.src = imageUrl;
+                imgElement.className = 'recipe-preview-media';
+                imgElement.alt = recipe.title || 'Recipe Preview';
+                mediaContainer.appendChild(imgElement);
+            }
         }
         
         // Set generation parameters
@@ -167,55 +292,104 @@ class RecipeModal {
         const lorasListElement = document.getElementById('recipeLorasList');
         const lorasCountElement = document.getElementById('recipeLorasCount');
         
-        // 检查所有 LoRAs 是否都在库中
+        // Check all LoRAs status
         let allLorasAvailable = true;
         let missingLorasCount = 0;
+        let deletedLorasCount = 0;
         
         if (recipe.loras && recipe.loras.length > 0) {
             recipe.loras.forEach(lora => {
-                if (!lora.inLibrary) {
+                if (lora.isDeleted) {
+                    deletedLorasCount++;
+                } else if (!lora.inLibrary) {
                     allLorasAvailable = false;
                     missingLorasCount++;
                 }
             });
         }
         
-        // 设置 LoRAs 计数和状态
+        // Set LoRAs count and status
         if (lorasCountElement && recipe.loras) {
             const totalCount = recipe.loras.length;
             
-            // 创建状态指示器
+            // Create status indicator based on LoRA states
             let statusHTML = '';
             if (totalCount > 0) {
-                if (allLorasAvailable) {
+                if (allLorasAvailable && deletedLorasCount === 0) {
+                    // All LoRAs are available
                     statusHTML = `<div class="recipe-status ready"><i class="fas fa-check-circle"></i> Ready to use</div>`;
-                } else {
-                    statusHTML = `<div class="recipe-status missing"><i class="fas fa-exclamation-triangle"></i> ${missingLorasCount} missing</div>`;
+                } else if (missingLorasCount > 0) {
+                    // Some LoRAs are missing (prioritize showing missing over deleted)
+                    statusHTML = `<div class="recipe-status missing">
+                        <i class="fas fa-exclamation-triangle"></i> ${missingLorasCount} missing
+                        <div class="missing-tooltip">Click to download missing LoRAs</div>
+                    </div>`;
+                } else if (deletedLorasCount > 0 && missingLorasCount === 0) {
+                    // Some LoRAs are deleted but none are missing
+                    statusHTML = `<div class="recipe-status partial"><i class="fas fa-info-circle"></i> ${deletedLorasCount} deleted</div>`;
                 }
             }
             
             lorasCountElement.innerHTML = `<i class="fas fa-layer-group"></i> ${totalCount} LoRAs ${statusHTML}`;
+            
+            // Add click handler for missing LoRAs status
+            setTimeout(() => {
+                const missingStatus = document.querySelector('.recipe-status.missing');
+                if (missingStatus && missingLorasCount > 0) {
+                    missingStatus.classList.add('clickable');
+                    missingStatus.addEventListener('click', () => this.showDownloadMissingLorasModal());
+                }
+            }, 100);
         }
         
         if (lorasListElement && recipe.loras && recipe.loras.length > 0) {
             lorasListElement.innerHTML = recipe.loras.map(lora => {
                 const existsLocally = lora.inLibrary;
+                const isDeleted = lora.isDeleted;
                 const localPath = lora.localPath || '';
                 
-                // Create local status badge with a more stable structure
-                const localStatus = existsLocally ? 
-                    `<div class="local-badge">
-                        <i class="fas fa-check"></i> In Library
-                        <div class="local-path">${localPath}</div>
-                     </div>` : 
-                    `<div class="missing-badge">
-                        <i class="fas fa-exclamation-triangle"></i> Not in Library
-                     </div>`;
+                // Create status badge based on LoRA state
+                let localStatus;
+                if (existsLocally) {
+                    localStatus = `
+                        <div class="local-badge">
+                            <i class="fas fa-check"></i> In Library
+                            <div class="local-path">${localPath}</div>
+                        </div>`;
+                } else if (isDeleted) {
+                    localStatus = `
+                        <div class="deleted-badge">
+                            <i class="fas fa-trash-alt"></i> Deleted
+                        </div>`;
+                } else {
+                    localStatus = `
+                        <div class="missing-badge">
+                            <i class="fas fa-exclamation-triangle"></i> Not in Library
+                        </div>`;
+                }
+
+                // Check if preview is a video
+                const isPreviewVideo = lora.preview_url && lora.preview_url.toLowerCase().endsWith('.mp4');
+                const previewMedia = isPreviewVideo ?
+                    `<video class="thumbnail-video" autoplay loop muted playsinline>
+                        <source src="${lora.preview_url}" type="video/mp4">
+                     </video>` :
+                    `<img src="${lora.preview_url || '/loras_static/images/no-preview.png'}" alt="LoRA preview">`;
+
+                // Determine CSS class based on LoRA state
+                let loraItemClass = 'recipe-lora-item';
+                if (existsLocally) {
+                    loraItemClass += ' exists-locally';
+                } else if (isDeleted) {
+                    loraItemClass += ' is-deleted';
+                } else {
+                    loraItemClass += ' missing-locally';
+                }
 
                 return `
-                    <div class="recipe-lora-item ${existsLocally ? 'exists-locally' : 'missing-locally'}">
+                    <div class="${loraItemClass}">
                         <div class="recipe-lora-thumbnail">
-                            <img src="${lora.preview_url || '/loras_static/images/no-preview.png'}" alt="LoRA preview">
+                            ${previewMedia}
                         </div>
                         <div class="recipe-lora-content">
                             <div class="recipe-lora-header">
@@ -232,20 +406,263 @@ class RecipeModal {
                 `;
             }).join('');
             
-            // Generate recipe syntax for copy button
-            this.recipeLorasSyntax = recipe.loras.map(lora => 
-                `<lora:${lora.file_name}:${lora.strength || 1.0}>`
-            ).join(' ');
+            // Generate recipe syntax for copy button (this is now a placeholder, actual syntax will be fetched from the API)
+            this.recipeLorasSyntax = '';
             
         } else if (lorasListElement) {
             lorasListElement.innerHTML = '<div class="no-loras">No LoRAs associated with this recipe</div>';
             this.recipeLorasSyntax = '';
         }
+
+        console.log(this.currentRecipe.loras);
         
         // Show the modal
         modalManager.showModal('recipeModal');
     }
     
+    // Title editing methods
+    showTitleEditor() {
+        const titleContainer = document.getElementById('recipeModalTitle');
+        if (titleContainer) {
+            titleContainer.querySelector('.editable-content').classList.add('hide');
+            const editor = titleContainer.querySelector('#recipeTitleEditor');
+            editor.classList.add('active');
+            const input = editor.querySelector('input');
+            input.focus();
+            input.select();
+        }
+    }
+    
+    saveTitleEdit() {
+        const titleContainer = document.getElementById('recipeModalTitle');
+        if (titleContainer) {
+            const editor = titleContainer.querySelector('#recipeTitleEditor');
+            const input = editor.querySelector('input');
+            const newTitle = input.value.trim();
+            
+            // Check if title changed
+            if (newTitle && newTitle !== this.currentRecipe.title) {
+                // Update title in the UI
+                titleContainer.querySelector('.content-text').textContent = newTitle;
+                
+                // Update the recipe on the server
+                this.updateRecipeMetadata({ title: newTitle });
+            }
+            
+            // Hide editor
+            editor.classList.remove('active');
+            titleContainer.querySelector('.editable-content').classList.remove('hide');
+        }
+    }
+    
+    cancelTitleEdit() {
+        const titleContainer = document.getElementById('recipeModalTitle');
+        if (titleContainer) {
+            // Reset input value
+            const editor = titleContainer.querySelector('#recipeTitleEditor');
+            const input = editor.querySelector('input');
+            input.value = this.currentRecipe.title || '';
+            
+            // Hide editor
+            editor.classList.remove('active');
+            titleContainer.querySelector('.editable-content').classList.remove('hide');
+        }
+    }
+    
+    // Tags editing methods
+    showTagsEditor() {
+        const tagsContainer = document.getElementById('recipeTagsCompact');
+        if (tagsContainer) {
+            tagsContainer.querySelector('.editable-content').classList.add('hide');
+            const editor = tagsContainer.querySelector('#recipeTagsEditor');
+            editor.classList.add('active');
+            const input = editor.querySelector('input');
+            input.focus();
+        }
+    }
+    
+    saveTagsEdit() {
+        const tagsContainer = document.getElementById('recipeTagsCompact');
+        if (tagsContainer) {
+            const editor = tagsContainer.querySelector('#recipeTagsEditor');
+            const input = editor.querySelector('input');
+            const tagsText = input.value.trim();
+            
+            // Parse tags
+            let newTags = [];
+            if (tagsText) {
+                newTags = tagsText.split(',')
+                    .map(tag => tag.trim())
+                    .filter(tag => tag.length > 0);
+            }
+            
+            // Check if tags changed
+            const oldTags = this.currentRecipe.tags || [];
+            const tagsChanged = 
+                newTags.length !== oldTags.length || 
+                newTags.some((tag, index) => tag !== oldTags[index]);
+            
+            if (tagsChanged) {
+                // Update the recipe on the server
+                this.updateRecipeMetadata({ tags: newTags });
+                
+                // Update tags in the UI
+                const tagsDisplay = tagsContainer.querySelector('.tags-display');
+                tagsDisplay.innerHTML = '';
+                
+                if (newTags.length > 0) {
+                    // Limit displayed tags to 5, show a "+X more" button if needed
+                    const maxVisibleTags = 5;
+                    const visibleTags = newTags.slice(0, maxVisibleTags);
+                    const remainingTags = newTags.length > maxVisibleTags ? newTags.slice(maxVisibleTags) : [];
+                    
+                    // Add visible tags
+                    visibleTags.forEach(tag => {
+                        const tagElement = document.createElement('div');
+                        tagElement.className = 'recipe-tag-compact';
+                        tagElement.textContent = tag;
+                        tagsDisplay.appendChild(tagElement);
+                    });
+                    
+                    // Add "more" button if needed
+                    if (remainingTags.length > 0) {
+                        const moreButton = document.createElement('div');
+                        moreButton.className = 'recipe-tag-more';
+                        moreButton.textContent = `+${remainingTags.length} more`;
+                        tagsDisplay.appendChild(moreButton);
+                        
+                        // Update tooltip content
+                        const tooltipContent = document.getElementById('recipeTagsTooltipContent');
+                        if (tooltipContent) {
+                            tooltipContent.innerHTML = '';
+                            newTags.forEach(tag => {
+                                const tooltipTag = document.createElement('div');
+                                tooltipTag.className = 'tooltip-tag';
+                                tooltipTag.textContent = tag;
+                                tooltipContent.appendChild(tooltipTag);
+                            });
+                        }
+                        
+                        // Re-add tooltip functionality
+                        moreButton.addEventListener('mouseenter', () => {
+                            document.getElementById('recipeTagsTooltip').classList.add('visible');
+                        });
+                        
+                        moreButton.addEventListener('mouseleave', () => {
+                            setTimeout(() => {
+                                if (!document.getElementById('recipeTagsTooltip').matches(':hover')) {
+                                    document.getElementById('recipeTagsTooltip').classList.remove('visible');
+                                }
+                            }, 300);
+                        });
+                    }
+                } else {
+                    tagsDisplay.innerHTML = '<div class="no-tags">No tags</div>';
+                }
+                
+                // Update the current recipe object
+                this.currentRecipe.tags = newTags;
+            }
+            
+            // Hide editor
+            editor.classList.remove('active');
+            tagsContainer.querySelector('.editable-content').classList.remove('hide');
+        }
+    }
+    
+    cancelTagsEdit() {
+        const tagsContainer = document.getElementById('recipeTagsCompact');
+        if (tagsContainer) {
+            // Reset input value
+            const editor = tagsContainer.querySelector('#recipeTagsEditor');
+            const input = editor.querySelector('input');
+            input.value = this.currentRecipe.tags ? this.currentRecipe.tags.join(', ') : '';
+            
+            // Hide editor
+            editor.classList.remove('active');
+            tagsContainer.querySelector('.editable-content').classList.remove('hide');
+        }
+    }
+    
+    // Update recipe metadata on the server
+    async updateRecipeMetadata(updates) {
+        try {
+            const response = await fetch(`/api/recipe/${this.recipeId}/update`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(updates)
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                // 显示保存成功的提示
+                if (updates.title) {
+                    showToast('Recipe name updated successfully', 'success');
+                } else if (updates.tags) {
+                    showToast('Recipe tags updated successfully', 'success');
+                } else {
+                    showToast('Recipe updated successfully', 'success');
+                }
+                
+                // 更新当前recipe对象的属性
+                Object.assign(this.currentRecipe, updates);
+                
+                // 确保这个更新也传播到卡片视图
+                // 尝试找到可能显示这个recipe的卡片并更新它
+                try {
+                    const recipeCards = document.querySelectorAll('.recipe-card');
+                    recipeCards.forEach(card => {
+                        if (card.dataset.recipeId === this.recipeId) {
+                            // 更新卡片标题
+                            if (updates.title) {
+                                const titleElement = card.querySelector('.recipe-title');
+                                if (titleElement) {
+                                    titleElement.textContent = updates.title;
+                                }
+                            }
+                            
+                            // 更新卡片标签
+                            if (updates.tags) {
+                                const tagsElement = card.querySelector('.recipe-tags');
+                                if (tagsElement) {
+                                    if (updates.tags.length > 0) {
+                                        tagsElement.innerHTML = updates.tags.map(
+                                            tag => `<div class="recipe-tag">${tag}</div>`
+                                        ).join('');
+                                    } else {
+                                        tagsElement.innerHTML = '';
+                                    }
+                                }
+                            }
+                        }
+                    });
+                } catch (err) {
+                    console.log("Non-critical error updating recipe cards:", err);
+                }
+                
+                // 重要：强制刷新recipes列表，确保从服务器获取最新数据
+                try {
+                    if (window.recipeManager && typeof window.recipeManager.loadRecipes === 'function') {
+                        // 异步刷新recipes列表，不阻塞用户界面
+                        setTimeout(() => {
+                            window.recipeManager.loadRecipes(true);
+                        }, 500);
+                    }
+                } catch (err) {
+                    console.log("Error refreshing recipes list:", err);
+                }
+            } else {
+                showToast(`Failed to update recipe: ${data.error}`, 'error');
+            }
+        } catch (error) {
+            console.error('Error updating recipe:', error);
+            showToast(`Error updating recipe: ${error.message}`, 'error');
+        }
+    }
+    
     // Setup copy buttons for prompts and recipe syntax
     setupCopyButtons() {
         const copyPromptBtn = document.getElementById('copyPromptBtn');
@@ -268,11 +685,42 @@ class RecipeModal {
         
         if (copyRecipeSyntaxBtn) {
             copyRecipeSyntaxBtn.addEventListener('click', () => {
-                this.copyToClipboard(this.recipeLorasSyntax, 'Recipe syntax copied to clipboard');
+                // Use backend API to get recipe syntax
+                this.fetchAndCopyRecipeSyntax();
             });
         }
     }
     
+    // Fetch recipe syntax from backend and copy to clipboard
+    async fetchAndCopyRecipeSyntax() {
+        if (!this.recipeId) {
+            showToast('No recipe ID available', 'error');
+            return;
+        }
+        
+        try {
+            // Fetch recipe syntax from backend
+            const response = await fetch(`/api/recipe/${this.recipeId}/syntax`);
+            
+            if (!response.ok) {
+                throw new Error(`Failed to get recipe syntax: ${response.statusText}`);
+            }
+            
+            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');
+            } else {
+                throw new Error(data.error || 'No syntax returned from server');
+            }
+        } catch (error) {
+            console.error('Error fetching recipe syntax:', error);
+            showToast(`Error copying recipe syntax: ${error.message}`, 'error');
+        }
+    }
+    
     // Helper method to copy text to clipboard
     copyToClipboard(text, successMessage) {
         navigator.clipboard.writeText(text).then(() => {
@@ -282,6 +730,105 @@ class RecipeModal {
             showToast('Failed to copy text', 'error');
         });
     }
+
+    // Add new method to handle downloading missing LoRAs
+    async showDownloadMissingLorasModal() {
+        console.log("currentRecipe", this.currentRecipe);
+        // Get missing LoRAs from the current recipe
+        const missingLoras = this.currentRecipe.loras.filter(lora => !lora.inLibrary);
+        console.log("missingLoras", missingLoras);
+        
+        if (missingLoras.length === 0) {
+            showToast('No missing LoRAs to download', 'info');
+            return;
+        }
+
+        try {
+            state.loadingManager.showSimpleLoading('Getting version info for missing LoRAs...');
+
+            // Get version info for each missing LoRA by calling the appropriate API endpoint
+            const missingLorasWithVersionInfoPromises = missingLoras.map(async lora => {
+                let endpoint;
+                
+                // Determine which endpoint to use based on available data
+                if (lora.modelVersionId) {
+                    endpoint = `/api/civitai/model/${lora.modelVersionId}`;
+                } else if (lora.hash) {
+                    endpoint = `/api/civitai/model/${lora.hash}`;
+                } else {
+                    console.error("Missing both hash and modelVersionId for lora:", lora);
+                    return null;
+                }
+                
+                const response = await fetch(endpoint);
+                const versionInfo = await response.json();
+                
+                // Return original lora data combined with version info
+                return {
+                    ...lora,
+                    civitaiInfo: versionInfo
+                };
+            });
+            
+            // Wait for all API calls to complete
+            const lorasWithVersionInfo = await Promise.all(missingLorasWithVersionInfoPromises);
+            console.log("Loras with version info:", lorasWithVersionInfo);
+            
+            // Filter out null values (failed requests)
+            const validLoras = lorasWithVersionInfo.filter(lora => lora !== null);
+            
+            if (validLoras.length === 0) {
+                showToast('Failed to get information for missing LoRAs', 'error');
+                return;
+            }
+            
+            // Close the recipe modal first
+            modalManager.closeModal('recipeModal');
+            
+            // Prepare data for import manager using the retrieved information
+            const recipeData = {
+                loras: validLoras.map(lora => {
+                    const civitaiInfo = lora.civitaiInfo;
+                    const modelFile = civitaiInfo.files ? 
+                        civitaiInfo.files.find(file => file.type === 'Model') : null;
+                    
+                    return {
+                        // Basic lora info
+                        name: civitaiInfo.model?.name || lora.name,
+                        version: civitaiInfo.name || '',
+                        strength: lora.strength || 1.0,
+                        
+                        // Model identifiers
+                        hash: modelFile?.hashes?.SHA256?.toLowerCase() || lora.hash,
+                        modelVersionId: civitaiInfo.id || lora.modelVersionId,
+                        
+                        // Metadata
+                        thumbnailUrl: civitaiInfo.images?.[0]?.url || '',
+                        baseModel: civitaiInfo.baseModel || '',
+                        downloadUrl: civitaiInfo.downloadUrl || '',
+                        size: modelFile ? (modelFile.sizeKB * 1024) : 0,
+                        file_name: modelFile ? modelFile.name.split('.')[0] : '',
+                        
+                        // Status flags
+                        existsLocally: false,
+                        isDeleted: civitaiInfo.error === "Model not found",
+                        isEarlyAccess: !!civitaiInfo.earlyAccessEndsAt,
+                        earlyAccessEndsAt: civitaiInfo.earlyAccessEndsAt || ''
+                    };
+                })
+            };
+            
+            console.log("recipeData for import:", recipeData);
+            
+            // Call ImportManager's download missing LoRAs method
+            window.importManager.downloadMissingLoras(recipeData, this.currentRecipe.id);
+        } catch (error) {
+            console.error("Error downloading missing LoRAs:", error);
+            showToast('Error preparing LoRAs for download', 'error');
+        } finally {
+            state.loadingManager.hide();
+        }
+    }
 }
 
 export { RecipeModal }; 

static/js/managers/ImportManager.js

@@ -26,7 +26,7 @@ export class ImportManager {
         this.importMode = 'upload'; // Default mode: 'upload' or 'url'
     }
 
-    showImportModal() {
+    showImportModal(recipeData = null, recipeId = null) {
         if (!this.initialized) {
             // Check if modal exists
             const modal = document.getElementById('importModal');
@@ -39,6 +39,10 @@ export class ImportManager {
         
         // Always reset the state when opening the modal
         this.resetSteps();
+        if (recipeData) {
+            this.downloadableLoRAs = recipeData.loras;
+            this.recipeId = recipeId;
+        }
         
         // Show the modal
         modalManager.showModal('importModal', null, () => {
@@ -116,6 +120,7 @@ export class ImportManager {
         this.recipeName = '';
         this.recipeTags = [];
         this.missingLoras = [];
+        this.downloadableLoRAs = [];
         
         // Reset import mode to upload
         this.importMode = 'upload';
@@ -398,7 +403,7 @@ export class ImportManager {
                 }
             }
         }
-        
+
         // Update LoRA count information
         const totalLoras = this.recipeData.loras.length;
         const existingLoras = this.recipeData.loras.filter(lora => lora.existsLocally).length;
@@ -548,33 +553,24 @@ export class ImportManager {
                 <div class="warning-icon"><i class="fas fa-exclamation-triangle"></i></div>
                 <div class="warning-content">
                     <div class="warning-title">${deletedLoras} LoRA(s) have been deleted from Civitai</div>
-                    <div class="warning-text">These LoRAs cannot be downloaded. If you continue, they will be removed from the recipe.</div>
+                    <div class="warning-text">These LoRAs cannot be downloaded. If you continue, they will remain in the recipe but won't be included when used.</div>
                 </div>
             `;
             
             // Insert before the buttons container
             buttonsContainer.parentNode.insertBefore(warningContainer, buttonsContainer);
+        }
             
-            // Update next button text to be more clear
-            nextButton.textContent = 'Continue Without Deleted LoRAs';
+        // If we have missing LoRAs (not deleted), show "Download Missing LoRAs"
+        // Otherwise show "Save Recipe"
+        const missingNotDeleted = this.recipeData.loras.filter(
+            lora => !lora.existsLocally && !lora.isDeleted
+        ).length;
+        
+        if (missingNotDeleted > 0) {
+            nextButton.textContent = 'Download Missing LoRAs';
         } else {
-            // Remove warning if no deleted LoRAs
-            const warningMsg = document.getElementById('deletedLorasWarning');
-            if (warningMsg) {
-                warningMsg.remove();
-            }
-            
-            // If we have missing LoRAs (not deleted), show "Download Missing LoRAs"
-            // Otherwise show "Save Recipe"
-            const missingNotDeleted = this.recipeData.loras.filter(
-                lora => !lora.existsLocally && !lora.isDeleted
-            ).length;
-            
-            if (missingNotDeleted > 0) {
-                nextButton.textContent = 'Download Missing LoRAs';
-            } else {
-                nextButton.textContent = 'Save Recipe';
-            }
+            nextButton.textContent = 'Save Recipe';
         }
     }
 
@@ -839,219 +835,233 @@ export class ImportManager {
     }
 
     async saveRecipe() {
-        if (!this.recipeName) {
+        // Check if we're in download-only mode (for existing recipe)
+        const isDownloadOnly = !!this.recipeId;
+
+        console.log("isDownloadOnly", isDownloadOnly);
+        
+        if (!isDownloadOnly && !this.recipeName) {
             showToast('Please enter a recipe name', 'error');
             return;
         }
         
         try {
-            // First save the recipe
-            this.loadingManager.showSimpleLoading('Saving recipe...');
+            this.loadingManager.showSimpleLoading(isDownloadOnly ? 'Preparing download...' : 'Saving recipe...');
             
-            // Create form data for save request
-            const formData = new FormData();
-            
-            // Handle image data - either from file upload or from URL mode
-            if (this.recipeImage) {
-                // File upload mode
-                formData.append('image', this.recipeImage);
-            } else if (this.recipeData && this.recipeData.image_base64) {
-                // URL mode with base64 data
-                formData.append('image_base64', this.recipeData.image_base64);
-            } else if (this.importMode === 'url') {
-                // Fallback for URL mode - tell backend to fetch the image again
-                const urlInput = document.getElementById('imageUrlInput');
-                if (urlInput && urlInput.value) {
-                    formData.append('image_url', urlInput.value);
+            // If we're only downloading LoRAs for an existing recipe, skip the recipe save step
+            if (!isDownloadOnly) {
+                // First save the recipe
+                // Create form data for save request
+                const formData = new FormData();
+                
+                // Handle image data - either from file upload or from URL mode
+                if (this.recipeImage) {
+                    // File upload mode
+                    formData.append('image', this.recipeImage);
+                } else if (this.recipeData && this.recipeData.image_base64) {
+                    // URL mode with base64 data
+                    formData.append('image_base64', this.recipeData.image_base64);
+                } else if (this.importMode === 'url') {
+                    // Fallback for URL mode - tell backend to fetch the image again
+                    const urlInput = document.getElementById('imageUrlInput');
+                    if (urlInput && urlInput.value) {
+                        formData.append('image_url', urlInput.value);
+                    } else {
+                        throw new Error('No image data available');
+                    }
                 } else {
                     throw new Error('No image data available');
                 }
-            } else {
-                throw new Error('No image data available');
+                
+                formData.append('name', this.recipeName);
+                formData.append('tags', JSON.stringify(this.recipeTags));
+                
+                // Prepare complete metadata including generation parameters
+                const completeMetadata = {
+                    base_model: this.recipeData.base_model || "",
+                    loras: this.recipeData.loras || [],
+                    gen_params: this.recipeData.gen_params || {},
+                    raw_metadata: this.recipeData.raw_metadata || {}
+                };
+                
+                formData.append('metadata', JSON.stringify(completeMetadata));
+            
+                // Send save request
+                const response = await fetch('/api/recipes/save', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                const result = await response.json();
+
+                if (!result.success) {
+                    // Handle save error
+                    console.error("Failed to save recipe:", result.error);
+                    showToast(result.error, 'error');
+                    // Close modal
+                    modalManager.closeModal('importModal');
+                    return;
+                }
             }
-            
-            formData.append('name', this.recipeName);
-            formData.append('tags', JSON.stringify(this.recipeTags));
-            
-            // Prepare complete metadata including generation parameters
-            const completeMetadata = {
-                base_model: this.recipeData.base_model || "",
-                loras: this.recipeData.loras || [],
-                gen_params: this.recipeData.gen_params || {},
-                raw_metadata: this.recipeData.raw_metadata || {}
-            };
-            
-            formData.append('metadata', JSON.stringify(completeMetadata));
-            
-            // Send save request
-            const response = await fetch('/api/recipes/save', {
-                method: 'POST',
-                body: formData
-            });
-            
-            const result = await response.json();
-            if (result.success) {
-                // Handle successful save
+
+            // Check if we need to download LoRAs
+            let failedDownloads = 0;
+            if (this.downloadableLoRAs && this.downloadableLoRAs.length > 0) {
+                // For download, we need to validate the target path
+                const loraRoot = document.getElementById('importLoraRoot')?.value;
+                if (!loraRoot) {
+                    throw new Error('Please select a LoRA root directory');
+                }
                 
+                // Build target path
+                let targetPath = loraRoot;
+                if (this.selectedFolder) {
+                    targetPath += '/' + this.selectedFolder;
+                }
                 
-                // Check if we need to download LoRAs
-                if (this.downloadableLoRAs && this.downloadableLoRAs.length > 0) {
-                    // For download, we need to validate the target path
-                    const loraRoot = document.getElementById('importLoraRoot')?.value;
-                    if (!loraRoot) {
-                        throw new Error('Please select a LoRA root directory');
-                    }
-                    
-                    // Build target path
-                    let targetPath = loraRoot;
-                    if (this.selectedFolder) {
-                        targetPath += '/' + this.selectedFolder;
-                    }
-                    
-                    const newFolder = document.getElementById('importNewFolder')?.value?.trim();
-                    if (newFolder) {
-                        targetPath += '/' + newFolder;
-                    }
-                    
-                    // Set up WebSocket for progress updates
-                    const wsProtocol = window.location.protocol === 'https:' ? 'wss://' : 'ws://';
-                    const ws = new WebSocket(`${wsProtocol}${window.location.host}/ws/fetch-progress`);
-                    
-                    // Show enhanced loading with progress details for multiple items
-                    const updateProgress = this.loadingManager.showDownloadProgress(this.downloadableLoRAs.length);
-                    
-                    let completedDownloads = 0;
-                    let failedDownloads = 0;
-                    let earlyAccessFailures = 0;
-                    let currentLoraProgress = 0;
-                    
-                    // Set up progress tracking for current download
-                    ws.onmessage = (event) => {
-                        const data = JSON.parse(event.data);
-                        if (data.status === 'progress') {
-                            // Update current LoRA progress
-                            currentLoraProgress = data.progress;
-                            
-                            // Get current LoRA name
-                            const currentLora = this.downloadableLoRAs[completedDownloads + failedDownloads];
-                            const loraName = currentLora ? currentLora.name : '';
-                            
-                            // Update progress display
-                            updateProgress(currentLoraProgress, completedDownloads, loraName);
-                            
-                            // Add more detailed status messages based on progress
-                            if (currentLoraProgress < 3) {
-                                this.loadingManager.setStatus(
-                                    `Preparing download for LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
-                                );
-                            } else if (currentLoraProgress === 3) {
-                                this.loadingManager.setStatus(
-                                    `Downloaded preview for LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
-                                );
-                            } else if (currentLoraProgress > 3 && currentLoraProgress < 100) {
-                                this.loadingManager.setStatus(
-                                    `Downloading LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
-                                );
-                            } else {
-                                this.loadingManager.setStatus(
-                                    `Finalizing LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
-                                );
-                            }
-                        }
-                    };
-                    
-                    for (let i = 0; i < this.downloadableLoRAs.length; i++) {
-                        const lora = this.downloadableLoRAs[i];
+                const newFolder = document.getElementById('importNewFolder')?.value?.trim();
+                if (newFolder) {
+                    targetPath += '/' + newFolder;
+                }
+                
+                // Set up WebSocket for progress updates
+                const wsProtocol = window.location.protocol === 'https:' ? 'wss://' : 'ws://';
+                const ws = new WebSocket(`${wsProtocol}${window.location.host}/ws/fetch-progress`);
+                
+                // Show enhanced loading with progress details for multiple items
+                const updateProgress = this.loadingManager.showDownloadProgress(this.downloadableLoRAs.length);
+                
+                let completedDownloads = 0;
+                let accessFailures = 0;
+                let currentLoraProgress = 0;
+                
+                // Set up progress tracking for current download
+                ws.onmessage = (event) => {
+                    const data = JSON.parse(event.data);
+                    if (data.status === 'progress') {
+                        // Update current LoRA progress
+                        currentLoraProgress = data.progress;
                         
-                        // Reset current LoRA progress for new download
-                        currentLoraProgress = 0;
+                        // Get current LoRA name
+                        const currentLora = this.downloadableLoRAs[completedDownloads + failedDownloads];
+                        const loraName = currentLora ? currentLora.name : '';
                         
-                        // Initial status update for new LoRA
-                        this.loadingManager.setStatus(`Starting download for LoRA ${i+1}/${this.downloadableLoRAs.length}`);
-                        updateProgress(0, completedDownloads, lora.name);
+                        // Update progress display
+                        updateProgress(currentLoraProgress, completedDownloads, loraName);
                         
-                        try {
-                            // Download the LoRA
-                            const response = await fetch('/api/download-lora', {
-                                method: 'POST',
-                                headers: { 'Content-Type': 'application/json' },
-                                body: JSON.stringify({
-                                    download_url: lora.downloadUrl,
-                                    lora_root: loraRoot,
-                                    relative_path: targetPath.replace(loraRoot + '/', '')
-                                })
-                            });
-                            
-                            if (!response.ok) {
-                                const errorText = await response.text();
-                                console.error(`Failed to download LoRA ${lora.name}: ${errorText}`);
-                                
-                                // Check if this is an early access error (status 401 is the key indicator)
-                                if (response.status === 401 || 
-                                   (errorText.toLowerCase().includes('early access') || 
-                                    errorText.toLowerCase().includes('purchase'))) {
-                                    earlyAccessFailures++;
-                                    this.loadingManager.setStatus(
-                                        `Failed to download ${lora.name}: Early Access required`
-                                    );
-                                }
-                                
-                                failedDownloads++;
-                                // Continue with next download
-                            } else {
-                                completedDownloads++;
-                                
-                                // Update progress to show completion of current LoRA
-                                updateProgress(100, completedDownloads, '');
-                                
-                                if (completedDownloads + failedDownloads < this.downloadableLoRAs.length) {
-                                    this.loadingManager.setStatus(
-                                        `Completed ${completedDownloads}/${this.downloadableLoRAs.length} LoRAs. Starting next download...`
-                                    );
-                                }
-                            }
-                        } catch (downloadError) {
-                            console.error(`Error downloading LoRA ${lora.name}:`, downloadError);
-                            failedDownloads++;
-                            // Continue with next download
-                        }
-                    }
-                    
-                    // Close WebSocket
-                    ws.close();
-                    
-                    // Show appropriate completion message based on results
-                    if (failedDownloads === 0) {
-                        showToast(`All ${completedDownloads} LoRAs downloaded successfully`, 'success');
-                    } else {
-                        if (earlyAccessFailures > 0) {
-                            showToast(
-                                `Downloaded ${completedDownloads} of ${this.downloadableLoRAs.length} LoRAs. ${earlyAccessFailures} failed due to Early Access restrictions.`,
-                                'error'
+                        // Add more detailed status messages based on progress
+                        if (currentLoraProgress < 3) {
+                            this.loadingManager.setStatus(
+                                `Preparing download for LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
+                            );
+                        } else if (currentLoraProgress === 3) {
+                            this.loadingManager.setStatus(
+                                `Downloaded preview for LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
+                            );
+                        } else if (currentLoraProgress > 3 && currentLoraProgress < 100) {
+                            this.loadingManager.setStatus(
+                                `Downloading LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
                             );
                         } else {
-                            showToast(`Downloaded ${completedDownloads} of ${this.downloadableLoRAs.length} LoRAs`, 'error');
+                            this.loadingManager.setStatus(
+                                `Finalizing LoRA ${completedDownloads + failedDownloads + 1}/${this.downloadableLoRAs.length}`
+                            );
                         }
                     }
+                };
+                
+                for (let i = 0; i < this.downloadableLoRAs.length; i++) {
+                    const lora = this.downloadableLoRAs[i];
+                    
+                    // Reset current LoRA progress for new download
+                    currentLoraProgress = 0;
+                    
+                    // Initial status update for new LoRA
+                    this.loadingManager.setStatus(`Starting download for LoRA ${i+1}/${this.downloadableLoRAs.length}`);
+                    updateProgress(0, completedDownloads, lora.name);
+                    
+                    try {
+                        // Download the LoRA
+                        const response = await fetch('/api/download-lora', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                download_url: lora.downloadUrl,
+                                model_version_id: lora.modelVersionId,
+                                model_hash: lora.hash,
+                                lora_root: loraRoot,
+                                relative_path: targetPath.replace(loraRoot + '/', '')
+                            })
+                        });
+                        
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            console.error(`Failed to download LoRA ${lora.name}: ${errorText}`);
+                            
+                            // Check if this is an early access error (status 401 is the key indicator)
+                            if (response.status === 401) {
+                                accessFailures++;
+                                this.loadingManager.setStatus(
+                                    `Failed to download ${lora.name}: Access restricted`
+                                );
+                            }
+                            
+                            failedDownloads++;
+                            // Continue with next download
+                        } else {
+                            completedDownloads++;
+                            
+                            // Update progress to show completion of current LoRA
+                            updateProgress(100, completedDownloads, '');
+                            
+                            if (completedDownloads + failedDownloads < this.downloadableLoRAs.length) {
+                                this.loadingManager.setStatus(
+                                    `Completed ${completedDownloads}/${this.downloadableLoRAs.length} LoRAs. Starting next download...`
+                                );
+                            }
+                        }
+                    } catch (downloadError) {
+                        console.error(`Error downloading LoRA ${lora.name}:`, downloadError);
+                        failedDownloads++;
+                        // Continue with next download
+                    }
                 }
+                
+                // Close WebSocket
+                ws.close();
+                
+                // Show appropriate completion message based on results
+                if (failedDownloads === 0) {
+                    showToast(`All ${completedDownloads} LoRAs downloaded successfully`, 'success');
+                } else {
+                    if (accessFailures > 0) {
+                        showToast(
+                            `Downloaded ${completedDownloads} of ${this.downloadableLoRAs.length} LoRAs. ${accessFailures} failed due to access restrictions. Check your API key in settings or early access status.`,
+                            'error'
+                        );
+                    } else {
+                        showToast(`Downloaded ${completedDownloads} of ${this.downloadableLoRAs.length} LoRAs`, 'error');
+                    }
+                }
+            }
 
-                // Show success message for recipe save
-                showToast(`Recipe "${this.recipeName}" saved successfully`, 'success');
-                
-                // Close modal and reload recipes
-                modalManager.closeModal('importModal');
-                
-                window.recipeManager.loadRecipes(true); // true to reset pagination
-                
+            // Show success message
+            if (isDownloadOnly) {
+                if (failedDownloads === 0) {    
+                    showToast('LoRAs downloaded successfully', 'success');
+                }
             } else {
-                // Handle error
-                console.error(`Failed to save recipe: ${result.error}`);
-                // Show error message to user
-                showToast(result.error, 'error');
+                showToast(`Recipe "${this.recipeName}" saved successfully`, 'success');
             }
             
+            // Close modal
+            modalManager.closeModal('importModal');
+            
+            // Refresh the recipe
+            window.recipeManager.loadRecipes(this.recipeId);
+            
         } catch (error) {
-            console.error('Error saving recipe:', error);
+            console.error('Error:', error);
             showToast(error.message, 'error');
         } finally {
             this.loadingManager.hide();
@@ -1213,4 +1223,33 @@ export class ImportManager {
         
         return true;
     }
-} 
+
+    // Add new method to handle downloading missing LoRAs from a recipe
+    downloadMissingLoras(recipeData, recipeId) {
+        // Store the recipe data and ID
+        this.recipeData = recipeData;
+        this.recipeId = recipeId;
+        
+        // Show the location step directly
+        this.showImportModal(recipeData, recipeId);
+        this.proceedToLocation();
+        
+        // Update the modal title to reflect we're downloading for an existing recipe
+        const modalTitle = document.querySelector('#importModal h2');
+        if (modalTitle) {
+            modalTitle.textContent = 'Download Missing LoRAs';
+        }
+        
+        // Update the save button text
+        const saveButton = document.querySelector('#locationStep .primary-btn');
+        if (saveButton) {
+            saveButton.textContent = 'Download Missing LoRAs';
+        }
+        
+        // Hide the back button since we're skipping steps
+        const backButton = document.querySelector('#locationStep .secondary-btn');
+        if (backButton) {
+            backButton.style.display = 'none';
+        }
+    }
+}

static/js/recipes.js

@@ -4,6 +4,7 @@ import { ImportManager } from './managers/ImportManager.js';
 import { RecipeCard } from './components/RecipeCard.js';
 import { RecipeModal } from './components/RecipeModal.js';
 import { getCurrentPageState } from './state/index.js';
+import { toggleApiKeyVisibility } from './managers/SettingsManager.js';
 
 class RecipeManager {
     constructor() {
@@ -54,6 +55,7 @@ class RecipeManager {
         // Only expose what's needed for the page
         window.recipeManager = this;
         window.importManager = this.importManager;
+        window.toggleApiKeyVisibility = toggleApiKeyVisibility;
     }
     
     initEventListeners() {

templates/base.html

@@ -37,6 +37,49 @@
     <link rel="preconnect" href="https://civitai.com">
     <link rel="preconnect" href="https://cdnjs.cloudflare.com">
 
+    <!-- Add styles for initialization notice -->
+    {% if is_initializing %}
+    <style>
+        .initialization-notice {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.85);
+            z-index: 9999;
+            margin-top: 0;
+            border-radius: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            color: white;
+        }
+        .notice-content {
+            background-color: rgba(30, 30, 30, 0.9);
+            border-radius: 10px;
+            padding: 30px;
+            text-align: center;
+            box-shadow: 0 0 20px rgba(0, 0, 0, 0.5);
+            max-width: 500px;
+            width: 80%;
+        }
+        .loading-spinner {
+            border: 5px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top: 5px solid #fff;
+            width: 50px;
+            height: 50px;
+            margin: 0 auto 20px;
+            animation: spin 1s linear infinite;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+    </style>
+    {% endif %}
+
     <script>
         // 计算滚动条宽度并设置CSS变量
         document.addEventListener('DOMContentLoaded', () => {
@@ -52,6 +95,15 @@
 </head>
 
 <body data-page="{% block page_id %}base{% endblock %}">
+    {% if is_initializing %}
+    <div class="initialization-notice">
+        <div class="notice-content">
+            <div class="loading-spinner"></div>
+            <h2>{% block init_title %}Initializing{% endblock %}</h2>
+            <p>{% block init_message %}Scanning and building cache. This may take a few minutes...{% endblock %}</p>
+        </div>
+    </div>
+    {% else %}
     {% include 'components/header.html' %}
 
     <div class="page-content">
@@ -61,22 +113,12 @@
         {% block additional_components %}{% endblock %}
 
         <div class="container">
-            {% if is_initializing %}
-            <div class="initialization-notice">
-                <div class="notice-content">
-                    <div class="loading-spinner"></div>
-                    <h2>{% block init_title %}Initializing{% endblock %}</h2>
-                    <p>{% block init_message %}Scanning and building cache. This may take a few minutes...{% endblock %}
-                    </p>
-                </div>
-            </div>
-            {% else %}
             {% block content %}{% endblock %}
-            {% endif %}
         </div>
 
         {% block overlay %}{% endblock %}
     </div>
+    {% endif %}
 
     {% block main_script %}{% endblock %}
 
@@ -100,11 +142,11 @@
         }
 
         // 启动状态检查
-        checkInitStatus();
+        setTimeout(checkInitStatus, 1000); // 给页面完全加载的时间
     </script>
     {% endif %}
 
     {% block additional_scripts %}{% endblock %}
 </body>
 
-</html>
+</html>

templates/components/recipe_modal.html

@@ -16,8 +16,8 @@
         <div class="modal-body">
             <!-- Top Section: Preview and Generation Parameters -->
             <div class="recipe-top-section">
-                <div class="recipe-preview-container">
-                    <img id="recipeModalImage" src="" alt="Recipe Preview">
+                <div class="recipe-preview-container" id="recipePreviewContainer">
+                    <img id="recipeModalImage" src="" alt="Recipe Preview" class="recipe-preview-media">
                 </div>
                 
                 <div class="info-section recipe-gen-params">

templates/loras.html

@@ -4,7 +4,9 @@
 {% block page_id %}loras{% endblock %}
 
 {% block preload %}
+{% if not is_initializing %}
 <link rel="preload" href="/loras_static/js/loras.js" as="script" crossorigin="anonymous">
+{% endif %}
 {% endblock %}
 
 {% block init_title %}Initializing LoRA Manager{% endblock %}
@@ -29,5 +31,7 @@
 {% endblock %}
 
 {% block main_script %}
+{% if not is_initializing %}
 <script type="module" src="/loras_static/js/loras.js"></script>
+{% endif %}
 {% endblock %}

web/comfyui/lora_loader.js

@@ -35,6 +35,10 @@ app.registerExtension({
             // Enable widget serialization
             node.serialize_widgets = true;
 
+            node.addInput('clip', 'CLIP', {
+                "shape": 7
+            });
+
             node.addInput("lora_stack", 'LORA_STACK', {
                 "shape": 7  // 7 is the shape of the optional input
             });