chore: Update version to 0.8.29 and add release notes for enhanced recipe imports and bug fixes

Disable PySSSS autocomplete functionality in:
- Lora Loader
- Lora Stacker
- WanVideo Lora Select node

README.md

@@ -34,6 +34,13 @@ Enhance your Civitai browsing experience with our companion browser extension! S
 
 ## Release Notes
 
+### v0.8.29
+* **Enhanced Recipe Imports** - Improved recipe importing with new target folder selection, featuring path input autocomplete and interactive folder tree navigation. Added a "Use Default Path" option when downloading missing LoRAs.
+* **WanVideo Lora Select Node Update** - Updated the WanVideo Lora Select node with a 'merge_loras' option to match the counterpart node in the WanVideoWrapper node package.
+* **Autocomplete Conflict Resolution** - Resolved an autocomplete feature conflict in LoRA nodes with pysssss autocomplete.
+* **Improved Download Functionality** - Enhanced download functionality with resumable downloads and improved error handling.
+* **Bug Fixes** - Addressed several bugs for improved stability and performance.
+
 ### v0.8.28
 * **Autocomplete for Node Inputs** - Instantly find and add LoRAs by filename directly in Lora Loader, Lora Stacker, and WanVideo Lora Select nodes. Autocomplete suggestions include preview tooltips and preset weights, allowing you to quickly select LoRAs without opening the LoRA Manager UI.
 * **Duplicate Notification Control** - Added a switch to duplicates mode, enabling users to turn off duplicate model notifications for a more streamlined experience.
@@ -296,3 +303,6 @@ Join our Discord community for support, discussions, and updates:
 [Discord Server](https://discord.gg/vcqNrWVFvM)
 
 ---
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=willmiao/ComfyUI-Lora-Manager&type=Date)](https://star-history.com/#willmiao/ComfyUI-Lora-Manager&Date)

__init__.py

@@ -1,5 +1,5 @@
 from .py.lora_manager import LoraManager
-from .py.nodes.lora_loader import LoraManagerLoader
+from .py.nodes.lora_loader import LoraManagerLoader, LoraManagerTextLoader
 from .py.nodes.trigger_word_toggle import TriggerWordToggle
 from .py.nodes.lora_stacker import LoraStacker
 from .py.nodes.save_image import SaveImage
@@ -10,6 +10,7 @@ from .py.metadata_collector import init as init_metadata_collector
 
 NODE_CLASS_MAPPINGS = {
     LoraManagerLoader.NAME: LoraManagerLoader,
+    LoraManagerTextLoader.NAME: LoraManagerTextLoader,
     TriggerWordToggle.NAME: TriggerWordToggle,
     LoraStacker.NAME: LoraStacker,
     SaveImage.NAME: SaveImage,

py/nodes/lora_loader.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from nodes import LoraLoader
 from comfy.comfy_types import IO # type: ignore
 from ..utils.utils import get_lora_info
@@ -18,6 +19,7 @@ class LoraManagerLoader:
                 # "clip": ("CLIP",),
                 "text": (IO.STRING, {
                     "multiline": True,
+                    "pysssss.autocomplete": False, 
                     "dynamicPrompts": True, 
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
                     "placeholder": "LoRA syntax input: <lora:name:strength>"
@@ -129,3 +131,141 @@ class LoraManagerLoader:
         formatted_loras_text = " ".join(formatted_loras)
 
         return (model, clip, trigger_words_text, formatted_loras_text)
+
+class LoraManagerTextLoader:
+    NAME = "LoRA Text Loader (LoraManager)"
+    CATEGORY = "Lora Manager/loaders"
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "lora_syntax": (IO.STRING, {
+                    "defaultInput": True,
+                    "forceInput": True,
+                    "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation"
+                }),
+            },
+            "optional": {
+                "clip": ("CLIP",),
+                "lora_stack": ("LORA_STACK",),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP", IO.STRING, IO.STRING)
+    RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
+    FUNCTION = "load_loras_from_text"
+    
+    def parse_lora_syntax(self, text):
+        """Parse LoRA syntax from text input."""
+        # Pattern to match <lora:name:strength> or <lora:name:model_strength:clip_strength>
+        pattern = r'<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>'
+        matches = re.findall(pattern, text, re.IGNORECASE)
+        
+        loras = []
+        for match in matches:
+            lora_name = match[0].strip()
+            model_strength = float(match[1])
+            clip_strength = float(match[2]) if match[2] else model_strength
+            
+            loras.append({
+                'name': lora_name,
+                'model_strength': model_strength,
+                'clip_strength': clip_strength
+            })
+        
+        return loras
+    
+    def load_loras_from_text(self, model, lora_syntax, clip=None, lora_stack=None):
+        """Load LoRAs based on text syntax input."""
+        loaded_loras = []
+        all_trigger_words = []
+        
+        # Check if model is a Nunchaku Flux model - simplified approach
+        is_nunchaku_model = False
+        
+        try:
+            model_wrapper = model.model.diffusion_model
+            # Check if model is a Nunchaku Flux model using only class name
+            if model_wrapper.__class__.__name__ == "ComfyFluxWrapper":
+                is_nunchaku_model = True
+                logger.info("Detected Nunchaku Flux model")
+        except (AttributeError, TypeError):
+            # Not a model with the expected structure
+            pass
+        
+        # First process lora_stack if available
+        if lora_stack:
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Apply the LoRA using the appropriate loader
+                if is_nunchaku_model:
+                    # Use our custom function for Flux models
+                    model = nunchaku_load_lora(model, lora_path, model_strength)
+                    # clip remains unchanged for Nunchaku models
+                else:
+                    # Use default loader for standard models
+                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                
+                # Extract lora name for trigger words lookup
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = get_lora_info(lora_name)
+                
+                all_trigger_words.extend(trigger_words)
+                # Add clip strength to output if different from model strength (except for Nunchaku models)
+                if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
+        
+        # Parse and process LoRAs from text syntax
+        parsed_loras = self.parse_lora_syntax(lora_syntax)
+        for lora in parsed_loras:
+            lora_name = lora['name']
+            model_strength = lora['model_strength']
+            clip_strength = lora['clip_strength']
+            
+            # Get lora path and trigger words
+            lora_path, trigger_words = get_lora_info(lora_name)
+            
+            # Apply the LoRA using the appropriate loader
+            if is_nunchaku_model:
+                # For Nunchaku models, use our custom function
+                model = nunchaku_load_lora(model, lora_path, model_strength)
+                # clip remains unchanged
+            else:
+                # Use default loader for standard models
+                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength and not a Nunchaku model
+            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
+            
+            # Add trigger words to collection
+            all_trigger_words.extend(trigger_words)
+        
+        # use ',, ' to separate trigger words for group mode
+        trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0].strip()
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
+
+        return (model, clip, trigger_words_text, formatted_loras_text)

py/nodes/lora_stacker.py

@@ -17,6 +17,7 @@ class LoraStacker:
             "required": {
                 "text": (IO.STRING, {
                     "multiline": True, 
+                    "pysssss.autocomplete": False, 
                     "dynamicPrompts": True, 
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
                     "placeholder": "LoRA syntax input: <lora:name:strength>"

py/nodes/wanvideo_lora_select.py

@@ -14,9 +14,11 @@ class WanVideoLoraSelect:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "low_mem_load": ("BOOLEAN", {"default": False, "tooltip": "Load the LORA model with less VRAM usage, slower loading"}),
+                "low_mem_load": ("BOOLEAN", {"default": False, "tooltip": "Load LORA models with less VRAM usage, slower loading. This affects ALL LoRAs, not just the current ones. No effect if merge_loras is False"}),
+                "merge_loras": ("BOOLEAN", {"default": True, "tooltip": "Merge LoRAs into the model, otherwise they are loaded on the fly. Always disabled for GGUF and scaled fp8 models. This affects ALL LoRAs, not just the current one"}),
                 "text": (IO.STRING, {
                     "multiline": True, 
+                    "pysssss.autocomplete": False, 
                     "dynamicPrompts": True, 
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
                     "placeholder": "LoRA syntax input: <lora:name:strength>"
@@ -29,7 +31,7 @@ class WanVideoLoraSelect:
     RETURN_NAMES = ("lora", "trigger_words", "active_loras")
     FUNCTION = "process_loras"
     
-    def process_loras(self, text, low_mem_load=False, **kwargs):
+    def process_loras(self, text, low_mem_load=False, merge_loras=True, **kwargs):
         loras_list = []
         all_trigger_words = []
         active_loras = []
@@ -39,6 +41,9 @@ class WanVideoLoraSelect:
         if prev_lora is not None:
             loras_list.extend(prev_lora)
 
+        if not merge_loras:
+            low_mem_load = False  # Unmerged LoRAs don't need low_mem_load
+        
         # Get blocks if available
         blocks = kwargs.get('blocks', {})
         selected_blocks = blocks.get("selected_blocks", {})
@@ -65,6 +70,7 @@ class WanVideoLoraSelect:
                 "blocks": selected_blocks,
                 "layer_filter": layer_filter,
                 "low_mem_load": low_mem_load,
+                "merge_loras": merge_loras,
             }
             
             # Add to list and collect active loras

py/routes/misc_routes.py

@@ -1,4 +1,3 @@
-import json
 import logging
 import os
 import sys
@@ -183,16 +182,6 @@ class MiscRoutes:
                     if old_path != value:
                         logger.info(f"Example images path changed to {value} - server restart required")
                 
-                # Special handling for base_model_path_mappings - parse JSON string
-                if (key == 'base_model_path_mappings' or key == 'download_path_templates') and value:
-                    try:
-                        value = json.loads(value)
-                    except json.JSONDecodeError:
-                        return web.json_response({
-                            'success': False,
-                            'error': f"Invalid JSON format for base_model_path_mappings: {value}"
-                        })
-                
                 # Save to settings
                 settings.set(key, value)
             

py/services/civitai_client.py

@@ -33,8 +33,8 @@ class CivitaiClient:
         }
         self._session = None
         self._session_created_at = None
-        # Set default buffer size to 1MB for higher throughput
+        # Adjust chunk size based on storage type - consider making this configurable
-        self.chunk_size = 1024 * 1024
+        self.chunk_size = 4 * 1024 * 1024   # 4MB chunks for better HDD throughput
     
     @property
     async def session(self) -> aiohttp.ClientSession:
@@ -49,8 +49,8 @@ class CivitaiClient:
                 enable_cleanup_closed=True
             )
             trust_env = True  # Allow using system environment proxy settings
-            # Configure timeout parameters - increase read timeout for large files
+            # Configure timeout parameters - increase read timeout for large files and remove sock_read timeout
-            timeout = aiohttp.ClientTimeout(total=None, connect=60, sock_read=120)
+            timeout = aiohttp.ClientTimeout(total=None, connect=60, sock_read=None)
             self._session = aiohttp.ClientSession(
                 connector=connector, 
                 trust_env=trust_env,
@@ -102,7 +102,7 @@ class CivitaiClient:
         return headers
 
     async def _download_file(self, url: str, save_dir: str, default_filename: str, progress_callback=None) -> Tuple[bool, str]:
-        """Download file with content-disposition support and progress tracking
+        """Download file with resumable downloads and retry mechanism
 
         Args:
             url: Download URL
@@ -113,50 +113,119 @@ class CivitaiClient:
         Returns:
             Tuple[bool, str]: (success, save_path or error message)
         """
-        logger.debug(f"Resolving DNS for: {url}")
+        max_retries = 5
+        retry_count = 0
+        base_delay = 2.0  # Base delay for exponential backoff
+        
+        # Initial setup
         session = await self._ensure_fresh_session()
+        save_path = os.path.join(save_dir, default_filename)
+        part_path = save_path + '.part'
+        
+        # Get existing file size for resume
+        resume_offset = 0
+        if os.path.exists(part_path):
+            resume_offset = os.path.getsize(part_path)
+            logger.info(f"Resuming download from offset {resume_offset} bytes")
+        
+        total_size = 0
+        filename = default_filename
+        
+        while retry_count <= max_retries:
             try:
                 headers = self._get_request_headers()
                 
+                # Add Range header for resume if we have partial data
+                if resume_offset > 0:
+                    headers['Range'] = f'bytes={resume_offset}-'
+                
                 # Add Range header to allow resumable downloads
                 headers['Accept-Encoding'] = 'identity'  # Disable compression for better chunked downloads
                 
-            logger.debug(f"Starting download from: {url}")
+                logger.debug(f"Download attempt {retry_count + 1}/{max_retries + 1} from: {url}")
+                if resume_offset > 0:
+                    logger.debug(f"Requesting range from byte {resume_offset}")
+                
                 async with session.get(url, headers=headers, allow_redirects=True) as response:
-                if response.status != 200:
+                    # Handle different response codes
-                    # Handle 401 unauthorized responses
+                    if response.status == 200:
-                    if response.status == 401:
+                        # Full content response
+                        if resume_offset > 0:
+                            # Server doesn't support ranges, restart from beginning
+                            logger.warning("Server doesn't support range requests, restarting download")
+                            resume_offset = 0
+                            if os.path.exists(part_path):
+                                os.remove(part_path)
+                    elif response.status == 206:
+                        # Partial content response (resume successful)
+                        content_range = response.headers.get('Content-Range')
+                        if content_range:
+                            # Parse total size from Content-Range header (e.g., "bytes 1024-2047/2048")
+                            range_parts = content_range.split('/')
+                            if len(range_parts) == 2:
+                                total_size = int(range_parts[1])
+                        logger.info(f"Successfully resumed download from byte {resume_offset}")
+                    elif response.status == 416:
+                        # Range not satisfiable - file might be complete or corrupted
+                        if os.path.exists(part_path):
+                            part_size = os.path.getsize(part_path)
+                            logger.warning(f"Range not satisfiable. Part file size: {part_size}")
+                            # Try to get actual file size
+                            head_response = await session.head(url, headers=self._get_request_headers())
+                            if head_response.status == 200:
+                                actual_size = int(head_response.headers.get('content-length', 0))
+                                if part_size == actual_size:
+                                    # File is complete, just rename it
+                                    os.rename(part_path, save_path)
+                                    if progress_callback:
+                                        await progress_callback(100)
+                                    return True, save_path
+                            # Remove corrupted part file and restart
+                            os.remove(part_path)
+                            resume_offset = 0
+                            continue
+                    elif response.status == 401:
                         logger.warning(f"Unauthorized access to resource: {url} (Status 401)")
-                        
                         return False, "Invalid or missing CivitAI API key, or early access restriction."
-                    
+                    elif response.status == 403:
-                    # Handle other client errors that might be permission-related
-                    if response.status == 403:
                         logger.warning(f"Forbidden access to resource: {url} (Status 403)")
                         return False, "Access forbidden: You don't have permission to download this file."
-                    
+                    else:
-                    # Generic error response for other status codes
                         logger.error(f"Download failed for {url} with status {response.status}")
                         return False, f"Download failed with status {response.status}"
 
-                # Get filename from content-disposition header
+                    # Get filename from content-disposition header (only on first attempt)
+                    if retry_count == 0:
                         content_disposition = response.headers.get('Content-Disposition')
-                filename = self._parse_content_disposition(content_disposition)
+                        parsed_filename = self._parse_content_disposition(content_disposition)
-                if not filename:
+                        if parsed_filename:
-                    filename = default_filename
+                            filename = parsed_filename
-                
+                            # Update paths with correct filename
                             save_path = os.path.join(save_dir, filename)
+                            new_part_path = save_path + '.part'
+                            # Rename existing part file if filename changed
+                            if part_path != new_part_path and os.path.exists(part_path):
+                                os.rename(part_path, new_part_path)
+                            part_path = new_part_path
                     
-                # Get total file size for progress calculation
+                    # Get total file size for progress calculation (if not set from Content-Range)
+                    if total_size == 0:
                         total_size = int(response.headers.get('content-length', 0))
-                current_size = 0
+                        if response.status == 206:
+                            # For partial content, add the offset to get total file size
+                            total_size += resume_offset
+
+                    current_size = resume_offset
                     last_progress_report_time = datetime.now()
 
                     # Stream download to file with progress updates using larger buffer
-                with open(save_path, 'wb') as f:
+                    loop = asyncio.get_running_loop()
+                    mode = 'ab' if resume_offset > 0 else 'wb'
+                    with open(part_path, mode) as f:
                         async for chunk in response.content.iter_chunked(self.chunk_size):
                             if chunk:
-                            f.write(chunk)
+                                # Run blocking file write in executor
+                                await loop.run_in_executor(None, f.write, chunk)
                                 current_size += len(chunk)
                                 
                                 # Limit progress update frequency to reduce overhead
@@ -168,19 +237,67 @@ class CivitaiClient:
                                     await progress_callback(progress)
                                     last_progress_report_time = now
                     
+                    # Download completed successfully
+                    # Verify file size if total_size was provided
+                    final_size = os.path.getsize(part_path)
+                    if total_size > 0 and final_size != total_size:
+                        logger.warning(f"File size mismatch. Expected: {total_size}, Got: {final_size}")
+                        # Don't treat this as fatal error, rename anyway
+                    
+                    # Atomically rename .part to final file with retries
+                    max_rename_attempts = 5
+                    rename_attempt = 0
+                    rename_success = False
+                    
+                    while rename_attempt < max_rename_attempts and not rename_success:
+                        try:
+                            os.rename(part_path, save_path)
+                            rename_success = True
+                        except PermissionError as e:
+                            rename_attempt += 1
+                            if rename_attempt < max_rename_attempts:
+                                logger.info(f"File still in use, retrying rename in 2 seconds (attempt {rename_attempt}/{max_rename_attempts})")
+                                await asyncio.sleep(2)  # Wait before retrying
+                            else:
+                                logger.error(f"Failed to rename file after {max_rename_attempts} attempts: {e}")
+                                return False, f"Failed to finalize download: {str(e)}"
+                    
                     # Ensure 100% progress is reported
                     if progress_callback:
                         await progress_callback(100)
                         
                     return True, save_path
                     
-        except aiohttp.ClientError as e:
+            except (aiohttp.ClientError, aiohttp.ClientPayloadError, 
-            logger.error(f"Network error during download: {e}")
+                    aiohttp.ServerDisconnectedError, asyncio.TimeoutError) as e:
-            return False, f"Network error: {str(e)}"
+                retry_count += 1
+                logger.warning(f"Network error during download (attempt {retry_count}/{max_retries + 1}): {e}")
+                
+                if retry_count <= max_retries:
+                    # Calculate delay with exponential backoff
+                    delay = base_delay * (2 ** (retry_count - 1))
+                    logger.info(f"Retrying in {delay} seconds...")
+                    await asyncio.sleep(delay)
+                    
+                    # Update resume offset for next attempt
+                    if os.path.exists(part_path):
+                        resume_offset = os.path.getsize(part_path)
+                        logger.info(f"Will resume from byte {resume_offset}")
+                    
+                    # Refresh session to get new connection
+                    await self.close()
+                    session = await self._ensure_fresh_session()
+                    continue
+                else:
+                    logger.error(f"Max retries exceeded for download: {e}")
+                    return False, f"Network error after {max_retries + 1} attempts: {str(e)}"
+                    
             except Exception as e:
-            logger.error(f"Download error: {e}")
+                logger.error(f"Unexpected download error: {e}")
                 return False, str(e)
         
+        return False, f"Download failed after {max_retries + 1} attempts"
+
     async def get_model_by_hash(self, model_hash: str) -> Optional[Dict]:
         try:
             session = await self._ensure_fresh_session()

py/services/download_manager.py

@@ -274,9 +274,9 @@ class DownloadManager:
                     from datetime import datetime
                     date_obj = datetime.fromisoformat(early_access_date.replace('Z', '+00:00'))
                     formatted_date = date_obj.strftime('%Y-%m-%d')
-                    early_access_msg = f"This model requires early access payment (until {formatted_date}). "
+                    early_access_msg = f"This model requires payment (until {formatted_date}). "
                 except:
-                    early_access_msg = "This model requires early access payment. "
+                    early_access_msg = "This model requires payment. "
                 
                 early_access_msg += "Please ensure you have purchased early access and are logged in to Civitai."
                 logger.warning(f"Early access model detected: {version_info.get('name', 'Unknown')}")
@@ -321,6 +321,10 @@ class DownloadManager:
                 download_id=download_id
             )
 
+            # If early_access_msg exists and download failed, replace error message
+            if 'early_access_msg' in locals() and not result.get('success', False):
+                result['error'] = early_access_msg
+
             return result
 
         except Exception as e:
@@ -392,11 +396,13 @@ class DownloadManager:
         try:
             civitai_client = await self._get_civitai_client()
             save_path = metadata.file_path
+            part_path = save_path + '.part'
             metadata_path = os.path.splitext(save_path)[0] + '.metadata.json'
             
-            # Store file path in active_downloads for potential cleanup
+            # Store file paths in active_downloads for potential cleanup
             if download_id and download_id in self._active_downloads:
                 self._active_downloads[download_id]['file_path'] = save_path
+                self._active_downloads[download_id]['part_path'] = part_path
 
             # Download preview image if available
             images = version_info.get('images', [])
@@ -463,10 +469,22 @@ class DownloadManager:
             )
 
             if not success:
-                # Clean up files on failure
+                # Clean up files on failure, but preserve .part file for resume
-                for path in [save_path, metadata_path, metadata.preview_url]:
+                cleanup_files = [metadata_path]
+                if metadata.preview_url and os.path.exists(metadata.preview_url):
+                    cleanup_files.append(metadata.preview_url)
+                
+                for path in cleanup_files:
                     if path and os.path.exists(path):
+                        try:
                             os.remove(path)
+                        except Exception as e:
+                            logger.warning(f"Failed to cleanup file {path}: {e}")
+                
+                # Log but don't remove .part file to allow resume
+                if os.path.exists(part_path):
+                    logger.info(f"Preserving partial download for resume: {part_path}")
+                
                 return {'success': False, 'error': result}
 
             # 4. Update file information (size and modified time)
@@ -502,10 +520,18 @@ class DownloadManager:
 
         except Exception as e:
             logger.error(f"Error in _execute_download: {e}", exc_info=True)
-            # Clean up partial downloads
+            # Clean up partial downloads except .part file
-            for path in [save_path, metadata_path]:
+            cleanup_files = [metadata_path]
+            if hasattr(metadata, 'preview_url') and metadata.preview_url and os.path.exists(metadata.preview_url):
+                cleanup_files.append(metadata.preview_url)
+            
+            for path in cleanup_files:
                 if path and os.path.exists(path):
+                    try:
                         os.remove(path)
+                    except Exception as e:
+                        logger.warning(f"Failed to cleanup file {path}: {e}")
+            
             return {'success': False, 'error': str(e)}
 
     async def _handle_download_progress(self, file_progress: float, progress_callback):
@@ -547,19 +573,32 @@ class DownloadManager:
             except (asyncio.CancelledError, asyncio.TimeoutError):
                 pass
             
-            # Clean up partial downloads
+            # Clean up ALL files including .part when user cancels
             download_info = self._active_downloads.get(download_id)
-            if download_info and 'file_path' in download_info:
+            if download_info:
-                # Delete the partial file
+                # Delete the main file
+                if 'file_path' in download_info:
                     file_path = download_info['file_path']
                     if os.path.exists(file_path):
                         try:
                             os.unlink(file_path)
-                        logger.debug(f"Deleted partial download: {file_path}")
+                            logger.debug(f"Deleted cancelled download: {file_path}")
                         except Exception as e:
-                        logger.error(f"Error deleting partial file: {e}")
+                            logger.error(f"Error deleting file: {e}")
+                
+                # Delete the .part file (only on user cancellation)
+                if 'part_path' in download_info:
+                    part_path = download_info['part_path']
+                    if os.path.exists(part_path):
+                        try:
+                            os.unlink(part_path)
+                            logger.debug(f"Deleted partial download: {part_path}")
+                        except Exception as e:
+                            logger.error(f"Error deleting part file: {e}")
                 
                 # Delete metadata file if exists
+                if 'file_path' in download_info:
+                    file_path = download_info['file_path']
                     metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
                     if os.path.exists(metadata_path):
                         try:

py/services/model_scanner.py

@@ -303,11 +303,11 @@ class ModelScanner:
                             self._tags_count[tag] = self._tags_count.get(tag, 0) + 1
                 
                 # Log duplicate filename warnings after building the index
-                duplicate_filenames = self._hash_index.get_duplicate_filenames()
+                # duplicate_filenames = self._hash_index.get_duplicate_filenames()
-                if duplicate_filenames:
+                # if duplicate_filenames:
-                    logger.warning(f"Found {len(duplicate_filenames)} filename(s) with duplicates during {self.model_type} cache build:")
+                #     logger.warning(f"Found {len(duplicate_filenames)} filename(s) with duplicates during {self.model_type} cache build:")
-                    for filename, paths in duplicate_filenames.items():
+                #     for filename, paths in duplicate_filenames.items():
-                        logger.warning(f"  Duplicate filename '{filename}': {paths}")
+                #         logger.warning(f"  Duplicate filename '{filename}': {paths}")
                 
                 # Update cache
                 self._cache.raw_data = raw_data
@@ -375,11 +375,11 @@ class ModelScanner:
                         self._tags_count[tag] = self._tags_count.get(tag, 0) + 1
             
             # Log duplicate filename warnings after building the index
-            duplicate_filenames = self._hash_index.get_duplicate_filenames()
+            # duplicate_filenames = self._hash_index.get_duplicate_filenames()
-            if duplicate_filenames:
+            # if duplicate_filenames:
-                logger.warning(f"Found {len(duplicate_filenames)} filename(s) with duplicates during {self.model_type} cache build:")
+            #     logger.warning(f"Found {len(duplicate_filenames)} filename(s) with duplicates during {self.model_type} cache build:")
-                for filename, paths in duplicate_filenames.items():
+            #     for filename, paths in duplicate_filenames.items():
-                    logger.warning(f"  Duplicate filename '{filename}': {paths}")
+            #         logger.warning(f"  Duplicate filename '{filename}': {paths}")
             
             # Update cache
             self._cache = ModelCache(

py/utils/routes_common.py

@@ -628,15 +628,6 @@ class ModelRouteUtils:
             if not result.get('success', False):
                 error_message = result.get('error', 'Unknown error')
                 
-                # Return 401 for early access errors
-                if 'early access' in error_message.lower():
-                    logger.warning(f"Early access download failed: {error_message}")
-                    return web.json_response({
-                        'success': False,
-                        'error': f"Early Access Restriction: {error_message}",
-                        'download_id': download_id
-                    }, status=401)
-                
                 return web.json_response({
                     'success': False,
                     'error': error_message,

py/utils/utils.py

@@ -156,7 +156,8 @@ def calculate_relative_path_for_model(model_data: Dict, model_type: str = 'lora'
     if civitai_data and civitai_data.get('id') is not None:
         base_model = civitai_data.get('baseModel', '')
         # Get author from civitai creator data
-        author = civitai_data.get('creator', {}).get('username') or 'Anonymous'
+        creator_info = civitai_data.get('creator') or {}
+        author = creator_info.get('username') or 'Anonymous'
     else:
         # Fallback to model_data fields for non-CivitAI models
         base_model = model_data.get('base_model', '')

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "Revolutionize your workflow with the ultimate LoRA companion for ComfyUI!"
-version = "0.8.28"
+version = "0.8.29"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",

static/css/components/import-modal.css

@@ -337,72 +337,7 @@
     margin-left: 8px;
 }
 
-/* Location Selection Styles */
-.location-selection {
-    margin: var(--space-2) 0;
-    padding: var(--space-2);
-    background: var(--lora-surface);
-    border-radius: var(--border-radius-sm);
-}
-
-/* Reuse folder browser and path preview styles from download-modal.css */
-.folder-browser {
-    border: 1px solid var(--border-color);
-    border-radius: var(--border-radius-xs);
-    padding: var(--space-1);
-    max-height: 200px;
-    overflow-y: auto;
-}
-
-.folder-item {
-    padding: 8px;
-    cursor: pointer;
-    border-radius: var(--border-radius-xs);
-    transition: background-color 0.2s;
-}
-
-.folder-item:hover {
-    background: var(--lora-surface);
-}
-
-.folder-item.selected {
-    background: oklch(var(--lora-accent) / 0.1);
-    border: 1px solid var(--lora-accent);
-}
-
-.path-preview {
-    margin-bottom: var(--space-3);
-    padding: var(--space-2);
-    background: var(--bg-color);
-    border-radius: var(--border-radius-sm);
-    border: 1px dashed var(--border-color);
-}
-
-.path-preview label {
-    display: block;
-    margin-bottom: 8px;
-    color: var(--text-color);
-    font-size: 0.9em;
-    opacity: 0.8;
-}
-
-.path-display {
-    padding: var(--space-1);
-    color: var(--text-color);
-    font-family: monospace;
-    font-size: 0.9em;
-    line-height: 1.4;
-    white-space: pre-wrap;
-    word-break: break-all;
-    opacity: 0.85;
-    background: var(--lora-surface);
-    border-radius: var(--border-radius-xs);
-}
-
 /* Input Group Styles */
-.input-group {
-    margin-bottom: var(--space-2);
-}
 
 .input-with-button {
     display: flex;
@@ -430,22 +365,6 @@
     background: oklch(from var(--lora-accent) l c h / 0.9);
 }
 
-.input-group label {
-    display: block;
-    margin-bottom: 8px;
-    color: var(--text-color);
-}
-
-.input-group input,
-.input-group select {
-    width: 100%;
-    padding: 8px;
-    border: 1px solid var(--border-color);
-    border-radius: var(--border-radius-xs);
-    background: var(--bg-color);
-    color: var(--text-color);
-}
-
 /* Dark theme adjustments */
 [data-theme="dark"] .lora-item {
     background: var(--lora-surface);

static/css/components/modal/_base.css

@@ -23,7 +23,7 @@ body.modal-open {
     position: relative;
     max-width: 800px;
     height: auto;
-    max-height: calc(90vh - 48px); /* Adjust to account for header height */
+    /* max-height: calc(90vh - 48px); */
     margin: 1rem auto; /* Keep reduced top margin */
     background: var(--lora-surface);
     border-radius: var(--border-radius-base);

static/css/components/modal/download-modal.css

@@ -121,15 +121,6 @@
     gap: 4px;
 }
 
-/* Folder Browser Styles */
-.folder-browser {
-    border: 1px solid var(--border-color);
-    border-radius: var(--border-radius-xs);
-    padding: var(--space-1);
-    max-height: 200px;
-    overflow-y: auto;
-}
-
 .folder-item {
     padding: 8px;
     cursor: pointer;

static/js/managers/ImportManager.js

@@ -4,8 +4,13 @@ import { ImportStepManager } from './import/ImportStepManager.js';
 import { ImageProcessor } from './import/ImageProcessor.js';
 import { RecipeDataManager } from './import/RecipeDataManager.js';
 import { DownloadManager } from './import/DownloadManager.js';
-import { FolderBrowser } from './import/FolderBrowser.js';
+import { FolderTreeManager } from '../components/FolderTreeManager.js';
 import { formatFileSize } from '../utils/formatters.js';
+import { getStorageItem, setStorageItem } from '../utils/storageHelpers.js';
+import { getModelApiClient } from '../api/modelApiFactory.js';
+import { state } from '../state/index.js';
+import { MODEL_TYPES } from '../api/apiConfig.js';
+import { showToast } from '../utils/uiHelpers.js';
 
 export class ImportManager {
     constructor() {
@@ -20,6 +25,8 @@ export class ImportManager {
         this.downloadableLoRAs = [];
         this.recipeId = null;
         this.importMode = 'url'; // Default mode: 'url' or 'upload'
+        this.useDefaultPath = false;
+        this.apiClient = null;
         
         // Initialize sub-managers
         this.loadingManager = new LoadingManager();
@@ -27,10 +34,12 @@ export class ImportManager {
         this.imageProcessor = new ImageProcessor(this);
         this.recipeDataManager = new RecipeDataManager(this);
         this.downloadManager = new DownloadManager(this);
-        this.folderBrowser = new FolderBrowser(this);
+        this.folderTreeManager = new FolderTreeManager();
         
         // Bind methods
         this.formatFileSize = formatFileSize;
+        this.updateTargetPath = this.updateTargetPath.bind(this);
+        this.handleToggleDefaultPath = this.toggleDefaultPath.bind(this);
     }
 
     showImportModal(recipeData = null, recipeId = null) {
@@ -40,9 +49,13 @@ export class ImportManager {
                 console.error('Import modal element not found');
                 return;
             }
+            this.initializeEventHandlers();
             this.initialized = true;
         }
         
+        // Get API client for LoRAs
+        this.apiClient = getModelApiClient(MODEL_TYPES.LORA);
+        
         // Reset state
         this.resetSteps();
         if (recipeData) {
@@ -52,14 +65,12 @@ export class ImportManager {
         
         // Show modal
         modalManager.showModal('importModal', null, () => {
-            this.folderBrowser.cleanup();
+            this.cleanupFolderBrowser();
             this.stepManager.removeInjectedStyles();
         });
 
         // Verify visibility and focus on URL input
         setTimeout(() => {      
-            this.ensureModalVisible();
-            
             // Ensure URL option is selected and focus on the input
             this.toggleImportMode('url');
             const urlInput = document.getElementById('imageUrlInput');
@@ -69,6 +80,14 @@ export class ImportManager {
         }, 50);
     }
 
+    initializeEventHandlers() {
+        // Default path toggle handler
+        const useDefaultPathToggle = document.getElementById('importUseDefaultPath');
+        if (useDefaultPathToggle) {
+            useDefaultPathToggle.addEventListener('change', this.handleToggleDefaultPath);
+        }
+    }
+
     resetSteps() {
         // Clear UI state
         this.stepManager.removeInjectedStyles();
@@ -93,6 +112,12 @@ export class ImportManager {
         const tagsContainer = document.getElementById('tagsContainer');
         if (tagsContainer) tagsContainer.innerHTML = '<div class="empty-tags">No tags added</div>';
         
+        // Clear folder path input
+        const folderPathInput = document.getElementById('importFolderPath');
+        if (folderPathInput) {
+            folderPathInput.value = '';
+        }
+        
         // Reset state variables
         this.recipeImage = null;
         this.recipeData = null;
@@ -100,33 +125,19 @@ export class ImportManager {
         this.recipeTags = [];
         this.missingLoras = [];
         this.downloadableLoRAs = [];
+        this.selectedFolder = '';
         
         // Reset import mode
         this.importMode = 'url';
         this.toggleImportMode('url');
         
-        // Reset folder browser
+        // Clear folder tree selection
-        this.selectedFolder = '';
+        if (this.folderTreeManager) {
-        const folderBrowser = document.getElementById('importFolderBrowser');
+            this.folderTreeManager.clearSelection();
-        if (folderBrowser) {
-            folderBrowser.querySelectorAll('.folder-item').forEach(f => 
-                f.classList.remove('selected'));
         }
         
-        // Clear missing LoRAs list
+        // Reset default path toggle
-        const missingLorasList = document.getElementById('missingLorasList');
+        this.loadDefaultPathSetting();
-        if (missingLorasList) missingLorasList.innerHTML = '';
-        
-        // Reset total download size
-        const totalSizeDisplay = document.getElementById('totalDownloadSize');
-        if (totalSizeDisplay) totalSizeDisplay.textContent = 'Calculating...';
-        
-        // Remove warnings
-        const deletedLorasWarning = document.getElementById('deletedLorasWarning');
-        if (deletedLorasWarning) deletedLorasWarning.remove();
-        
-        const earlyAccessWarning = document.getElementById('earlyAccessWarning');
-        if (earlyAccessWarning) earlyAccessWarning.remove();
         
         // Reset duplicate related properties
         this.duplicateRecipes = [];
@@ -204,7 +215,54 @@ export class ImportManager {
     }
 
     async proceedToLocation() {
-        await this.folderBrowser.proceedToLocation();
+        this.stepManager.showStep('locationStep');
+        
+        try {
+            // Fetch LoRA roots
+            const rootsData = await this.apiClient.fetchModelRoots();
+            const loraRoot = document.getElementById('importLoraRoot');
+            loraRoot.innerHTML = rootsData.roots.map(root => 
+                `<option value="${root}">${root}</option>`
+            ).join('');
+
+            // Set default root if available
+            const defaultRootKey = 'default_lora_root';
+            const defaultRoot = getStorageItem('settings', {})[defaultRootKey];
+            if (defaultRoot && rootsData.roots.includes(defaultRoot)) {
+                loraRoot.value = defaultRoot;
+            }
+
+            // Set autocomplete="off" on folderPath input
+            const folderPathInput = document.getElementById('importFolderPath');
+            if (folderPathInput) {
+                folderPathInput.setAttribute('autocomplete', 'off');
+            }
+
+            // Setup folder tree manager
+            this.folderTreeManager.init({
+                elementsPrefix: 'import',
+                onPathChange: (path) => {
+                    this.selectedFolder = path;
+                    this.updateTargetPath();
+                }
+            });
+            
+            // Initialize folder tree
+            await this.initializeFolderTree();
+            
+            // Setup lora root change handler
+            loraRoot.addEventListener('change', async () => {
+                await this.initializeFolderTree();
+                this.updateTargetPath();
+            });
+            
+            // Load default path setting for LoRAs
+            this.loadDefaultPathSetting();
+            
+            this.updateTargetPath();
+        } catch (error) {
+            showToast(error.message, 'error');
+        }
     }
 
     backToUpload() {
@@ -234,25 +292,107 @@ export class ImportManager {
         await this.downloadManager.saveRecipe();
     }
 
+    loadDefaultPathSetting() {
+        const storageKey = 'use_default_path_loras';
+        this.useDefaultPath = getStorageItem(storageKey, false);
+        
+        const toggleInput = document.getElementById('importUseDefaultPath');
+        if (toggleInput) {
+            toggleInput.checked = this.useDefaultPath;
+            this.updatePathSelectionUI();
+        }
+    }
+
+    toggleDefaultPath(event) {
+        this.useDefaultPath = event.target.checked;
+        
+        // Save to localStorage for LoRAs
+        const storageKey = 'use_default_path_loras';
+        setStorageItem(storageKey, this.useDefaultPath);
+        
+        this.updatePathSelectionUI();
+        this.updateTargetPath();
+    }
+
+    updatePathSelectionUI() {
+        const manualSelection = document.getElementById('importManualPathSelection');
+        
+        // Always show manual path selection, but disable/enable based on useDefaultPath
+        if (manualSelection) {
+            manualSelection.style.display = 'block';
+            if (this.useDefaultPath) {
+                manualSelection.classList.add('disabled');
+                // Disable all inputs and buttons inside manualSelection
+                manualSelection.querySelectorAll('input, select, button').forEach(el => {
+                    el.disabled = true;
+                    el.tabIndex = -1;
+                });
+            } else {
+                manualSelection.classList.remove('disabled');
+                manualSelection.querySelectorAll('input, select, button').forEach(el => {
+                    el.disabled = false;
+                    el.tabIndex = 0;
+                });
+            }
+        }
+        
+        // Always update the main path display
+        this.updateTargetPath();
+    }
+
+    async initializeFolderTree() {
+        try {
+            // Fetch unified folder tree
+            const treeData = await this.apiClient.fetchUnifiedFolderTree();
+            
+            if (treeData.success) {
+                // Load tree data into folder tree manager
+                await this.folderTreeManager.loadTree(treeData.tree);
+            } else {
+                console.error('Failed to fetch folder tree:', treeData.error);
+                showToast('Failed to load folder tree', 'error');
+            }
+        } catch (error) {
+            console.error('Error initializing folder tree:', error);
+            showToast('Error loading folder tree', 'error');
+        }
+    }
+
+    cleanupFolderBrowser() {
+        if (this.folderTreeManager) {
+            this.folderTreeManager.destroy();
+        }
+    }
+
     updateTargetPath() {
-        this.folderBrowser.updateTargetPath();
+        const pathDisplay = document.getElementById('importTargetPathDisplay');
+        const loraRoot = document.getElementById('importLoraRoot').value;
+        
+        let fullPath = loraRoot || 'Select a LoRA root directory';
+        
+        if (loraRoot) {
+            if (this.useDefaultPath) {
+                // Show actual template path
+                try {
+                    const templates = state.global.settings.download_path_templates;
+                    const template = templates.lora;
+                    fullPath += `/${template}`;
+                } catch (error) {
+                    console.error('Failed to fetch template:', error);
+                    fullPath += '/[Auto-organized by path template]';
+                }
+            } else {
+                // Show manual path selection
+                const selectedPath = this.folderTreeManager ? this.folderTreeManager.getSelectedPath() : '';
+                if (selectedPath) {
+                    fullPath += '/' + selectedPath;
+                }
+            }
         }
 
-    ensureModalVisible() {
+        if (pathDisplay) {
-        const importModal = document.getElementById('importModal');
+            pathDisplay.innerHTML = `<span class="path-text">${fullPath}</span>`;
-        if (!importModal) {
-            console.error('Import modal element not found');
-            return false;
         }
-        
-        // Check if modal is actually visible
-        const modalDisplay = window.getComputedStyle(importModal).display;
-        if (modalDisplay !== 'block') {
-            console.error('Import modal is not visible, display: ' + modalDisplay);
-            return false;
-        }
-        
-        return true;
     }
 
     /**

static/js/managers/SettingsManager.js

@@ -132,12 +132,8 @@ export class SettingsManager {
 
         fieldsToSync.forEach(key => {
             if (localSettings[key] !== undefined) {
-                if (key === 'base_model_path_mappings' || key === 'download_path_templates') {
-                    payload[key] = JSON.stringify(localSettings[key]);
-                } else {
                 payload[key] = localSettings[key];
             }
-            }
         });
 
         // Only send request if there is something to sync
@@ -546,7 +542,7 @@ export class SettingsManager {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({
-                    base_model_path_mappings: JSON.stringify(state.global.settings.base_model_path_mappings)
+                    base_model_path_mappings: state.global.settings.base_model_path_mappings
                 })
             });
 
@@ -733,7 +729,7 @@ export class SettingsManager {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({
-                    download_path_templates: JSON.stringify(state.global.settings.download_path_templates)
+                    download_path_templates: state.global.settings.download_path_templates
                 })
             });
 
@@ -868,7 +864,7 @@ export class SettingsManager {
             if (settingKey === 'default_lora_root' || settingKey === 'default_checkpoint_root' || settingKey === 'default_embedding_root' || settingKey === 'download_path_templates') {
                 const payload = {};
                 if (settingKey === 'download_path_templates') {
-                    payload[settingKey] = JSON.stringify(state.global.settings.download_path_templates);
+                    payload[settingKey] = state.global.settings.download_path_templates;
                 } else {
                     payload[settingKey] = value;
                 }

static/js/managers/import/DownloadManager.js

@@ -1,6 +1,7 @@
 import { showToast } from '../../utils/uiHelpers.js';
 import { getModelApiClient } from '../../api/modelApiFactory.js';
 import { MODEL_TYPES } from '../../api/apiConfig.js';
+import { getStorageItem } from '../../utils/storageHelpers.js';
 
 export class DownloadManager {
     constructor(importManager) {
@@ -120,14 +121,9 @@ export class DownloadManager {
         }
         
         // Build target path
-        let targetPath = loraRoot;
+        let targetPath = '';
         if (this.importManager.selectedFolder) {
-            targetPath += '/' + this.importManager.selectedFolder;
+            targetPath = this.importManager.selectedFolder;
-        }
-        
-        const newFolder = document.getElementById('importNewFolder')?.value?.trim();
-        if (newFolder) {
-            targetPath += '/' + newFolder;
         }
         
         // Generate a unique ID for this batch download
@@ -190,6 +186,8 @@ export class DownloadManager {
             }
         };
 
+        const useDefaultPaths = getStorageItem('use_default_path_loras', false);
+        
         for (let i = 0; i < this.importManager.downloadableLoRAs.length; i++) {
             const lora = this.importManager.downloadableLoRAs[i];
             
@@ -207,6 +205,7 @@ export class DownloadManager {
                     lora.id,
                     loraRoot,
                     targetPath.replace(loraRoot + '/', ''),
+                    useDefaultPaths,
                     batchDownloadId
                 );
                 

templates/components/import_modal.html

@@ -1,7 +1,9 @@
 <div id="importModal" class="modal">
     <div class="modal-content">
+        <div class="modal-header">
             <button class="close" onclick="modalManager.closeModal('importModal')">&times;</button>
             <h2>Import Recipe</h2>
+        </div>
         
         <!-- Step 1: Upload Image or Input URL -->
         <div class="import-step" id="uploadStep">
@@ -99,42 +101,59 @@
         <!-- Step 3: Download Location (if needed) -->
         <div class="import-step" id="locationStep" style="display: none;">
             <div class="location-selection">
-                <!-- Improved missing LoRAs summary section -->
+                <!-- Path preview with inline toggle -->
-                <div class="missing-loras-summary">
-                    <div class="summary-header">
-                        <h3>Missing LoRAs <span class="lora-count-badge">(0)</span> <span id="totalDownloadSize" class="total-size-badge">Calculating...</span></h3>
-                        <button id="toggleMissingLorasList" class="toggle-list-btn">
-                            <i class="fas fa-chevron-down"></i>
-                        </button>
-                    </div>
-                    <div id="missingLorasList" class="missing-loras-list collapsed">
-                        <!-- Missing LoRAs will be populated here -->
-                    </div>
-                </div>
-
-                <!-- Move path preview to top -->
                 <div class="path-preview">
+                    <div class="path-preview-header">
                         <label>Download Location Preview:</label>
+                        <div class="inline-toggle-container" title="When enabled, files are automatically organized using configured path templates">
+                            <span class="inline-toggle-label">Use Default Path</span>
+                            <div class="toggle-switch">
+                                <input type="checkbox" id="importUseDefaultPath">
+                                <label for="importUseDefaultPath" class="toggle-slider"></label>
+                            </div>
+                        </div>
+                    </div>
                     <div class="path-display" id="importTargetPathDisplay">
                         <span class="path-text">Select a LoRA root directory</span>
                     </div>
                 </div>
 
+                <!-- Model Root Selection -->
                 <div class="input-group">
-                    <label>Select LoRA Root:</label>
+                    <label for="importLoraRoot">Select LoRA Root:</label>
                     <select id="importLoraRoot"></select>
                 </div>
 
+                <!-- Manual Path Selection -->
+                <div class="manual-path-selection" id="importManualPathSelection">
+                    <!-- Path input with autocomplete -->
                     <div class="input-group">
-                    <label>Target Folder:</label>
+                        <label for="importFolderPath">Target Folder Path:</label>
-                    <div class="folder-browser" id="importFolderBrowser">
+                        <div class="path-input-container">
-                        <!-- Folders will be populated here -->
+                            <input type="text" id="importFolderPath" placeholder="Type folder path or select from tree below..." autocomplete="off" />
+                            <button type="button" id="importCreateFolderBtn" class="create-folder-btn" title="Create new folder">
+                                <i class="fas fa-plus"></i>
+                            </button>
                         </div>
+                        <div class="path-suggestions" id="importPathSuggestions" style="display: none;"></div>
                     </div>
                     
+                    <!-- Breadcrumb navigation -->
+                    <div class="breadcrumb-nav" id="importBreadcrumbNav">
+                        <span class="breadcrumb-item root" data-path="">
+                            <i class="fas fa-home"></i> Root
+                        </span>
+                    </div>
+                    
+                    <!-- Hierarchical folder tree -->
                     <div class="input-group">
-                    <label for="importNewFolder">New Folder (optional):</label>
+                        <label>Browse Folders:</label>
-                    <input type="text" id="importNewFolder" placeholder="Enter folder name">
+                        <div class="folder-tree-container">
+                            <div class="folder-tree" id="importFolderTree">
+                                <!-- Tree will be loaded dynamically -->
+                            </div>
+                        </div>
+                    </div>
                 </div>
             </div>
             

web/comfyui/autocomplete.js

@@ -141,11 +141,18 @@ class AutoComplete {
     }
     
     getSearchTerm(value) {
-        const lastCommaIndex = value.lastIndexOf(',');
+        // Use helper to get text before cursor for more accurate positioning
-        if (lastCommaIndex === -1) {
+        const beforeCursor = this.helper.getBeforeCursor();
-            return value.trim();
+        if (!beforeCursor) {
+            return '';
         }
-        return value.substring(lastCommaIndex + 1).trim();
+        
+        // Split on multiple delimiters: comma, space, '>' and other common separators
+        const segments = beforeCursor.split(/[,\s>]+/);
+        
+        // Return the last non-empty segment as search term
+        const lastSegment = segments[segments.length - 1] || '';
+        return lastSegment.trim();
     }
     
     async search(term = '') {
@@ -221,6 +228,13 @@ class AutoComplete {
         if (this.dropdown.lastChild) {
             this.dropdown.lastChild.style.borderBottom = 'none';
         }
+        
+        // Auto-select the first item with a small delay
+        if (this.items.length > 0) {
+            setTimeout(() => {
+            this.selectItem(0);
+            }, 100); // 50ms delay
+        }
     }
     
     highlightMatch(text, searchTerm) {

web/comfyui/lora_loader.js

@@ -6,7 +6,7 @@ import {
   updateConnectedTriggerWords,
   chainCallback,
   mergeLoras,
-    setupInputWidgetWithAutocomplete
+  setupInputWidgetWithAutocomplete,
 } from "./utils.js";
 import { addLorasWidget } from "./loras_widget.js";
 
@@ -36,12 +36,16 @@ app.registerExtension({
 
       // Update each Lora Loader node found
       if (loraLoaderNodes.length > 0) {
-                loraLoaderNodes.forEach(node => {
+        loraLoaderNodes.forEach((node) => {
           this.updateNodeLoraCode(node, loraCode, mode);
         });
-                console.log(`Updated ${loraLoaderNodes.length} Lora Loader nodes in broadcast mode`);
+        console.log(
+          `Updated ${loraLoaderNodes.length} Lora Loader nodes in broadcast mode`
+        );
       } else {
-                console.warn("No Lora Loader nodes found in the workflow for broadcast update");
+        console.warn(
+          "No Lora Loader nodes found in the workflow for broadcast update"
+        );
       }
 
       return;
@@ -49,9 +53,12 @@ app.registerExtension({
 
     // Standard mode - update a specific node
     const node = app.graph.getNodeById(+id);
-        if (!node || (node.comfyClass !== "Lora Loader (LoraManager)" && 
+    if (
+      !node ||
+      (node.comfyClass !== "Lora Loader (LoraManager)" &&
         node.comfyClass !== "Lora Stacker (LoraManager)" &&
-                node.comfyClass !== "WanVideo Lora Select (LoraManager)")) {
+        node.comfyClass !== "WanVideo Lora Select (LoraManager)")
+    ) {
       console.warn("Node not found or not a LoraLoader:", id);
       return;
     }
@@ -66,10 +73,10 @@ app.registerExtension({
     if (!inputWidget) return;
 
     // Get the current lora code
-        const currentValue = inputWidget.value || '';
+    const currentValue = inputWidget.value || "";
 
     // Update based on mode (replace or append)
-        if (mode === 'replace') {
+    if (mode === "replace") {
       inputWidget.value = loraCode;
     } else {
       // Append mode - add a space if the current value isn't empty
@@ -79,7 +86,7 @@ app.registerExtension({
     }
 
     // Trigger the callback to update the loras widget
-        if (typeof inputWidget.callback === 'function') {
+    if (typeof inputWidget.callback === "function") {
       inputWidget.callback(inputWidget.value);
     }
   },
@@ -98,19 +105,6 @@ app.registerExtension({
           shape: 7, // 7 is the shape of the optional input
         });
 
-            // Restore saved value if exists
-            let existingLoras = [];
-            if (this.widgets_values && this.widgets_values.length > 0) {
-              // 0 for input widget, 1 for loras widget
-              const savedValue = this.widgets_values[1];
-              existingLoras = savedValue || [];
-            }
-            // Merge the loras data
-            const mergedLoras = mergeLoras(
-              this.widgets[0].value,
-              existingLoras
-            );
-
         // Add flag to prevent callback loops
         let isUpdating = false;
 
@@ -118,9 +112,7 @@ app.registerExtension({
         this.lorasWidget = addLorasWidget(
           this,
           "loras",
-              {
+          {},
-                defaultVal: mergedLoras, // Pass object directly
-              },
           (value) => {
             // Collect all active loras from this node and its input chain
             const allActiveLoraNames = collectActiveLorasFromChain(this);
@@ -146,7 +138,10 @@ app.registerExtension({
               );
 
               // Clean up multiple spaces, extra commas, and trim; remove trailing comma if it's the only content
-                  newText = newText.replace(/\s+/g, " ").replace(/,\s*,+/g, ",").trim();
+              newText = newText
+                .replace(/\s+/g, " ")
+                .replace(/,\s*,+/g, ",")
+                .trim();
               if (newText === ",") newText = "";
 
               inputWidget.value = newText;
@@ -176,25 +171,29 @@ app.registerExtension({
         };
 
         // Setup input widget with autocomplete
-            inputWidget.callback = setupInputWidgetWithAutocomplete(this, inputWidget, originalCallback);
+        inputWidget.callback = setupInputWidgetWithAutocomplete(
+          this,
+          inputWidget,
+          originalCallback
+        );
 
         // Register this node with the backend
         this.registerNode = async () => {
           try {
-                await fetch('/api/register-node', {
+            await fetch("/api/register-node", {
-                  method: 'POST',
+              method: "POST",
               headers: {
-                    'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
               body: JSON.stringify({
                 node_id: this.id,
                 bgcolor: this.bgcolor,
                 title: this.title,
-                    graph_id: this.graph.id
+                graph_id: this.graph.id,
-                  })
+              }),
             });
           } catch (error) {
-                console.warn('Failed to register node:', error);
+            console.warn("Failed to register node:", error);
           }
         };
 
@@ -206,4 +205,21 @@ app.registerExtension({
       });
     }
   },
+
+  async nodeCreated(node) {
+    if (node.comfyClass == "Lora Loader (LoraManager)") {
+      requestAnimationFrame(async () => {
+        // Restore saved value if exists
+        let existingLoras = [];
+        if (node.widgets_values && node.widgets_values.length > 0) {
+          // 0 for input widget, 1 for loras widget
+          const savedValue = node.widgets_values[1];
+          existingLoras = savedValue || [];
+        }
+        // Merge the loras data
+        const mergedLoras = mergeLoras(node.widgets[0].value, existingLoras);
+        node.lorasWidget.value = mergedLoras;
+      });
+    }
+  },
 });

web/comfyui/lora_stacker.js

@@ -6,7 +6,7 @@ import {
   updateConnectedTriggerWords,
   chainCallback,
   mergeLoras,
-    setupInputWidgetWithAutocomplete
+  setupInputWidgetWithAutocomplete,
 } from "./utils.js";
 import { addLorasWidget } from "./loras_widget.js";
 
@@ -19,26 +19,14 @@ app.registerExtension({
         // Enable widget serialization
         this.serialize_widgets = true;
 
-                this.addInput("lora_stack", 'LORA_STACK', {
+        this.addInput("lora_stack", "LORA_STACK", {
-                    "shape": 7  // 7 is the shape of the optional input
+          shape: 7, // 7 is the shape of the optional input
         });
 
-                // Restore saved value if exists
-                let existingLoras = [];
-                if (this.widgets_values && this.widgets_values.length > 0) {
-                    // 0 for input widget, 1 for loras widget
-                    const savedValue = this.widgets_values[1];
-                    existingLoras = savedValue || [];
-                }
-                // Merge the loras data
-                const mergedLoras = mergeLoras(this.widgets[0].value, existingLoras);
-                
         // Add flag to prevent callback loops
         let isUpdating = false;
 
-                const result = addLorasWidget(this, "loras", {
+        const result = addLorasWidget(this, "loras", {}, (value) => {
-                    defaultVal: mergedLoras  // Pass object directly
-                }, (value) => {
           // Prevent recursive calls
           if (isUpdating) return;
           isUpdating = true;
@@ -46,22 +34,28 @@ app.registerExtension({
           try {
             // Remove loras that are not in the value array
             const inputWidget = this.widgets[0];
-                        const currentLoras = value.map(l => l.name);
+            const currentLoras = value.map((l) => l.name);
 
             // Use the constant pattern here as well
-                        let newText = inputWidget.value.replace(LORA_PATTERN, (match, name, strength) => {
+            let newText = inputWidget.value.replace(
-                            return currentLoras.includes(name) ? match : '';
+              LORA_PATTERN,
-                        });
+              (match, name, strength) => {
+                return currentLoras.includes(name) ? match : "";
+              }
+            );
 
             // Clean up multiple spaces, extra commas, and trim; remove trailing comma if it's the only content
-                        newText = newText.replace(/\s+/g, " ").replace(/,\s*,+/g, ",").trim();
+            newText = newText
+              .replace(/\s+/g, " ")
+              .replace(/,\s*,+/g, ",")
+              .trim();
             if (newText === ",") newText = "";
 
             inputWidget.value = newText;
 
             // Update this stacker's direct trigger toggles with its own active loras
             const activeLoraNames = new Set();
-                        value.forEach(lora => {
+            value.forEach((lora) => {
               if (lora.active) {
                 activeLoraNames.add(lora.name);
               }
@@ -102,25 +96,29 @@ app.registerExtension({
             isUpdating = false;
           }
         };
-                inputWidget.callback = setupInputWidgetWithAutocomplete(this, inputWidget, originalCallback);
+        inputWidget.callback = setupInputWidgetWithAutocomplete(
+          this,
+          inputWidget,
+          originalCallback
+        );
 
         // Register this node with the backend
         this.registerNode = async () => {
           try {
-                        await fetch('/api/register-node', {
+            await fetch("/api/register-node", {
-                            method: 'POST',
+              method: "POST",
               headers: {
-                                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
               body: JSON.stringify({
                 node_id: this.id,
                 bgcolor: this.bgcolor,
                 title: this.title,
-                                graph_id: this.graph.id
+                graph_id: this.graph.id,
-                            })
+              }),
             });
           } catch (error) {
-                        console.warn('Failed to register node:', error);
+            console.warn("Failed to register node:", error);
           }
         };
 
@@ -131,6 +129,22 @@ app.registerExtension({
       });
     }
   },
+  async nodeCreated(node) {
+    if (node.comfyClass == "Lora Stacker (LoraManager)") {
+      requestAnimationFrame(async () => {
+        // Restore saved value if exists
+        let existingLoras = [];
+        if (node.widgets_values && node.widgets_values.length > 0) {
+          // 0 for input widget, 1 for loras widget
+          const savedValue = node.widgets_values[1];
+          existingLoras = savedValue || [];
+        }
+        // Merge the loras data
+        const mergedLoras = mergeLoras(node.widgets[0].value, existingLoras);
+        node.lorasWidget.value = mergedLoras;
+      });
+    }
+  },
 });
 
 // Helper function to find and update downstream Lora Loader nodes
@@ -148,12 +162,19 @@ function updateDownstreamLoaders(startNode, visited = new Set()) {
             const targetNode = app.graph.getNodeById(link.target_id);
 
             // If target is a Lora Loader, collect all active loras in the chain and update
-                        if (targetNode && targetNode.comfyClass === "Lora Loader (LoraManager)") {
+            if (
-                            const allActiveLoraNames = collectActiveLorasFromChain(targetNode);
+              targetNode &&
+              targetNode.comfyClass === "Lora Loader (LoraManager)"
+            ) {
+              const allActiveLoraNames =
+                collectActiveLorasFromChain(targetNode);
               updateConnectedTriggerWords(targetNode, allActiveLoraNames);
             }
             // If target is another Lora Stacker, recursively check its outputs
-                        else if (targetNode && targetNode.comfyClass === "Lora Stacker (LoraManager)") {
+            else if (
+              targetNode &&
+              targetNode.comfyClass === "Lora Stacker (LoraManager)"
+            ) {
               updateDownstreamLoaders(targetNode, visited);
             }
           }

web/comfyui/loras_widget.js

@@ -676,24 +676,8 @@ export function addLorasWidget(node, name, opts, callback) {
         return [...filtered, lora];
       }, []);
       
-      // Preserve clip strengths and expanded state when updating the value
-      const oldLoras = parseLoraValue(widgetValue);
-      
       // Apply existing clip strength values and transfer them to the new value
       const updatedValue = uniqueValue.map(lora => {       
-        const existingLora = oldLoras.find(oldLora => oldLora.name === lora.name);
-        
-        // If there's an existing lora with the same name, preserve its clip strength and expanded state
-        if (existingLora) {
-          return {
-            ...lora,
-            clipStrength: existingLora.clipStrength || lora.strength,
-            expanded: existingLora.hasOwnProperty('expanded') ? 
-                      existingLora.expanded : 
-                      Number(existingLora.clipStrength || lora.strength) !== Number(lora.strength)
-          };
-        }
-        
         // For new loras, default clip strength to model strength and expanded to false
         // unless clipStrength is already different from strength
         const clipStrength = lora.clipStrength || lora.strength;

web/comfyui/utils.js

@@ -69,21 +69,6 @@ export function hideWidgetForGood(node, widget, suffix = "") {
   }
 }
 
-// Wrapper class to handle 'two element array bug' in LiteGraph or comfyui
-export class DataWrapper {
-  constructor(data) {
-    this.data = data;
-  }
-
-  getData() {
-    return this.data;
-  }
-
-  setData(data) {
-    this.data = data;
-  }
-}
-
 // Function to get the appropriate loras widget based on ComfyUI version
 export async function getLorasWidgetModule() {
   return await dynamicImportByVersion("./loras_widget.js", "./legacy_loras_widget.js");
@@ -208,6 +193,7 @@ export function mergeLoras(lorasText, lorasArr) {
         name: lora.name,
         strength: lora.strength !== undefined ? lora.strength : parsedLoras[lora.name].strength,
         active: lora.active !== undefined ? lora.active : true,
+        expanded: lora.expanded !== undefined ? lora.expanded : false,
         clipStrength: lora.clipStrength !== undefined ? lora.clipStrength : parsedLoras[lora.name].clipStrength,
       });
       usedNames.add(lora.name);

web/comfyui/wanvideo_lora_select.js

@@ -5,7 +5,7 @@ import {
   updateConnectedTriggerWords,
   chainCallback,
   mergeLoras,
-    setupInputWidgetWithAutocomplete
+  setupInputWidgetWithAutocomplete,
 } from "./utils.js";
 import { addLorasWidget } from "./loras_widget.js";
 
@@ -19,53 +19,47 @@ app.registerExtension({
         this.serialize_widgets = true;
 
         // Add optional inputs
-                this.addInput("prev_lora", 'WANVIDLORA', {
+        this.addInput("prev_lora", "WANVIDLORA", {
-                    "shape": 7  // 7 is the shape of the optional input
+          shape: 7, // 7 is the shape of the optional input
         });
 
-                this.addInput("blocks", 'SELECTEDBLOCKS', {
+        this.addInput("blocks", "SELECTEDBLOCKS", {
-                    "shape": 7  // 7 is the shape of the optional input
+          shape: 7, // 7 is the shape of the optional input
         });
 
-                // Restore saved value if exists
-                let existingLoras = [];
-                if (this.widgets_values && this.widgets_values.length > 0) {
-                    // 0 for low_mem_load, 1 for text widget, 2 for loras widget
-                    const savedValue = this.widgets_values[2];
-                    existingLoras = savedValue || [];
-                }
-                // Merge the loras data
-                const mergedLoras = mergeLoras(this.widgets[1].value, existingLoras);
-                
         // Add flag to prevent callback loops
         let isUpdating = false;
 
-                const result = addLorasWidget(this, "loras", {
+        const result = addLorasWidget(this, "loras", {}, (value) => {
-                    defaultVal: mergedLoras  // Pass object directly
-                }, (value) => {
           // Prevent recursive calls
           if (isUpdating) return;
           isUpdating = true;
 
           try {
             // Remove loras that are not in the value array
-                        const inputWidget = this.widgets[1];
+            const inputWidget = this.widgets[2];
-                        const currentLoras = value.map(l => l.name);
+            const currentLoras = value.map((l) => l.name);
 
             // Use the constant pattern here as well
-                        let newText = inputWidget.value.replace(LORA_PATTERN, (match, name, strength) => {
+            let newText = inputWidget.value.replace(
-                            return currentLoras.includes(name) ? match : '';
+              LORA_PATTERN,
-                        });
+              (match, name, strength) => {
+                return currentLoras.includes(name) ? match : "";
+              }
+            );
 
             // Clean up multiple spaces, extra commas, and trim; remove trailing comma if it's the only content
-                        newText = newText.replace(/\s+/g, " ").replace(/,\s*,+/g, ",").trim();
+            newText = newText
+              .replace(/\s+/g, " ")
+              .replace(/,\s*,+/g, ",")
+              .trim();
             if (newText === ",") newText = "";
 
             inputWidget.value = newText;
 
             // Update this node's direct trigger toggles with its own active loras
             const activeLoraNames = new Set();
-                        value.forEach(lora => {
+            value.forEach((lora) => {
               if (lora.active) {
                 activeLoraNames.add(lora.name);
               }
@@ -79,7 +73,7 @@ app.registerExtension({
         this.lorasWidget = result.widget;
 
         // Update input widget callback
-                const inputWidget = this.widgets[1];
+        const inputWidget = this.widgets[2];
         inputWidget.options.getMaxHeight = () => 100;
         this.inputWidget = inputWidget;
         // Wrap the callback with autocomplete setup
@@ -100,7 +94,27 @@ app.registerExtension({
             isUpdating = false;
           }
         };
-                inputWidget.callback = setupInputWidgetWithAutocomplete(this, inputWidget, originalCallback);
+        inputWidget.callback = setupInputWidgetWithAutocomplete(
+          this,
+          inputWidget,
+          originalCallback
+        );
+      });
+    }
+  },
+  async nodeCreated(node) {
+    if (node.comfyClass == "WanVideo Lora Select (LoraManager)") {
+      requestAnimationFrame(async () => {
+        // Restore saved value if exists
+        let existingLoras = [];
+        if (node.widgets_values && node.widgets_values.length > 0) {
+          // 0 for low_mem_load, 1 for merge_loras, 2 for text widget, 3 for loras widget
+          const savedValue = node.widgets_values[3];
+          existingLoras = savedValue || [];
+        }
+        // Merge the loras data
+        const mergedLoras = mergeLoras(node.widgets[2].value, existingLoras);
+        node.lorasWidget.value = mergedLoras;
       });
     }
   },