ComfyUI LoRA Manager

https://github.com/willmiao/comfyui-lora-manager
Admin
A comprehensive toolset for organizing, downloading, and applying LoRA models in ComfyUI with recipe...
Tokens:37,454
Snippets:548
Trust Score:8.8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Manual Installation using Git Clone

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Install the LoRA Manager by cloning the repository and installing requirements.

```bash
git clone https://github.com/willmiao/ComfyUI-Lora-Manager.git
cd ComfyUI-Lora-Manager
pip install -r requirements.txt
```

--------------------------------

### Example aria2c Path on macOS (Intel)

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Example of a full executable path for aria2c on macOS with Intel processors, installed via Homebrew.

```text
/usr/local/bin/aria2c
```

--------------------------------

### Install Frontend Dependencies

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Installs JavaScript dependencies for the standalone web UI using npm. Run this in the project root.

```bash
npm install
```

--------------------------------

### Example aria2c Path on Linux

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Example of a full executable path for aria2c on Linux, typically found in /usr/bin after package installation.

```text
/usr/bin/aria2c
```

--------------------------------

### Simplified Test Setup with Fixtures

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Demonstrates refactoring a complex test setup into a cleaner version using fixtures, making the test logic more readable.

```python
async def test_start_download_bootstraps_progress_and_task(
    download_manager_with_fake_backend,
    release_event
):
    # Setup in fixtures, test is clean
    manager = download_manager_with_fake_backend
    result = await manager.start_download({"model_types": ["lora"]})
    assert result["success"] is True
    assert manager._is_downloading is True
```

--------------------------------

### Install Backend Dependencies

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Installs the necessary Python packages for the backend development. Includes core requirements and development-specific ones.

```bash
pip install -r requirements.txt
pip install -r requirements-dev.txt
```

--------------------------------

### Example aria2c Path on macOS (Apple Silicon)

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Example of a full executable path for aria2c on macOS with Apple Silicon (M1/M2/etc.), installed via Homebrew.

```text
/opt/homebrew/bin/aria2c
```

--------------------------------

### User-Added Custom Images Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/metadata-json-schema.md

An example demonstrating how to include user-added custom images within the Civitai configuration.

```json
{
  "civitai": {
    "trainedWords": ["custom_style"],
    "customImages": [
      {
        "url": "",
        "id": "example_1",
        "nsfwLevel": 0,
        "width": 832,
        "height": 1216,
        "type": "image",
        "meta": {
          "prompt": "example prompt",
          "seed": 12345
        },
        "hasMeta": true,
        "hasPositivePrompt": true
      }
    ]
  }
}
```

--------------------------------

### Install Frontend Dependencies

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Installs Node.js dependencies for the frontend, including Vue widgets.

```bash
npm install
cd vue-widgets && npm install && cd ..
```

--------------------------------

### Example aria2c Path on Windows

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Example of a full executable path for aria2c on Windows, used when the aria2 directory is not added to the system PATH.

```text
C:\tools\aria2\aria2c.exe
```

--------------------------------

### Filename Pattern Examples

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Examples of how to use various patterns to format generated image filenames, including seed, dimensions, model names, dates, and prompts.

```text
image_%seed% → image_1234567890
```

```text
gen_%width%x%height% → gen_512x768
```

```text
%model:10%_%seed% → dreamshape_1234567890
```

```text
%date:yyyy-MM-dd% → 2025-04-28
```

```text
%pprompt:20%_%seed% → beautiful landscape_1234567890
```

```text
%model%_%date:yyMMdd%_%seed% → dreamshaper_v8_250428_1234567890
```

--------------------------------

### Install Dependencies

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Command to install the necessary Python dependencies for LoRA Manager.

```bash
pip install -r requirements.txt
```

--------------------------------

### Wildcard Example: Text File

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Demonstrates how to use a simple text file for wildcard expansion in TextLM/PromptLM. Place this file in the 'wildcards' folder.

```txt
# wildcards/color.txt
red
blue
green
```

--------------------------------

### Wildcard Example: YAML File

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Shows how to define nested wildcards using a YAML file for TextLM/PromptLM. Place this file in the 'wildcards' folder.

```yaml
# wildcards/colors.yaml
palette:
  warm:
    - red
    - orange
```

--------------------------------

### Minimal Clipboard-Only Setup

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Remote-Open-for-Example-Images

Configure LoRA Manager to copy the local path to the clipboard for manual pasting into file explorers.

```yaml
openMode:    Copy local path
localRoot:   /Volumes/lora-manager/example_images
```

--------------------------------

### Non-Civitai Configuration Without Trigger Words

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/metadata-json-schema.md

A non-Civitai configuration example where no specific trigger words are defined.

```json
{
  "civitai": {}
}
```

--------------------------------

### Example Priority Tag Entry

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

A sample entry list showing canonical tags and their aliases. Aliases are in parentheses and separated by pipes.

```text
character, concept, style(toon|toon_style)
```

--------------------------------

### Run Standalone Backend Server

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Starts the standalone Python server for the LoRA Manager. Defaults to port 8188.

```bash
python standalone.py --port 8188
```

--------------------------------

### Goal: Alias Shorthand Tags

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

Example priority list configuration using shorthand aliases for longer canonical tag names.

```text
realistic(real|realisim), photorealistic(photo_real)
```

--------------------------------

### Example Image Route Architecture Diagram

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/example_images_routes.md

A Mermaid diagram illustrating the layered architecture of the example image routing stack, showing the flow between HTTP, Application, and Side Effects layers.

```mermaid
graph TD
    subgraph HTTP
        A[ExampleImagesRouteRegistrar] -->|binds| B[ExampleImagesRoutes controller]
    end
    subgraph Application
        B --> C[ExampleImagesHandlerSet]
        C --> D1[Handlers]
        D1 --> E1[Use cases]
        E1 --> F1[Download manager / processor / file manager]
    end
    subgraph Side Effects
        F1 --> G1[Filesystem]
        F1 --> G2[Model metadata]
        F1 --> G3[WebSocket progress]
    end
```

--------------------------------

### Windows SMB Mount Configuration

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Remote-Open-for-Example-Images

Configure LoRA Manager to open example images in Explorer on Windows via an SMB mount using a custom URI.

```yaml
openMode:    Open custom URI
localRoot:   Z:\lora-manager\example_images
uriTemplate: file:///{{encoded_local_path}}
```

--------------------------------

### Install Vue Widget Dependencies

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Installs Node.js dependencies specifically for the Vue widgets. Navigate to the 'vue-widgets' directory first.

```bash
cd vue-widgets
npm install
```

--------------------------------

### Apple Shortcuts Configuration

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Remote-Open-for-Example-Images

Configure LoRA Manager to open example images using Apple Shortcuts on macOS, passing the local path as text input.

```yaml
openMode:    Open custom URI
localRoot:   /Volumes/lora-manager/example_images
uriTemplate: shortcuts://run-shortcut?name=Open%20Finder&input=text&text={{encoded_local_path}}
```

--------------------------------

### Alias Syntax Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/priority_tags_help.md

Illustrates the correct syntax for defining aliases within parentheses, separated by '|', for a canonical tag.

```plaintext
character(char|chars)
```

--------------------------------

### Run Standalone with Custom Host/Port

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Command to launch LoRA Manager standalone with specified host and port. Ensure dependencies are installed first.

```bash
python custom_nodes\comfyui-lora-manager\standalone.py --host 127.0.0.1 --port 9000
```

--------------------------------

### Vue Build Config Function Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

An example of a function that builds a configuration object based on component state in a Vue application. Uses TypeScript for type safety.

```typescript
interface Config { /* ... */ }

const buildConfig = (): Config => {
  // Logic to build config based on state
  return { /* config object */ };
};
```

--------------------------------

### Goal: Prefer People Over Styles

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

Example priority list configuration to prioritize 'people' related tags over 'style' tags.

```text
character, portraits, style(anime|toon)
```

--------------------------------

### Run Vue Widget Dev Mode

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Starts the Vue widget development server, which watches for changes and rebuilds automatically.

```bash
cd vue-widgets && npm run dev
```

--------------------------------

### ComfyUI Node Widget Registration Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows how to register a new node widget within ComfyUI using `app.registerExtension()`. This is the entry point for custom nodes.

```javascript
app.registerExtension({
    name: "MyCustomNode",
    registerNodes: function() {
        // Node registration logic here
    }
});
```

--------------------------------

### Python Imports and Formatting Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates Python import grouping and the use of `from __future__ import annotations`. Follows PEP 8 with 4-space indentation and type hints.

```python
from __future__ import annotations

import os
import sys

import aiohttp
import pytest

from py.services import X
from py.utils import Y
```

--------------------------------

### Python Async Response Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates returning JSON responses in an async context using `aiohttp.web.json_response`. This is standard for API endpoints.

```python
from aiohttp import web

async def handler(request):
    return web.json_response({'message': 'success'})

```

--------------------------------

### macOS SMB Mount Configuration

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Remote-Open-for-Example-Images

Configure LoRA Manager to open example images in Finder on macOS via an SMB mount using a custom URI.

```yaml
openMode:    Open custom URI
localRoot:   /Volumes/lora-manager/example_images
uriTemplate: file://{{encoded_local_path}}
```

--------------------------------

### Vue Composition API Import Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Demonstrates importing reactive utilities like `ref` and `computed` from Vue's Composition API. Also shows type-only imports.

```javascript
import { ref, computed } from 'vue';
import type { Foo } from './types';

```

--------------------------------

### Python Standalone Detection Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Demonstrates how to detect if the application is running in standalone mode using an environment variable. This allows for different configurations based on the deployment environment.

```python
import os

is_standalone = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"

if is_standalone:
    print("Running in standalone mode.")
else:
    print("Running as ComfyUI plugin.")
```

--------------------------------

### Python Async Test Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Demonstrates marking an asynchronous test function with `@pytest.mark.asyncio`. Requires `pytest-asyncio`.

```python
@pytest.mark.asyncio
async def test_something():
    assert True
```

--------------------------------

### Python Route Registrar Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Demonstrates the `ModelRouteRegistrar` for setting up API endpoints related to models. It defines routes like `/loras/*`, `/checkpoints/*`, etc.

```python
class ModelRouteRegistrar:
    def __init__(self, app: web.Application, model_service: BaseModelService):
        self.app = app
        self.model_service = model_service

    def register_routes(self):
        self.app.router.add_get('/loras', self.list_loras_handler)
        self.app.router.add_get('/checkpoints', self.list_checkpoints_handler)
        # ... other routes
```

--------------------------------

### Install aria2 on Linux (Arch)

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Install aria2 using the pacman package manager on Arch Linux. This command makes aria2c available in the system PATH.

```bash
sudo pacman -S aria2
```

--------------------------------

### Install aria2 on macOS

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Install aria2 using Homebrew on macOS. This command typically makes aria2c available in the system PATH.

```bash
brew install aria2
```

--------------------------------

### Simple Text Widget: Vue Component Setup

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom-widgets/value-persistence-best-practices.md

Vue component setup for a simple text widget, ensuring the DOM element reference is correctly assigned and cleaned up.

```typescript
onMounted(() => {
  if (textareaRef.value) {
    props.widget.inputEl = textareaRef.value
  }
})

onUnmounted(() => {
  if (props.widget.inputEl === textareaRef.value) {
    props.widget.inputEl = undefined
  }
})
```

--------------------------------

### Install aria2 on Linux (Debian/Ubuntu)

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Install aria2 using the apt package manager on Debian-based Linux distributions. This command makes aria2c available in the system PATH.

```bash
sudo apt install aria2
```

--------------------------------

### Backend Testing with Coverage

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Commands to install development dependencies and run pytest with coverage reports for the backend. Artifacts are stored in the coverage/backend directory.

```bash
pip install -r requirements-dev.txt
COVERAGE_FILE=coverage/backend/.coverage pytest \
  --cov=py \
  --cov=standalone \
  --cov-report=term-missing \
  --cov-report=html:coverage/backend/html \
  --cov-report=xml:coverage/backend/coverage.xml \
  --cov-report=json:coverage/backend/coverage.json
```

--------------------------------

### Install aria2 on Linux (Fedora)

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Aria2-Download-Backend-(Experimental)

Install aria2 using the dnf package manager on Fedora-based Linux distributions. This command makes aria2c available in the system PATH.

```bash
sudo dnf install aria2
```

--------------------------------

### Run Standalone for Non-ComfyUI Users

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Command to run LoRA Manager in standalone mode for users not using ComfyUI. Ensure dependencies are installed first.

```bash
python standalone.py
```

--------------------------------

### Priority Tag Configuration Examples

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/custom_priority_tags_format.md

Illustrates the custom priority tag format for different model types like lora, checkpoint, and embedding, showing canonical tags and their aliases.

```plaintext
lora: celebrity(celeb|celebrity), stylized, character(char)
checkpoint: realistic(realism|realistic), anime(anime-style|toon)
embedding: face, celeb(celebrity|celeb)
```

--------------------------------

### Vue Composable Pattern Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates the Vue composable pattern using `useXxxState(widget)`. It returns reactive refs and methods for managing component state.

```javascript
function useMyState(widget) {
  const count = ref(0);
  const increment = () => {
    count.value++;
  };
  return { count, increment };
}
```

--------------------------------

### JavaScript Named Export Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates exporting named functions in JavaScript modules, a common practice for reusable code.

```javascript
export function foo() {
  console.log('bar');
}
```

--------------------------------

### Python Path Normalization Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Highlights the importance of normalizing paths, especially when dealing with symlinks. This ensures consistent path handling across different operating systems and environments.

```python
import os

original_path = "/path/to/symlink"
normalized_path = os.path.normpath(os.path.realpath(original_path))

print(f"Original: {original_path}")
print(f"Normalized: {normalized_path}")
```

--------------------------------

### Run ComfyUI LoRA Manager Standalone

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Command to launch LoRA Manager independently from ComfyUI. Ensure dependencies are installed first.

```bash
python custom_nodes\comfyui-lora-manager\standalone.py
```

--------------------------------

### Python Singleton with Async Lock Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows how to implement a thread-safe singleton using `asyncio.Lock`. This pattern is used for managing shared resources like `ModelScanner`.

```python
class ModelScanner:
    _instance = None
    _lock = asyncio.Lock()

    async def __new__(cls):
        if cls._instance is None:
            async with cls._lock:
                # Double-check locking
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    await cls._instance.init()
        return cls._instance

    async def init(self):
        # Initialization logic here
```

--------------------------------

### Goal: Group Sci-Fi Variants

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

Example priority list configuration for grouping different variations of sci-fi tags.

```text
sci-fi(scifi|science_fiction), cyberpunk(cyber|punk)
```

--------------------------------

### Python WebSocket Manager Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates the `WebSocketManager` for handling real-time communication via WebSockets. This is used for broadcasting updates, such as model changes.

```python
class WebSocketManager:
    async def broadcast(self, message: str):
        # Sends a message to all connected clients
        pass

    async def send_to_client(self, client_id: str, message: str):
        # Sends a message to a specific client
        pass
```

--------------------------------

### Save Image Node Filename Pattern: Width and Height

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using %width% and %height% patterns to include image dimensions in the saved image filename.

```text
%width%_%height%
```

--------------------------------

### JavaScript ES Module Import Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows how to import modules in JavaScript using ES module syntax, specifically importing `app` from ComfyUI's core scripts.

```javascript
import { app } from "../../scripts/app.js";
```

--------------------------------

### ComfyUI Add DOM Widget Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Demonstrates adding a DOM widget to a node in ComfyUI. This allows for custom UI elements within nodes.

```javascript
node.addDOMWidget(name, type, element, options);
```

--------------------------------

### Custom Image Structure Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/metadata-json-schema.md

Defines the structure for a custom image entry, including URL, ID, NSFW level, dimensions, and generation metadata.

```json
{
  "url": "",
  "id": "short_id",
  "nsfwLevel": 0,
  "width": 832,
  "height": 1216,
  "type": "image",
  "meta": {
    "prompt": "...",
    "negativePrompt": "...",
    "steps": 20,
    "cfgScale": 7,
    "seed": 123456
  },
  "hasMeta": true,
  "hasPositivePrompt": true
}
```

--------------------------------

### Save Image Node Filename Pattern: Negative Prompt (Limited Characters)

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using %nprompt:N% to include the negative prompt, limited to N characters, in the saved image filename.

```text
%nprompt:50%
```

--------------------------------

### Save Image Node Filename Pattern: Seed

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using the %seed% pattern to include the generation seed in the saved image filename.

```text
%seed%
```

--------------------------------

### Vue Restoration Loop Guard Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows a common pattern in Vue for preventing infinite loops during state restoration using a boolean flag `isRestoring`.

```javascript
let isRestoring = false;

function restoreState() {
  if (isRestoring) return;
  isRestoring = true;
  // Restoration logic...
  isRestoring = false;
}
```

--------------------------------

### Save Image Node Filename Pattern: Date and Time

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using the %date% pattern to include the current date and time in 'yyyyMMddhhmmss' format in the saved image filename.

```text
%date%
```

--------------------------------

### Save Image Node Filename Pattern: Positive Prompt (Limited Characters)

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using %pprompt:N% to include the positive prompt, limited to N characters, in the saved image filename.

```text
%pprompt:50%
```

--------------------------------

### Save Image Node Filename Pattern: Custom Date Format

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using %date:FORMAT% to include the date and time with a custom format in the saved image filename.

```text
%date:yyyy-MM-dd_hh-mm-ss%
```

--------------------------------

### Python Persistent Model Cache Example

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows the usage of `PersistentModelCache` for storing and retrieving model information persistently, likely using an SQLite database. This speeds up access to model metadata.

```python
class PersistentModelCache:
    async def add_model(self, model_info: ModelInfo):
        # Adds model details to the cache
        pass

    async def get_model(self, model_id: str) -> ModelInfo | None:
        # Retrieves model details from the cache
        pass

    async def clear_cache(self):
        # Clears all entries from the cache
        pass
```

--------------------------------

### Save Image Node Filename Pattern: Model Name (Limited Characters)

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/README.md

Example of using %model:N% to include the model/checkpoint name, limited to N characters, in the saved image filename.

```text
%model:30%
```

--------------------------------

### Build Production Bundle for Vue Widgets

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Creates a production-ready bundle for the Vue widgets. Use this for deployment after development is complete.

```bash
npm run build
```

--------------------------------

### Run All Frontend Tests

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes all frontend tests, including both vanilla JavaScript and Vue widget tests.

```bash
npm test
```

--------------------------------

### Immediate Theme Application

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/templates/base.html

Applies the theme (light or dark) immediately based on user preference stored in local storage or system preference.

```javascript
(function() {
  const STORAGE_PREFIX = 'lora_manager_';
  const savedTheme = localStorage.getItem(STORAGE_PREFIX + 'theme') || 'auto';
  const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
  if (savedTheme === 'dark' || (savedTheme === 'auto' && prefersDark)) {
    document.documentElement.setAttribute('data-theme', 'dark');
  } else {
    document.documentElement.setAttribute('data-theme', 'light');
  }
})();
```

--------------------------------

### Path Template with {first_tag}

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

Illustrates how the {first_tag} placeholder in a path template uses the priority list and model tags to determine folder names.

```text
/{model_type}/{first_tag}
```

--------------------------------

### Python Service Registry Singleton

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Illustrates the `ServiceRegistry` singleton pattern for Dependency Injection. Services are accessed via a `get_instance()` classmethod.

```python
class ServiceRegistry:
    _instance = None
    _lock = asyncio.Lock()

    async def __new__(cls):
        if cls._instance is None:
            async with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    await cls._instance.init()
        return cls._instance

    async def init(self):
        # Initialize services here
        pass

# Usage:
# registry = await ServiceRegistry.get_instance()

```

--------------------------------

### Set Widget Minimum and Preferred Height with Options

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom_widget_dev_guide.md

Use the `getMinHeight` and `getHeight` options to define widget dimensions. This method improves performance by avoiding expensive DOM measurements.

```javascript
const widget = node.addDOMWidget("MyWidget", "custom", element, {
    // Specify minimum height in pixels
    getMinHeight: () => 150,
    
    // Or specify preferred height (pixels or percentage string)
    // getHeight: () => "50%", 
});
```

--------------------------------

### Recipe Handler Set Initialization

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

The RecipeHandlerSet is initialized with various services and managers, including SettingsManager, i18n, Jinja environment, RecipeScanner, RecipePersistenceService, RecipeAnalysisService, RecipeSharingService, and civitai_client.

```python
class RecipeHandlerSet:
    def __init__(
        self,
        settings_manager: SettingsManager,
        i18n: server_i18n.I18n,
        jinja_env: Environment,
        recipe_scanner: RecipeScanner,
        persistence_service: RecipePersistenceService,
        analysis_service: RecipeAnalysisService,
        sharing_service: RecipeSharingService,
        civitai_client: civitai_client.Client,
    ):
        self._settings_manager = settings_manager
        self._i18n = i18n
        self._jinja_env = jinja_env
        self._recipe_scanner = recipe_scanner
        self._persistence_service = persistence_service
        self._analysis_service = analysis_service
        self._sharing_service = sharing_service
        self._civitai_client = civitai_client

        # Register i18n filter exactly once per environment instance
        if not hasattr(self._jinja_env, "i18n_filter_registered"):
            self._jinja_env.filters["i18n"] = self._i18n.gettext
            self._jinja_env.i18n_filter_registered = True

    async def page_view(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def list_recipes(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def get_recipe_by_id(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def save_recipe(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def update_recipe(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def reconnect_recipe(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def delete_recipes(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def ingest_widget(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def share_recipe(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def download_recipe_share(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

    async def analyze_recipe(self, request: web.Request) -> web.Response:
        # ... implementation ...
        pass

```

--------------------------------

### Build Vue Widgets

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Builds the Vue widgets for production, outputting them to the web/comfyui/vue-widgets/ directory.

```bash
cd vue-widgets && npm run build
```

--------------------------------

### Mock Downloader Fixture

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Provides a configurable mock downloader for tests. It records download calls and can be set to simulate failures.

```python
import pytest

@pytest.fixture
def mock_downloader():
    """Provide a configurable mock downloader."""
    class MockDownloader:
        def __init__(self):
            self.download_calls = []
            self.should_fail = False
            
        async def download_file(self, url, target_path, **kwargs):
            self.download_calls.append({"url": url, "target_path": target_path})
            if self.should_fail:
                return False, "Download failed"
            return True, str(target_path)
    
    return MockDownloader()
```

--------------------------------

### Recipe Listing Handler

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles API requests for listing recipes, respecting pagination and search filters. It ensures every item includes a 'file_url' fallback and returns HTTP 404 for missing recipes.

```python
class RecipeListingHandler:
    def __init__(self, recipe_scanner: RecipeScanner):
        self._recipe_scanner = recipe_scanner

    async def list_recipes(self, request: web.Request) -> web.Response:
        # ... pagination and filtering logic ...
        paginated_data = await self._recipe_scanner.get_paginated_data(request.query)
        recipes = paginated_data.get('recipes', [])
        for recipe in recipes:
            if 'file_url' not in recipe:
                recipe['file_url'] = format_recipe_file_url(recipe.get('id')) # Example fallback
        return web.json_response({'recipes': recipes, 'total': paginated_data.get('total')})

    async def get_recipe_by_id(self, request: web.Request) -> web.Response:
        recipe_id = request.match_info.get('id')
        recipe = await self._recipe_scanner.get_recipe_by_id(recipe_id)
        if recipe is None:
            return web.HTTPNotFound()
        if 'file_url' not in recipe:
            recipe['file_url'] = format_recipe_file_url(recipe.get('id')) # Example fallback
        return web.json_response(recipe)

```

--------------------------------

### Run Vanilla JS Frontend Tests

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes only the vanilla JavaScript tests for the frontend.

```bash
npm run test:js
```

--------------------------------

### Render Full Template Fixture

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/frontend-dom-fixtures.md

Use `renderTemplate` to load a full HTML template file and mount it into the document body. This is useful for setting up the initial state for tests, mirroring production Django behavior.

```javascript
import { renderTemplate } from '../utils/domFixtures.js'; // adjust the relative path to your spec

beforeEach(() => {
  renderTemplate('loras.html', {
    dataset: { page: 'loras' }
  });
});
```

--------------------------------

### Refactor Download Manager Tests

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Compares a bad mocking approach to a good one that tests actual download logic with injected dependencies. Use this to refactor existing tests that mock methods under test.

```python
# BEFORE (Bad - mocks method under test)
async def fake_execute_download(self, **kwargs):
    return {"success": True}
monkeypatch.setattr(DownloadManager, "_execute_download", fake_execute_download)

# AFTER (Good - tests actual logic with injected dependencies)
async def test_download_executes_with_real_logic(
    tmp_path, mock_downloader, mock_websocket
):
    manager = DownloadManager(
        downloader=mock_downloader,
        ws_manager=mock_websocket
    )
    result = await manager._execute_download(urls=["http://test.com/file.safetensors"])
    assert result.success is True
    assert mock_downloader.download_calls == 1
```

--------------------------------

### Register Python Node in __init__.py

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/vue-widgets/README.md

Add your custom Python node class to the `NODE_CLASS_MAPPINGS` dictionary in your project's `__init__.py` file.

```python
from .py.nodes.your_node import YourCustomNode

NODE_CLASS_MAPPINGS = {
    # ...
    "YourCustomNode": YourCustomNode
}
```

--------------------------------

### Recipe Sharing Handler - Share

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles sharing recipes. Share responses provide a stable download URL and filename. Expired shares surface as HTTP 404.

```python
class RecipeSharingHandler:
    def __init__(self, sharing_service: RecipeSharingService):
        self._sharing_service = sharing_service

    async def share_recipe(self, request: web.Request) -> web.Response:
        recipe_id = await request.json() # Assume recipe ID is sent in request body
        share_info = await self._sharing_service.create_share(recipe_id)
        return web.json_response({
            'download_url': f'/loras/recipes/share/{share_info.token}',
            'filename': share_info.filename
        })

    async def download_recipe_share(self, request: web.Request) -> web.Response:
        token = request.match_info.get('token')
        share_data = await self._sharing_service.get_share_data(token)
        if share_data is None or share_data.is_expired():
            raise web.HTTPNotFound()
        # Stream the file using web.FileResponse
        return web.FileResponse(share_data.filepath, filename=share_data.filename, status=200)

```

--------------------------------

### Build Vue Widgets in Watch Mode

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Builds the Vue widgets in watch mode, recompiling automatically on file changes. Ideal for development.

```bash
npm run dev
```

--------------------------------

### Minimal Non-Civitai Configuration

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/metadata-json-schema.md

A minimal JSON configuration for non-Civitai models, specifying trained words.

```json
{
  "civitai": {
    "trainedWords": ["my_trigger_word"]
  }
}
```

--------------------------------

### Run Vue Widget Frontend Tests

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes only the Vue widget tests for the frontend.

```bash
npm run test:vue
```

--------------------------------

### Integration Test for Download Flow

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Tests the complete download process, from request to file saving and WebSocket progress updates. Requires a running test server and WebSocket manager.

```python
import pytest
import aiohttp

# Assuming ws_manager is a global or accessible object
# from your WebSocket management module

@pytest.mark.integration
@pytest.mark.asyncio
async def test_complete_download_flow(tmp_path, test_server):
    """
    Integration test covering:
    1. Route receives download request
    2. DownloadCoordinator schedules it
    3. DownloadManager executes actual download
    4. Downloader makes HTTP request (to test server)
    5. Progress is broadcast via WebSocket
    6. File is saved and cache updated
    """
    # Setup test server with known file
    test_file = tmp_path / "test_model.safetensors"
    test_file.write_bytes(b"fake model data")
    
    # Start download
    async with aiohttp.ClientSession() as session:
        response = await session.post(
            "http://localhost:8188/api/lm/download",
            json={"urls": [f"http://localhost:{test_server.port}/test_model.safetensors"]}
        )
        assert response.status == 200
        
    # Verify file downloaded
    downloaded = tmp_path / "downloads" / "test_model.safetensors"
    assert downloaded.exists()
    assert downloaded.read_bytes() == b"fake model data"
    
    # Verify WebSocket progress updates
    assert len(ws_manager.broadcasts) > 0
    assert any(b["status"] == "completed" for b in ws_manager.broadcasts)
```

--------------------------------

### Recipe Analysis Handler

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles analysis of uploaded, local, or remote recipes. Unsupported content types map to HTTP 400. Download errors are not retried. Every response includes a 'loras' array for client compatibility.

```python
class RecipeAnalysisHandler:
    def __init__(self,
                 analysis_service: RecipeAnalysisService,
                 recipe_scanner: RecipeScanner,
                 civitai_client: civitai_client.Client):
        self._analysis_service = analysis_service
        self._recipe_scanner = recipe_scanner
        self._civitai_client = civitai_client

    async def analyze_recipe(self, request: web.Request) -> web.Response:
        try:
            # Assume request contains file or URL for analysis
            analysis_result = await self._analysis_service.analyze(request)
            # Ensure 'loras' array is present
            if 'loras' not in analysis_result:
                analysis_result['loras'] = []
            return web.json_response(analysis_result)
        except UnsupportedContentTypeError as e:
            return web.json_response({'error': str(e)}, status=400)
        except RecipeDownloadError as e:
            # Log error, but do not retry
            return web.json_response({'error': 'Download failed: ' + str(e)}, status=500)
        except Exception as e:
            # Log the exception
            return web.HTTPInternalServerError()

```

--------------------------------

### Recipe Query Handler

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles requests for recipe statistics, syntax, and LoRA lookups. It reuses cache snapshots without forcing refreshes and collapses duplicate lookups by fingerprint. Returns helpful errors for absent LoRAs.

```python
class RecipeQueryHandler:
    def __init__(self, recipe_scanner_cache: RecipeScannerCache):
        self._cache = recipe_scanner_cache

    async def get_tag_stats(self, request: web.Request) -> web.Response:
        # ... logic to get tag statistics from cache ...
        pass

    async def get_syntax_lookup(self, request: web.Request) -> web.Response:
        # ... logic for syntax lookup, handling absent LoRAs ...
        pass

```

--------------------------------

### Run Python Backend Tests with Coverage

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Runs backend tests while generating a detailed coverage report. This helps identify untested code sections.

```bash
COVERAGE_FILE=coverage/backend/.coverage pytest \
  --cov=py --cov=standalone \
  --cov-report=term-missing \
  --cov-report=html:coverage/backend/html \
  --cov-report=xml:coverage/backend/coverage.xml
```

--------------------------------

### Priority Tag Entry Rules

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/Priority-Tags-Configuration-Guide

Demonstrates different formats for priority list entries, including canonical tags only and canonical tags with aliases.

```text
realistic
```

```text
character(char|chars)
```

--------------------------------

### Run Frontend Tests in Watch Mode

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Runs vanilla JavaScript frontend tests and automatically re-runs them when files change.

```bash
npm run test:watch
```

--------------------------------

### Run Backend Tests with Coverage

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Runs backend tests while collecting code coverage information. Generates reports in various formats.

```bash
COVERAGE_FILE=coverage/backend/.coverage pytest \
  --cov=py \
  --cov=standalone \
  --cov-report=term-missing \
  --cov-report=html:coverage/backend/html \
  --cov-report=xml:coverage/backend/coverage.xml \
  --cov-report=json:coverage/backend/coverage.json
```

--------------------------------

### Run Specific Backend Test File

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes tests within a specific Python file.

```bash
pytest tests/test_recipes.py
```

--------------------------------

### Run All Backend Tests

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes all backend tests using pytest.

```bash
pytest
```

--------------------------------

### Generate Frontend Coverage Report

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Generates a code coverage report for the frontend tests.

```bash
npm run test:coverage
```

--------------------------------

### Sample Data for Danbooru/E621 Merged CSV

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/reference/danbooru_e621_categories.md

This sample data illustrates the structure of the danbooru_e621_merged.csv file, showing tag names, category values, post counts, and aliases.

```csv
1girl,0,6008644,"1girls,sole_female"
highres,5,5256195,"high_res,high_resolution,hires"
solo,0,5000954,"alone,female_solo,single,solo_female"
long_hair,0,4350743,"/lh,longhair"
mammal,12,3437444,"cetancodont,cetancodontamorph,feralmammal"
anthro,7,3381927,"adult_anthro,anhtro,antho,anthro_horse"
 skirt,0,1557883,
```

--------------------------------

### Recipe Management Handler - Save

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles saving a new recipe. It uses RecipePersistenceService for persistence and ensures that fingerprint/index updates flow through the scanner before returning. Validation errors surface as HTTP 400 without touching disk.

```python
class RecipeManagementHandler:
    def __init__(self,
                 persistence_service: RecipePersistenceService,
                 recipe_scanner: RecipeScanner):
        self._persistence_service = persistence_service
        self._recipe_scanner = recipe_scanner

    async def save_recipe(self, request: web.Request) -> web.Response:
        data = await request.json()
        try:
            # Validate data first
            validated_data = self.validate_recipe_data(data) # Assume this method exists
            recipe_id = await self._persistence_service.save(validated_data)
            await self._recipe_scanner.update_index(recipe_id) # Update index after persistence
            return web.json_response({'id': recipe_id}, status=201)
        except RecipeValidationError as e:
            return web.json_response({'error': str(e)}, status=400)
        except Exception as e:
            # Log the exception
            return web.HTTPInternalServerError()

```

--------------------------------

### Handle Node Resizing with `onResize`

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom_widget_dev_guide.md

Implement the `onResize` callback in the widget options to receive notifications when the node's size changes. Use this to adjust the widget's internal DOM layout as needed.

```javascript
const widget = node.addDOMWidget("ResizingWidget", "custom", element, {
    onResize: (w) => {
        // 'w' is the widget instance
        // Adjust internal DOM layout here if necessary
        console.log("Widget resized");
    }
});
```

--------------------------------

### Recipe Routes Controller

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

The RecipeRoutes controller lazily resolves clients from the service registry, wires shared templates and i18n, and instantiates RecipeHandlerSet. It exposes a mapping of handler names to coroutines for the registrar.

```python
class RecipeRoutes:
    def __init__(self, app: web.Application):
        self._app = app
        self._handler_set = None

    def routes(self):
        return [
            web.get('/loras/recipes', self.list_recipes),
            web.get('/api/lm/recipes', self.list_recipes_api),
            web.get('/api/lm/recipe/{id}', self.get_recipe_by_id_api),
            web.post('/loras/recipes/save', self.save_recipe),
            web.post('/loras/recipes/update', self.update_recipe),
            web.post('/loras/recipes/reconnect', self.reconnect_recipe),
            web.post('/loras/recipes/delete', self.delete_recipes),
            web.post('/loras/recipes/ingest', self.ingest_widget),
            web.post('/loras/recipes/share', self.share_recipe),
            web.get('/loras/recipes/share/{token}', self.download_recipe_share),
            web.post('/loras/recipes/analysis', self.analyze_recipe),
        ]

    async def _get_handler_set(self) -> RecipeHandlerSet:
        if self._handler_set is None:
            self._handler_set = RecipeHandlerSet(
                self._app[SettingsManager.KEY],
                self._app[server_i18n.KEY],
                self._app.get_template_engine(),
                self._app[RecipeScanner.KEY],
                self._app[RecipePersistenceService.KEY],
                self._app[RecipeAnalysisService.KEY],
                self._app[RecipeSharingService.KEY],
                self._app[civitai_client.KEY],
            )
        return self._handler_set

    async def list_recipes(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.page_view(request)

    async def list_recipes_api(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.list_recipes(request)

    async def get_recipe_by_id_api(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.get_recipe_by_id(request)

    async def save_recipe(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.save_recipe(request)

    async def update_recipe(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.update_recipe(request)

    async def reconnect_recipe(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.reconnect_recipe(request)

    async def delete_recipes(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.delete_recipes(request)

    async def ingest_widget(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.ingest_widget(request)

    async def share_recipe(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.share_recipe(request)

    async def download_recipe_share(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.download_recipe_share(request)

    async def analyze_recipe(self, request: web.Request) -> web.Response:
        handler_set = await self._get_handler_set()
        return await handler_set.analyze_recipe(request)

```

--------------------------------

### Recipe Management Handler - Delete

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

Handles bulk deletion of recipes. Persistence results propagate HTTP status codes. Fingerprint/index updates flow through the scanner before returning.

```python
class RecipeManagementHandler:
    # ... (init method as above) ...

    async def delete_recipes(self, request: web.Request) -> web.Response:
        recipe_ids = await request.json()
        try:
            await self._persistence_service.delete_multiple(recipe_ids)
            await self._recipe_scanner.remove_from_index(recipe_ids)
            return web.json_response({'message': 'Recipes deleted successfully'})
        except Exception as e:
            # Log the exception
            return web.HTTPInternalServerError()

```

--------------------------------

### Integration Test for Recipe Flow

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Tests the process of analyzing a recipe from an image, extracting models, and saving/retrieving them from cache and database. This test is a placeholder and requires further implementation.

```python
# tests/integration/test_recipe_flow.py
@pytest.mark.integration
@pytest.mark.asyncio
async def test_recipe_analysis_and_save_flow(tmp_path):
    """
    Integration test covering:
    1. Import recipe from image
    2. Parse metadata and extract models
    3. Save to cache and database
    4. Retrieve and display
    """
```

--------------------------------

### Run Specific Backend Test Function

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Executes a particular test function within a Python file.

```bash
pytest tests/test_recipes.py::test_function_name
```

--------------------------------

### Python Recipe Enrichment Service

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/AGENTS.md

Shows the `RecipeEnrichmentService` responsible for adding details or context to recipes. This service likely works with parsed recipe data.

```python
class RecipeEnrichmentService:
    async def enrich(self, recipe_data: dict) -> dict:
        # Adds extra information to the recipe data
        pass
```

--------------------------------

### Mock WebSocket Manager Fixture

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Provides a recording WebSocket manager that captures all broadcast payloads for verification.

```python
import pytest

@pytest.fixture
def mock_websocket_manager():
    """Provide a recording WebSocket manager."""
    class RecordingWebSocketManager:
        def __init__(self):
            self.payloads = []
            
        async def broadcast(self, payload):
            self.payloads.append(payload)
            
    return RecordingWebSocketManager()
```

--------------------------------

### Sync Translation Keys

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Synchronizes translation keys after UI strings have been updated in the backend.

```bash
python scripts/sync_translation_keys.py
```

--------------------------------

### Implement Custom Serialization for DOM Widgets

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom_widget_dev_guide.md

Implement `getValue` and `setValue` in the widget options to enable persistence of internal DOM state. `getValue` returns the state, and `setValue` restores it. This is crucial for saving and loading workflow states.

```javascript
const inputEl = document.createElement("input");
const widget = node.addDOMWidget("MyInput", "custom", inputEl, {
    // 1. Called during Save
    getValue: () => {
        return inputEl.value;
    },
    // 2. Called during Load or Copy/Paste
    setValue: (value) => {
        inputEl.value = value || "";
    }
});

// Optional: Listen for changes to update widget.value immediately
inputEl.addEventListener("change", () => {
    widget.value = inputEl.value; // Triggers callbacks
});
```

--------------------------------

### Port Forwarding with socat for Remote Connection

Source: https://github.com/willmiao/comfyui-lora-manager/wiki/LoRA-Manager-Civitai-Extension-(Chrome-Extension)

Use this command to forward traffic from your local machine to a remote LoRA Manager instance, allowing the extension to connect to a remote IP address.

```bash
socat TCP-LISTEN:8188,bind=127.0.0.1,fork TCP:REMOTE.IP.ADDRESS.HERE:8188
```

--------------------------------

### Render Template Component Fixture

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/frontend-dom-fixtures.md

Load and render a specific template component partial. This is useful when a test only requires a fragment of markup, such as a progress panel or context menu.

```javascript
const container = renderTemplate('components/progress_panel.html');

const progressPanel = container.querySelector('#progress-panel');
```

--------------------------------

### Strengthened Assertions for String Matching and File State

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

Replaces loose string matching assertions with exact comparisons and adds assertions to verify file existence and retry history. Use these to ensure precise outcomes and state verification.

```python
# BEFORE
# assert "mismatch" in message.lower()

# AFTER
assert message == "File size mismatch. Expected: 1000 bytes, Got: 500 bytes"
assert not target_path.exists()
assert not Path(str(target_path) + ".part").exists()
assert len(downloader.retry_history) == 3
```

--------------------------------

### Avoid v-model for DOM Widgets

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom-widgets/value-persistence-best-practices.md

Illustrates the incorrect use of `v-model` for simple text inputs in DOM widgets, which can lead to synchronization issues. Recommends using `@input` and direct DOM manipulation instead.

```html
<!-- Wrong - creates sync issues -->
<textarea v-model="textValue" />

<!-- Right for simple text widgets -->
<textarea ref="textareaRef" @input="onInput" />
```

--------------------------------

### Recipe Route Registrar Binding

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/architecture/recipe_routes.md

This snippet illustrates how the RecipeRouteRegistrar binds routes to the aiohttp application, defining the HTTP endpoints for recipe-related functionalities.

```python
class RecipeRouteRegistrar:
    def __init__(self, app: web.Application):
        self._app = app

    def register_routes(self):
        recipe_routes = RecipeRoutes(self._app)
        self._app.add_routes(recipe_routes.routes())

```

--------------------------------

### Singleton Reset Fixture

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/testing/backend-testing-improvement-plan.md

An autouse fixture to reset various singletons (DownloadManager, ServiceRegistry, ModelScanner, SettingsManager) before each test to ensure isolation.

```python
import pytest
from some_module import DownloadManager, ServiceRegistry, ModelScanner, SettingsManager # Assuming these are the actual imports

@pytest.fixture(autouse=True)
def reset_singletons():
    """Reset all singletons before each test."""
    # Centralized singleton reset
    DownloadManager._instance = None
    ServiceRegistry.clear_services()
    ModelScanner._instances.clear()
    yield
    # Cleanup
    DownloadManager._instance = None
    ServiceRegistry.clear_services()
    ModelScanner._instances.clear()
```

--------------------------------

### Set Widget Height with CSS Variables

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/docs/dom_widget_dev_guide.md

Alternatively, set widget height using CSS variables directly on the root element.

```javascript
element.style.setProperty("--comfy-widget-min-height", "150px");
// or --comfy-widget-height
```

--------------------------------

### Typecheck Vue Widgets

Source: https://github.com/willmiao/comfyui-lora-manager/blob/main/CLAUDE.md

Performs static type checking on the Vue widget code.

```bash
cd vue-widgets && npm run typecheck
```
Tokens:
Raw