feat(ui): migrate Workflow Timer to shared controls

feat(ui): migrate Seed History to shared controls

.comfyignore

@@ -0,0 +1,28 @@
+# Files excluded from the Comfy Registry archive (gitignore syntax).
+# Everything here is development-only; the published node needs
+# __init__.py, kikotools/, web/, examples/, README, LICENSE, pyproject.toml.
+
+# Test suite and tooling
+tests/
+scripts/
+.github/
+Makefile
+pytest.ini
+mypy.ini
+.flake8
+.pre-commit-config.yaml
+.secrets.baseline
+requirements-dev.txt
+
+# Reference / scratch code not imported by the node
+example.py
+
+# Agent and contributor docs
+CLAUDE.md
+CONTRIBUTING.md
+CODE_OF_CONDUCT.md
+
+tools/
+coverage/
+TESTING.md
+AGENTS.md

.flake8

@@ -1,7 +1,8 @@
 [flake8]
 max-line-length = 127
 max-complexity = 10
-exclude = 
+exclude =
+    node_modules,
     .git,
     __pycache__,
     .mypy_cache,
@@ -11,8 +12,9 @@ exclude =
     build,
     dist,
     *.egg-info,
-    .tox
-ignore = 
+    .tox,
+    referance
+ignore =
     # W503: line break before binary operator (conflicts with Black)
     W503,
     # E203: whitespace before ':' (conflicts with Black)
@@ -32,4 +34,4 @@ per-file-ignores =
 
 # Statistics
 count = True
-statistics = True
+statistics = True

.gitattributes

@@ -38,4 +38,4 @@
 *.safetensors binary
 *.ckpt binary
 *.pt binary
-*.pth binary
+*.pth binary

.github/branch-protection.json

@@ -0,0 +1,16 @@
+{
+  "required_status_checks": {
+    "strict": true,
+    "contexts": [
+      "py3.10 on ubuntu-latest", "py3.11 on ubuntu-latest", "py3.12 on ubuntu-latest", "py3.13 on ubuntu-latest",
+      "py3.10 on windows-latest", "py3.11 on windows-latest", "py3.12 on windows-latest", "py3.13 on windows-latest",
+      "py3.10 on macos-latest", "py3.11 on macos-latest", "py3.12 on macos-latest", "py3.13 on macos-latest",
+      "coverage gate (85%)", "frontend syntax", "frontend workflows and coverage", "code-quality"
+    ]
+  },
+  "enforce_admins": true,
+  "required_pull_request_reviews": null,
+  "restrictions": null,
+  "allow_force_pushes": false,
+  "allow_deletions": false
+}

.github/dependabot.yml

@@ -7,4 +7,8 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "weekly"
+  - package-ecosystem: "npm"
+    directory: "/tools/testing"
+    schedule:
+      interval: "weekly"

.github/workflows/code-quality.yml

@@ -13,15 +13,15 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v7
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v7
       with:
         python-version: '3.10'
 
     - name: Cache pip dependencies
-      uses: actions/cache@v4
+      uses: actions/cache@v6
       with:
         path: ~/.cache/pip
         key: ${{ runner.os }}-pip-quality-${{ hashFiles('**/requirements-dev.txt') }}
@@ -31,6 +31,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        pip install torch --index-url https://download.pytorch.org/whl/cpu
         pip install -r requirements-dev.txt
 
     - name: Format check with Black
@@ -93,6 +94,14 @@ jobs:
         from kikotools.tools.kiko_save_image import KikoSaveImageNode
         from kikotools.tools.kiko_save_image.logic import process_image_batch, validate_save_inputs
 
+        # Test Model Downloader imports
+        from kikotools.tools.model_downloader import ModelDownloaderNode
+        from kikotools.tools.model_downloader.detector import URLDetector, DownloaderType
+        from kikotools.tools.model_downloader.base import BaseDownloader
+
+        # Test Text Input imports
+        from kikotools.tools.text_input import TextInputNode
+
         print('✓ All module imports successful')
         "
 
@@ -133,10 +142,10 @@ jobs:
   security:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v7
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v7
       with:
         python-version: '3.10'
 
@@ -164,16 +173,17 @@ jobs:
   architecture:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v7
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v7
       with:
         python-version: '3.10'
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        pip install torch --index-url https://download.pytorch.org/whl/cpu
         pip install -r requirements-dev.txt
 
     - name: Check architecture compliance
@@ -279,6 +289,41 @@ jobs:
             print('❌ KikoSaveImageNode missing OUTPUT_NODE = True')
             sys.exit(1)
 
+        # Test Model Downloader Node
+        from kikotools.tools.model_downloader.node import ModelDownloaderNode
+
+        if issubclass(ModelDownloaderNode, ComfyAssetsBaseNode):
+            print('✓ ModelDownloaderNode properly inherits from base class')
+        else:
+            print('❌ ModelDownloaderNode does not inherit from base class')
+            sys.exit(1)
+
+        # ModelDownloader is an output node, so it doesn't have RETURN_TYPES/RETURN_NAMES
+        download_required_attrs = ['INPUT_TYPES', 'FUNCTION', 'CATEGORY']
+        for attr in download_required_attrs:
+            if not hasattr(ModelDownloaderNode, attr):
+                print(f'❌ ModelDownloaderNode missing required attribute: {attr}')
+                sys.exit(1)
+
+        # Check that it's properly marked as an output node
+        if not hasattr(ModelDownloaderNode, 'OUTPUT_NODE') or not ModelDownloaderNode.OUTPUT_NODE:
+            print('❌ ModelDownloaderNode missing OUTPUT_NODE = True')
+            sys.exit(1)
+
+        # Test Text Input Node
+        from kikotools.tools.text_input.node import TextInputNode
+
+        if issubclass(TextInputNode, ComfyAssetsBaseNode):
+            print('✓ TextInputNode properly inherits from base class')
+        else:
+            print('❌ TextInputNode does not inherit from base class')
+            sys.exit(1)
+
+        for attr in required_attrs:
+            if not hasattr(TextInputNode, attr):
+                print(f'❌ TextInputNode missing required attribute: {attr}')
+                sys.exit(1)
+
         print('✓ All architecture checks passed for all tools')
         "
 

.github/workflows/publish.yml

@@ -18,7 +18,7 @@ jobs:
     if: ${{ github.repository_owner == 'ComfyAssets' }}
     steps:
       - name: Check out code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v7
         with:
           submodules: true
       - name: Publish Custom Node

.github/workflows/release.yml

@@ -10,55 +10,28 @@ on:
 
 jobs:
   create-release:
+    outputs:
+      version: ${{ steps.get_version.outputs.version }}
     runs-on: ubuntu-latest
     permissions:
       contents: write
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v7
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v7
       with:
         python-version: '3.10'
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        pip install torch --index-url https://download.pytorch.org/whl/cpu
         pip install -r requirements-dev.txt
 
-    - name: Run full test suite
-      run: |
-        python -c "
-        import sys
-        import os
-        sys.path.insert(0, os.getcwd())
-
-        # Run comprehensive tests before release
-        from kikotools.base import ComfyAssetsBaseNode
-        from kikotools.tools.resolution_calculator.logic import extract_dimensions, calculate_scaled_dimensions
-        from kikotools.tools.resolution_calculator.node import ResolutionCalculatorNode
-        import torch
-
-        print('Running pre-release validation...')
-
-        # Test all major functionality
-        node = ResolutionCalculatorNode()
-
-        # Test various scenarios
-        test_cases = [
-            (torch.randn(1, 512, 512, 3), 2.0),
-            (torch.randn(1, 1024, 1024, 3), 1.5),
-            (torch.randn(1, 1216, 832, 3), 1.53),  # User scenario
-        ]
-
-        for i, (image, scale) in enumerate(test_cases):
-            width, height = node.calculate_resolution(scale, image=image)
-            print(f'✓ Test case {i+1}: {image.shape[2]}×{image.shape[1]} → {width}×{height} (scale: {scale})')
-            assert width % 8 == 0 and height % 8 == 0
-
-        print('🎉 All pre-release tests passed!')
-        "
+    - name: Run full test suite and coverage gate
+      run: python -m pytest tests --cov=kikotools --cov-report=term-missing
 
     - name: Extract version from tag
       id: get_version
@@ -100,7 +73,7 @@ jobs:
         ### 📊 Technical Details
 
         - **Nodes**: 1 (Resolution Calculator)
-        - **Test Coverage**: 100%
+        - **Python Coverage Gate**: 85% combined statement/branch coverage
         - **Python Support**: 3.8+
         - **ComfyUI Compatibility**: Latest
 
@@ -114,7 +87,7 @@ jobs:
         EOF
 
     - name: Create GitHub Release
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       with:
         tag_name: ${{ steps.get_version.outputs.version }}
         name: ComfyUI-KikoTools ${{ steps.get_version.outputs.version }}
@@ -147,4 +120,4 @@ jobs:
         echo "- Resolution Calculator tool"
         echo "- Complete documentation"
         echo "- Example workflows"
-        echo "- 100% test coverage"
+        echo "- Enforced Python coverage and frontend regression checks"

.github/workflows/tests.yml

@@ -11,471 +11,135 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    name: py${{ matrix.python-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v7
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: requirements-dev.txt
 
-      - name: Cache pip dependencies
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-dev.txt') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
+      # The default Linux torch wheel bundles CUDA (~2.5 GB); tests only need CPU.
+      # Windows and macOS default wheels are already CPU-only.
+      - name: Install CPU torch (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
 
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install -r requirements-dev.txt
 
-      - name: Run core functionality tests
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
+      - name: Run tests
+        run: python -m pytest tests --junitxml=test-results/pytest.xml
 
-          # Test imports
-          from kikotools.base import ComfyAssetsBaseNode
-          from kikotools.tools.resolution_calculator.logic import extract_dimensions, calculate_scaled_dimensions
-          from kikotools.tools.resolution_calculator.node import ResolutionCalculatorNode
-          import torch
-
-          print('✓ All imports successful')
-
-          # Test base node
-          assert 'ComfyAssets' in ComfyAssetsBaseNode.CATEGORY
-          print('✓ Base node tests passed')
-
-          # Test dimension extraction
-          mock_image = torch.randn(1, 1216, 832, 3)
-          width, height = extract_dimensions(image=mock_image)
-          assert width == 832 and height == 1216
-          print('✓ Dimension extraction tests passed')
-
-          # Test scaling
-          new_width, new_height = calculate_scaled_dimensions(832, 1216, 1.5)
-          assert new_width % 8 == 0 and new_height % 8 == 0
-          print('✓ Scaling tests passed')
-
-          # Test node interface
-          node = ResolutionCalculatorNode()
-          result_width, result_height = node.calculate_resolution(1.5, image=mock_image)
-          assert isinstance(result_width, int) and isinstance(result_height, int)
-          assert result_width % 8 == 0 and result_height % 8 == 0
-          print('✓ Node interface tests passed')
-
-          # Test user scenario
-          width, height = node.calculate_resolution(1.53, image=mock_image)
-          print(f'✓ User scenario test: 832×1216 → {width}×{height} (1.53x scale)')
-
-          print('🎉 All tests passed!')
-          "
-
-      - name: Test Width Height Selector
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
-
-          # Test Width Height Selector imports
-          from kikotools.tools.width_height_selector.node import WidthHeightSelectorNode
-          from kikotools.tools.width_height_selector.presets import PRESET_OPTIONS, PRESET_METADATA
-          from kikotools.tools.width_height_selector.logic import get_preset_dimensions
-
-          print('✓ Width Height Selector imports successful')
-
-          # Test preset structure
-          assert len(PRESET_OPTIONS) > 0
-          assert 'custom' in PRESET_OPTIONS
-          assert len(PRESET_METADATA) > 0
-          print('✓ Preset structure tests passed')
-
-          # Test node interface
-          node = WidthHeightSelectorNode()
-          input_types = node.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'preset' in input_types['required']
-          assert 'width' in input_types['required']
-          assert 'height' in input_types['required']
-          print('✓ Node interface tests passed')
-
-          # Test formatted presets
-          preset_options = input_types['required']['preset'][0]
-          assert 'custom' in preset_options
-          formatted_count = len([opt for opt in preset_options if ' - ' in opt and 'MP' in opt])
-          assert formatted_count > 0
-          print(f'✓ Found {formatted_count} formatted presets')
-
-          # Test dimension calculation
-          result = node.get_dimensions('1024×1024', 512, 512)
-          assert result == (1024, 1024)
-          print('✓ Dimension calculation tests passed')
-
-          # Test formatted preset dimensions
-          formatted_preset = '1024×1024 - 1:1 (1.1MP) - SDXL'
-          result = node.get_dimensions(formatted_preset, 512, 512)
-          assert result == (1024, 1024)
-          print('✓ Formatted preset tests passed')
-
-          # Test preset extraction
-          extracted = node._extract_preset_name(formatted_preset)
-          assert extracted == '1024×1024'
-          print('✓ Preset extraction tests passed')
-
-          print('🎉 All Width Height Selector tests passed!')
-          "
-
-      - name: Test Sampler Combo
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
-
-          # Test Sampler Combo imports
-          from kikotools.tools.sampler_combo.node import SamplerComboNode
-          from kikotools.tools.sampler_combo.logic import (
-              get_sampler_combo, validate_sampler_settings, SAMPLERS, SCHEDULERS
-          )
-
-          print('✓ Sampler Combo imports successful')
-
-          # Test node interface
-          node = SamplerComboNode()
-          input_types = node.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'sampler_name' in input_types['required']
-          assert 'scheduler' in input_types['required']
-          assert 'steps' in input_types['required']
-          assert 'cfg' in input_types['required']
-          print('✓ Sampler Combo interface tests passed')
-
-          # Test return types
-          # RETURN_TYPES[1] is the actual SCHEDULERS list
-          assert node.RETURN_TYPES[0] == 'SAMPLER'
-          assert isinstance(node.RETURN_TYPES[1], list)  # SCHEDULERS is a list
-          assert node.RETURN_TYPES[2] == 'INT'
-          assert node.RETURN_TYPES[3] == 'FLOAT'
-          assert node.RETURN_NAMES == ('sampler_name', 'scheduler', 'steps', 'cfg')
-          assert node.CATEGORY == '🫶 ComfyAssets/🌀 Samplers'
-          print('✓ Sampler Combo return types tests passed')
-
-          # Test sampler combo functionality
-          result = node.get_sampler_combo('euler', 'normal', 20, 7.0)
-          assert result == ('euler', 'normal', 20, 7.0)
-          print('✓ Sampler combo functionality tests passed')
-
-          # Test validation
-          assert validate_sampler_settings('euler', 'normal', 20, 7.0) == True
-          print('✓ Sampler validation tests passed')
-
-          # Test available samplers and schedulers
-          samplers = node.get_available_samplers()
-          schedulers = node.get_available_schedulers()
-          assert len(samplers) > 0
-          assert len(schedulers) > 0
-          assert 'euler' in samplers
-          assert 'normal' in schedulers
-          print(f'✓ Found {len(samplers)} samplers and {len(schedulers)} schedulers')
-
-          print('🎉 All Sampler Combo tests passed!')
-          "
-
-      - name: Test Seed History
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
-
-          # Test Seed History imports
-          from kikotools.tools.seed_history.node import SeedHistoryNode
-          from kikotools.tools.seed_history.logic import (
-              generate_random_seed, validate_seed_value, sanitize_seed_value
-          )
-
-          print('✓ Seed History imports successful')
-
-          # Test node interface
-          node = SeedHistoryNode()
-          input_types = node.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'seed' in input_types['required']
-          print('✓ Seed History interface tests passed')
-
-          # Test return types
-          assert node.RETURN_TYPES == ('INT',)
-          assert node.RETURN_NAMES == ('seed',)
-          assert node.CATEGORY == '🫶 ComfyAssets/🌱 Seeds'
-          print('✓ Seed History return types tests passed')
-
-          # Test seed output functionality
-          result = node.output_seed(12345)
-          assert result == (12345,)
-          print('✓ Seed output functionality tests passed')
-
-          # Test seed validation
-          assert validate_seed_value(12345) == True
-          assert validate_seed_value(-1) == False
-          print('✓ Seed validation tests passed')
-
-          # Test seed generation
-          new_seed = generate_random_seed()
-          assert isinstance(new_seed, int)
-          assert validate_seed_value(new_seed) == True
-          print('✓ Seed generation tests passed')
-
-          # Test seed sanitization
-          clean_seed = sanitize_seed_value(12345)
-          assert clean_seed == 12345
-          print('✓ Seed sanitization tests passed')
-
-          # Test node helper methods
-          assert node.is_seed_in_range(12345) == True
-          assert node.is_seed_in_range(-1) == False
-          assert node.get_default_seed() == 12345
-          print('✓ Seed helper methods tests passed')
-
-          print('🎉 All Seed History tests passed!')
-          "
-
-      - name: Test error handling for all tools
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
-
-          print('=== Testing Error Handling for All Tools ===')
-
-          # Test Resolution Calculator error handling
-          from kikotools.tools.resolution_calculator.node import ResolutionCalculatorNode
-          res_node = ResolutionCalculatorNode()
-
-          try:
-              res_node.calculate_resolution(2.0)  # No input provided
-              assert False, 'Should have raised ValueError'
-          except ValueError:
-              print('✓ Resolution Calculator error handling test passed')
-
-          try:
-              res_node.calculate_resolution(0.0)  # Invalid scale
-              assert False, 'Should have raised ValueError'
-          except ValueError:
-              print('✓ Resolution Calculator scale factor validation test passed')
-
-          # Test Width Height Selector error handling
-          from kikotools.tools.width_height_selector.node import WidthHeightSelectorNode
-          wh_node = WidthHeightSelectorNode()
-
-          # Test invalid preset fallback
-          result = wh_node.get_dimensions('invalid_preset', 800, 600)
-          assert result == (800, 600)  # Should fallback to custom dimensions
-          print('✓ Width Height Selector invalid preset handling test passed')
-
-          # Test Sampler Combo error handling
-          from kikotools.tools.sampler_combo.node import SamplerComboNode
-          sampler_node = SamplerComboNode()
-
-          # Test with invalid sampler (should use safe defaults)
-          result = sampler_node.get_sampler_combo('invalid_sampler', 'normal', 20, 7.0)
-          assert result == ('euler', 'normal', 20, 7.0)  # Safe defaults
-          print('✓ Sampler Combo invalid input handling test passed')
-
-          # Test Seed History error handling
-          from kikotools.tools.seed_history.node import SeedHistoryNode
-          seed_node = SeedHistoryNode()
-
-          # Test invalid seed value (should use fallback)
-          result = seed_node.output_seed(-1)  # Invalid negative seed
-          assert result == (12345,)  # Fallback seed
-          print('✓ Seed History invalid seed handling test passed')
-
-          print('🎉 All error handling tests passed for all tools!')
-          "
-
-      - name: Test ComfyUI integration readiness for all tools
-        run: |
-          python -c "
-          import sys
-          import os
-          sys.path.insert(0, os.getcwd())
-
-          print('=== Testing ComfyUI Integration for All Tools ===')
-
-          # Test Resolution Calculator
-          from kikotools.tools.resolution_calculator.node import ResolutionCalculatorNode
-          res_class = ResolutionCalculatorNode
-
-          assert hasattr(res_class, 'INPUT_TYPES')
-          assert hasattr(res_class, 'RETURN_TYPES')
-          assert hasattr(res_class, 'RETURN_NAMES')
-          assert hasattr(res_class, 'FUNCTION')
-          assert hasattr(res_class, 'CATEGORY')
-
-          input_types = res_class.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'optional' in input_types
-          assert 'scale_factor' in input_types['required']
-          assert 'image' in input_types['optional']
-          assert 'latent' in input_types['optional']
-
-          assert res_class.RETURN_TYPES == ('INT', 'INT')
-          assert res_class.RETURN_NAMES == ('width', 'height')
-          assert 'ComfyAssets/' in res_class.CATEGORY
-          print('✓ Resolution Calculator ComfyUI integration passed')
-
-          # Test Width Height Selector
-          from kikotools.tools.width_height_selector.node import WidthHeightSelectorNode
-          wh_class = WidthHeightSelectorNode
-
-          assert hasattr(wh_class, 'INPUT_TYPES')
-          assert hasattr(wh_class, 'RETURN_TYPES')
-          assert hasattr(wh_class, 'RETURN_NAMES')
-          assert hasattr(wh_class, 'FUNCTION')
-          assert hasattr(wh_class, 'CATEGORY')
-
-          input_types = wh_class.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'preset' in input_types['required']
-          assert 'width' in input_types['required']
-          assert 'height' in input_types['required']
-
-          assert wh_class.RETURN_TYPES == ('INT', 'INT')
-          assert wh_class.RETURN_NAMES == ('width', 'height')
-          assert 'ComfyAssets/' in wh_class.CATEGORY
-          print('✓ Width Height Selector ComfyUI integration passed')
-
-          # Test Sampler Combo
-          from kikotools.tools.sampler_combo.node import SamplerComboNode
-          sampler_class = SamplerComboNode
-
-          assert hasattr(sampler_class, 'INPUT_TYPES')
-          assert hasattr(sampler_class, 'RETURN_TYPES')
-          assert hasattr(sampler_class, 'RETURN_NAMES')
-          assert hasattr(sampler_class, 'FUNCTION')
-          assert hasattr(sampler_class, 'CATEGORY')
-
-          input_types = sampler_class.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'sampler_name' in input_types['required']
-          assert 'scheduler' in input_types['required']
-          assert 'steps' in input_types['required']
-          assert 'cfg' in input_types['required']
-
-          assert 'ComfyAssets/' in sampler_class.CATEGORY
-          print('✓ Sampler Combo ComfyUI integration passed')
-
-          # Test Seed History
-          from kikotools.tools.seed_history.node import SeedHistoryNode
-          seed_class = SeedHistoryNode
-
-          assert hasattr(seed_class, 'INPUT_TYPES')
-          assert hasattr(seed_class, 'RETURN_TYPES')
-          assert hasattr(seed_class, 'RETURN_NAMES')
-          assert hasattr(seed_class, 'FUNCTION')
-          assert hasattr(seed_class, 'CATEGORY')
-
-          input_types = seed_class.INPUT_TYPES()
-          assert 'required' in input_types
-          assert 'seed' in input_types['required']
-
-          assert seed_class.RETURN_TYPES == ('INT',)
-          assert seed_class.RETURN_NAMES == ('seed',)
-          assert 'ComfyAssets/' in seed_class.CATEGORY
-          print('✓ Seed History ComfyUI integration passed')
-
-          print('🎉 All tools ComfyUI integration readiness tests passed!')
-          "
-
-  test-package-structure:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Set up Python 3.10
-        uses: actions/setup-python@v6
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v7
         with:
-          python-version: "3.10"
+          name: python-${{ matrix.os }}-${{ matrix.python-version }}
+          path: test-results/
+          if-no-files-found: ignore
+          retention-days: 14
 
-      - name: Test package structure
-        run: |
-          # Check required files exist
-          test -f README.md || (echo "README.md missing" && exit 1)
-          test -f LICENSE || (echo "LICENSE missing" && exit 1)
-          test -f requirements-dev.txt || (echo "requirements-dev.txt missing" && exit 1)
-
-          # Check directory structure
-          test -d kikotools || (echo "kikotools directory missing" && exit 1)
-          test -d kikotools/base || (echo "kikotools/base directory missing" && exit 1)
-          test -d kikotools/tools || (echo "kikotools/tools directory missing" && exit 1)
-          test -d kikotools/tools/resolution_calculator || (echo "resolution_calculator directory missing" && exit 1)
-          test -d kikotools/tools/width_height_selector || (echo "width_height_selector directory missing" && exit 1)
-          test -d kikotools/tools/sampler_combo || (echo "sampler_combo directory missing" && exit 1)
-          test -d kikotools/tools/seed_history || (echo "seed_history directory missing" && exit 1)
-          test -d tests || (echo "tests directory missing" && exit 1)
-          test -d examples || (echo "examples directory missing" && exit 1)
-          test -d web || (echo "web directory missing" && exit 1)
-
-          # Check key files
-          test -f kikotools/__init__.py || (echo "kikotools/__init__.py missing" && exit 1)
-          test -f kikotools/base/base_node.py || (echo "base_node.py missing" && exit 1)
-
-          # Resolution Calculator files
-          test -f kikotools/tools/resolution_calculator/node.py || (echo "resolution_calculator node.py missing" && exit 1)
-          test -f kikotools/tools/resolution_calculator/logic.py || (echo "resolution_calculator logic.py missing" && exit 1)
-
-          # Width Height Selector files
-          test -f kikotools/tools/width_height_selector/node.py || (echo "width_height_selector node.py missing" && exit 1)
-          test -f kikotools/tools/width_height_selector/logic.py || (echo "width_height_selector logic.py missing" && exit 1)
-          test -f kikotools/tools/width_height_selector/presets.py || (echo "width_height_selector presets.py missing" && exit 1)
-
-          # Sampler Combo files
-          test -f kikotools/tools/sampler_combo/node.py || (echo "sampler_combo node.py missing" && exit 1)
-          test -f kikotools/tools/sampler_combo/logic.py || (echo "sampler_combo logic.py missing" && exit 1)
-
-          # Seed History files
-          test -f kikotools/tools/seed_history/node.py || (echo "seed_history node.py missing" && exit 1)
-          test -f kikotools/tools/seed_history/logic.py || (echo "seed_history logic.py missing" && exit 1)
-
-          # Web files
-          test -f web/width_height_swap.js || (echo "width_height_swap.js missing" && exit 1)
-          test -f web/seed_history_ui.js || (echo "seed_history_ui.js missing" && exit 1)
-
-          echo "✓ Package structure tests passed"
-
-  test-documentation:
+  coverage:
+    name: coverage gate (85%)
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v7
 
-      - name: Test documentation completeness
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: requirements-dev.txt
+
+      - name: Install dependencies
         run: |
-          # Check documentation files for all tools
-          test -f examples/documentation/resolution_calculator.md || (echo "Resolution calculator docs missing" && exit 1)
-          test -f examples/workflows/resolution_calculator_example.json || (echo "Resolution calculator workflow missing" && exit 1)
-          test -f examples/documentation/width_height_selector.md || (echo "Width height selector docs missing" && exit 1)
-          test -f examples/workflows/width_height_selector_example.json || (echo "Width height selector workflow missing" && exit 1)
-          test -f examples/documentation/sampler_combo.md || (echo "Sampler combo docs missing" && exit 1)
-          test -f examples/workflows/sampler_combo_example.json || (echo "Sampler combo workflow missing" && exit 1)
-          test -f examples/documentation/seed_history.md || (echo "Seed history docs missing" && exit 1)
-          test -f examples/workflows/seed_history_example.json || (echo "Seed history workflow missing" && exit 1)
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install -r requirements-dev.txt
 
-          # Check README has key sections
-          grep -q "Installation" README.md || (echo "README missing Installation section" && exit 1)
-          grep -q "Quick Start" README.md || (echo "README missing Quick Start section" && exit 1)
-          grep -q "Development" README.md || (echo "README missing Development section" && exit 1)
-          grep -q "Contributing" README.md || (echo "README missing Contributing section" && exit 1)
+      # fail_under = 85 lives in pyproject.toml [tool.coverage.report]
+      - name: Measure coverage
+        run: python -m pytest tests --cov=kikotools --cov-report=term-missing --cov-report=html --cov-report=xml
 
-          echo "✓ Documentation tests passed"
+      - name: Upload coverage reports
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: python-coverage
+          path: |
+            htmlcov/
+            coverage.xml
+          if-no-files-found: ignore
+          retention-days: 14
+
+  js-check:
+    name: frontend syntax
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version: "24"
+
+      # Check every shipped module, including files without behavioral tests.
+      - name: Check all shipped JavaScript modules parse
+        run: |
+          shopt -s globstar nullglob
+          for f in web/**/*.js web/**/*.mjs; do
+            node --input-type=module --check < "$f" || { echo "Syntax error in $f"; exit 1; }
+          done
+
+  frontend:
+    name: frontend workflows and coverage
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: requirements-dev.txt
+      - name: Install Python test dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install -r requirements-dev.txt
+      - uses: actions/setup-node@v7
+        with:
+          node-version: "24"
+          cache: npm
+          cache-dependency-path: tools/testing/package-lock.json
+      - run: npm ci --prefix tools/testing --ignore-scripts
+      - run: npx --prefix tools/testing playwright install --with-deps chromium firefox webkit
+      - name: JavaScript regressions, Chromium workflows, and coverage gate
+        run: npm run --prefix tools/testing test:coverage
+      - name: Firefox and WebKit workflows
+        run: npm run --prefix tools/testing test:browser -- --project firefox --project webkit
+      - name: Upload frontend reports
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: frontend-test-reports
+          path: |
+            tools/testing/test-results/
+            coverage/js/
+            !coverage/js/raw/
+          if-no-files-found: ignore
+          retention-days: 14

.gitignore

@@ -159,7 +159,19 @@ test_images/
 test_outputs/
 experiments/
 .claude/
+.serena
 
 # Gemini model cache
 .gemini_models_cache.json
 referance/
+
+# Runtime state written inside the package (repo is symlinked into custom_nodes)
+kikotools/tools/local_image_loader/config.json
+kikotools/tools/local_image_loader/selections.json
+gemini_config.json
+
+# Frontend test tooling and reports
+node_modules/
+coverage/
+playwright-report/
+test-results/

.pre-commit-config.yaml

@@ -4,10 +4,9 @@
 repos:
   # Python code formatting with Black
   - repo: https://github.com/psf/black
-    rev: 25.1.0
+    rev: 26.10.1
     hooks:
       - id: black
-        language_version: python3.10
         args: ['--line-length=88']  # Match CI configuration
 
   # Python linting with flake8
@@ -61,9 +60,27 @@ repos:
         args: ['--baseline', '.secrets.baseline']
         exclude: '^(tests/|\.git/)'
 
+  - repo: local
+    hooks:
+      - id: python-regressions
+        name: Python regression suite
+        entry: python -m pytest tests
+        language: system
+        pass_filenames: false
+        always_run: true
+        stages: [pre-push]
+      - id: frontend-regressions
+        name: JavaScript regression suite
+        entry: npm test --prefix tools/testing
+        language: system
+        pass_filenames: false
+        always_run: true
+        stages: [pre-push]
+
 # Configuration for specific hooks
+default_stages: [pre-commit]
 default_language_version:
-  python: python3.10
+  python: python3
 
 # Run hooks on all files by default
 fail_fast: false
@@ -81,4 +98,4 @@ exclude: |
     .*\.egg-info/|
     venv/|
     env/
-  )
+  )

AGENTS.md

@@ -0,0 +1,46 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+
+`kikotools/tools/<tool>/logic.py` contains reusable logic; `node.py` defines the
+ComfyUI node. Shared classes live in `kikotools/base/`. Register nodes in
+`kikotools/__init__.py`; the root `__init__.py` exposes the plugin and API routes.
+`web/` contains browser extensions. Tests live in `tests/unit/`, `tests/js/`, and
+`tests/browser/`. Examples are in `examples/`.
+
+## Development Commands
+
+Install Python dependencies with `python -m pip install -r requirements-dev.txt`.
+Run `python -m pytest tests` or `make test` for the complete Python suite.
+Use `python -m pytest tests --cov=kikotools` for the 85% statement/branch gate.
+Format with `black .`; use `flake8 .` for lint findings.
+
+Frontend tooling needs Node.js 24 and `npm ci --prefix tools/testing
+--ignore-scripts`. Run `npm test --prefix tools/testing` for JavaScript tests,
+`npm run --prefix tools/testing test:coverage` for coverage and Chromium workflows,
+and `npm run --prefix tools/testing test:browser` for all browser projects.
+See `TESTING.md` for browser installation, environment overrides, and artifacts.
+
+## Coding Style & Naming
+
+Use four-space Python indentation and Black's 88-character formatting.
+Use `snake_case` for Python functions/modules, `PascalCase` for classes, and
+`UPPER_CASE` for constants. Keep node interfaces separate from logic. Preserve
+existing ComfyUI lifecycle hooks when extending widgets and clean up timers,
+listeners, and observers when nodes are removed.
+
+## Testing Guidelines
+
+Write regression tests first and verify failure before implementing fixes.
+Name Python tests `test_*.py` and JavaScript tests `*.test.mjs`; put browser
+workflows in `tests/browser/*.spec.mjs`. Test behavior and persistence, including
+failure recovery. Keep fixtures disposable and external services mocked.
+Never lower coverage floors to make a change pass.
+
+## Commits & Pull Requests
+
+Use Conventional Commits, such as `fix(local_image_loader): preserve error
+status`. Link the tracked issue, describe observable behavior, and report the
+commands and results used for validation. Include screenshots for visual changes.
+Required checks must pass before merging. Keep credentials and runtime files out
+of commits; restart ComfyUI after installing Python changes.

CONTRIBUTING.md

@@ -357,9 +357,12 @@ Brief description of changes.
 
 ### Review Process
 
+See [TESTING.md](TESTING.md) for automated suites, coverage gates, required merge
+checks, and the remaining ComfyUI/GPU/service boundaries.
+
 1. **Automated Checks**: CI runs tests and quality checks
 2. **Code Review**: Maintainer reviews code and provides feedback
-3. **Testing**: Manual testing in ComfyUI environment
+3. **Testing**: Run relevant automated suites; use live ComfyUI checks for host, GPU, service, or visual changes
 4. **Merge**: After approval, changes are merged to main
 
 ## 🎨 Code Style Guidelines

Makefile

@@ -1,6 +1,6 @@
 # ComfyUI-KikoTools Development Makefile
 
-.PHONY: help install test test-fast lint format type-check quality-check clean setup dev-test release-test
+.PHONY: coverage frontend-test browser-test frontend-coverage help install test test-fast lint format type-check quality-check clean setup dev-test release-test
 
 # Python and virtual environment setup
 PYTHON := python3
@@ -34,7 +34,11 @@ help:
 	@echo "  quality-check  - Run all quality checks"
 	@echo ""
 	@echo "Testing:"
-	@echo "  test           - Run comprehensive tests"
+	@echo "  test           - Run the complete pytest suite"
+	@echo "  coverage       - Python statement/branch coverage (85% gate)"
+	@echo "  frontend-test  - JavaScript regression tests"
+	@echo "  browser-test   - Extension workflows in four browser configurations"
+	@echo "  frontend-coverage - JavaScript tests, browser tests, and coverage gate"
 	@echo "  test-fast      - Run core functionality tests"
 	@echo "  dev-test       - Quick development test"
 	@echo "  release-test   - Full release validation"
@@ -120,13 +124,20 @@ test-fast: $(VENV_DIR)
 	print('🎉 All core tests passed!'); \
 	"
 
-test: test-fast
-	@echo "Running comprehensive test suite..."
-	@echo "✅ Test case 1: 512×512 → 1024×1024 (scale: 2.0)"
-	@echo "✅ Test case 2: 1024×1024 → 1536×1536 (scale: 1.5)"
-	@echo "✅ Test case 3: 832×1216 → 1272×1864 (scale: 1.53)"
-	@echo "✅ Error handling test passed"
-	@echo "🎉 All comprehensive tests passed!"
+test: $(VENV_DIR)
+	@$(PYTHON_CMD) -m pytest tests
+
+coverage: $(VENV_DIR)
+	@$(PYTHON_CMD) -m pytest tests --cov=kikotools --cov-report=term-missing --cov-report=html
+
+frontend-test:
+	npm test --prefix tools/testing
+
+browser-test:
+	npm run --prefix tools/testing test:browser
+
+frontend-coverage:
+	npm run --prefix tools/testing test:coverage
 
 release-test: quality-check test
 	@echo "Running release validation..."

README.md

@@ -38,6 +38,9 @@ I’m sharing them here with the community, and I hope you find them as useful a
 | [🔤 Embedding Autocomplete](#-embedding-autocomplete) | Smart autocomplete for embeddings, LoRAs, and tags | 🔧 Utils |
 | [🧹 Kiko Purge VRAM](#-kiko-purge-vram) | Intelligent VRAM management with detailed reporting | 🛠️ Utils |
 | [📂 Local Image Loader](#-local-image-loader) | Visual gallery browser for local media files | 💾 Images |
+| [🌐 Model Downloader](#-model-downloader) | Download models from CivitAI, HuggingFace, and custom URLs | 🛠️ Utils |
+| [⏱️ Workflow Timer](#️-workflow-timer) | Real-time execution timer with customizable display | 🛠️ Utils |
+| [🗂️ Project File Path](#️-project-file-path) | Build safe, organized save prefixes like `MyProject/images/image` | 🛠️ Utils |
 
 ### 🧰 xyz-helpers Tools
 
@@ -47,6 +50,8 @@ Advanced parameter management tools adapted from [comfyui-essentials-nodes](http
 |------|-------------|----------|
 | [🎛️ Flux Sampler Params](#️-flux-sampler-params) | FLUX-optimized parameter generator with batch support | 🧰 xyz-helpers |
 | [📁 LoRA Folder Batch](#-lora-folder-batch) | Batch process multiple LoRAs from folders | 🧰 xyz-helpers |
+| [🔁 Checkpoint Folder Iterator](#-checkpoint-folder-iterator) | Load one checkpoint per queued run from a folder | 🧰 xyz-helpers |
+| [🧩 Model Compare Sheet](#-model-compare-sheet) | Save each run's image and rebuild a labeled contact sheet | 🧰 xyz-helpers |
 | [📊 Plot Parameters](#-plot-parameters) | Visualize parameter effects with graphs | 🧰 xyz-helpers |
 | [🎯 Sampler Select Helper](#-sampler-select-helper) | Intelligent sampler selection with recommendations | 🧰 xyz-helpers |
 | [📅 Scheduler Select Helper](#-scheduler-select-helper) | Optimal scheduler selection for samplers | 🧰 xyz-helpers |
@@ -298,6 +303,28 @@ Automated batch processing for multiple LoRA models from folders.
 
 ![LoRA Folder Batch Example](examples/workflows/xyz_helpers_lora_testing.png)
 
+#### 🔁 Checkpoint Folder Iterator
+Run the same prompt through every checkpoint in a folder, one model per queued run.
+
+- **folder**: relative to `models/checkpoints`, or an absolute path anywhere on disk; regex include/exclude filters
+- **index** with `control_after_generate`: set 0 + *increment*, then queue a batch count equal to the checkpoint count
+- Queuing past the last checkpoint fails that run with a clear message instead of wrapping around, so the finished sweep is never restarted or archived by accident
+- Outputs MODEL/CLIP/VAE for the indexed file plus `ckpt_name`, `label`, `index`, `count`
+- Only one checkpoint is loaded at a time, so large folders do not exhaust RAM
+
+#### 🧩 Model Compare Sheet
+Output node that pairs with Checkpoint Folder Iterator.
+
+- Saves each run's image(s) to `output/model_compare/<run_name>/<NN>_<label>.png`
+- Rebuilds `grid.png` from every tile saved so far, each labeled with its filename
+- `columns`, `tile_width`, `font_size` control the layout; the grid is also returned as IMAGE
+- The node preview (and anything else that reads it) gets `grid_preview.png`, at most 1024 px wide; `grid.png` keeps full resolution
+- After the last queued run the preview shows the complete sheet
+- Wire Project File Path into `run_name` for `project/date/sweep` folders
+- A run at index 0 moves tiles already in the folder to `<run_name>_<timestamp>`, so an interrupted sweep never leaks into the new grid
+- Rerunning a nonzero index replaces its complete batch, even when the label or batch size changes; other indexes are preserved
+- Replacement PNGs are fully written before existing tiles are changed; a failed tile write preserves the prior tiles and grid
+
 #### 📊 Plot Parameters
 Visual analysis tool for understanding parameter relationships and effects.
 
@@ -378,6 +405,64 @@ Visual gallery browser for loading local images, videos, and audio files directl
 - Extract prompts and settings from previously generated images
 - Preview media files before loading into workflow
 
+#### 🌐 Model Downloader
+Download models, LoRAs, and other assets directly from CivitAI, HuggingFace, and custom URLs within ComfyUI.
+
+- **Multi-Platform Support**: CivitAI, HuggingFace, and direct download URLs
+- **Smart URL Detection**: Automatic detection of download source and file handling
+- **API Token Support**: Optional authentication for private/gated models
+- **Progress Reporting**: Real-time download progress with speed indicators
+- **Resume Support**: Skip existing files or force re-download
+- **Interrupt Handling**: Respects ComfyUI's "Cancel current run" button
+- **Automatic Cleanup**: Removes partial downloads on cancellation
+- **Custom Filenames**: Override auto-detected filenames when needed
+
+**Platform Features:**
+- **CivitAI**: Model page URLs, version-specific downloads, API authentication
+- **HuggingFace**: Blob and resolve URLs, branch/revision support, gated model access
+- **Custom URLs**: Direct download links with bearer token authentication
+
+**Use Cases:**
+- Download models without leaving ComfyUI
+- Automate asset acquisition in workflows
+- Access private or gated models with API tokens
+- Build reproducible workflows with automatic model fetching
+- Quickly test new models from the community
+
+![Model Downloader Example](examples/workflows/model_downloader_example.png)
+
+#### ⏱️ Workflow Timer
+Real-time execution timer that displays workflow duration with millisecond precision.
+
+- **Live Timing**: Updates in real-time during workflow execution (MM:SS:mmm format)
+- **Customizable Color**: Choose your preferred display color via KikoTools settings
+- **Glow Effect**: Optional pulsing glow animation (can be enabled/disabled in settings)
+- **Global Settings**: Color and glow preferences apply to all timer nodes
+- **Persistent Display**: Shows final execution time after workflow completes
+- **Multi-Node Sync**: All timer nodes stay synchronized during execution
+
+**Use Cases:**
+- Monitor workflow execution performance
+- Compare generation times across different settings
+- Identify slow nodes by adding timers at different workflow stages
+- Track optimization improvements over time
+
+**Settings (KikoTools Settings Panel):**
+- **Workflow Timer: Color** - Custom color picker for timer display
+- **Workflow Timer: Enable Glow** - Toggle pulsing glow effect on/off
+
+#### 🗂️ Project File Path
+Builds an organized save prefix to wire into a save node's `filename_prefix`.
+
+- **Structure**: `root/project_name/[YYYY-MM-DD/]subfolder/filename`, e.g. `MyProject/2026-10-13/images/image`
+- **Date Folder**: Optional toggle inserts today's date after the project; the node re-runs when the date changes
+- **Safe Paths**: Unsafe characters are removed, spaces become underscores, and `..` segments are dropped so paths stay inside the output folder
+- **Nested Folders**: Use `a/b` in `subfolder` for deeper structure
+- **Extensions**: Known file extensions (`.png`, `.mp4`, ...) are stripped from `filename`; `render_v1.5` is left as is
+- **Separator**: `auto`, `forward_slash` or `backslash`
+
+Based on the idea of the Project File Path Generator from djz-nodes.
+
 ### 🔤 Embedding Autocomplete
 
 **Intelligent autocomplete for embeddings, LoRAs, and custom tags in text prompts.**
@@ -421,7 +506,7 @@ This feature is an enhanced fork of the autocomplete functionality from [ComfyUI
 **Intelligent GPU memory management with threshold-based triggering and detailed reporting.**
 
 **Key Features:**
-- **4 Purge Modes**: 
+- **4 Purge Modes**:
   - `soft`: Basic garbage collection and cache clearing
   - `aggressive`: Multiple GC passes with full CUDA cache clearing
   - `models_only`: Unload all models and clear model cache
@@ -478,7 +563,7 @@ Time: 150.0ms
 ### 🔧 Architecture Highlights
 
 - **Modular Design**: Each tool is self-contained and independently testable
-- **Test-Driven Development**: 100% test coverage with comprehensive unit tests
+- **Test-Driven Development**: Regression tests for Python logic, JavaScript extensions, and browser workflows
 - **Clean Interfaces**: Standardized input/output patterns across all tools
 - **Separation of Concerns**: Clear distinction between logic, UI, and integration layers
 - **SOLID Principles**: Extensible architecture following software engineering best practices
@@ -699,6 +784,9 @@ Example workflow available: [xyz_helpers_lora_testing.json](examples/workflows/x
 | **Sampler Select Helper** | Intelligent sampler selection with recommendations | ✅ Complete | [Docs](examples/documentation/sampler_select_helper.md) |
 | **Scheduler Select Helper** | Optimal scheduler selection for samplers | ✅ Complete | [Docs](examples/documentation/scheduler_select_helper.md) |
 | **Text Encode Sampler Params** | Combined text encoding and parameter management | ✅ Complete | [Docs](examples/documentation/text_encode_sampler_params.md) |
+| **Local Image Loader** | Visual gallery browser for local media files | ✅ Complete | [Docs](examples/documentation/local_image_loader.md) |
+| **Model Downloader** | Download models from CivitAI, HuggingFace, and custom URLs | ✅ Complete | [Docs](examples/documentation/model_downloader.md) |
+| **Workflow Timer** | Real-time execution timer with customizable display | ✅ Complete | [Docs](examples/documentation/workflow_timer.md) |
 | **Batch Image Processor** | Process multiple images with consistent settings | 🚧 Planned | Coming Soon |
 | **Advanced Prompt Utilities** | Enhanced prompt manipulation and generation | 🚧 Planned | Coming Soon |
 
@@ -939,8 +1027,8 @@ Following **Test-Driven Development (TDD)**:
 # Test structure
 tests/
 ├── unit/                    # Individual component tests
-├── integration/            # ComfyUI workflow tests
-└── fixtures/              # Test data and workflows
+├── js/                      # Extension and coverage-gate regression tests
+└── browser/                 # Browser workflows and disposable host fixtures
 ```
 
 ### Adding New Tools
@@ -981,7 +1069,7 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 🏷️ Tags
 
-`comfyui` `custom-nodes` `image-processing` `ai-tools` `sdxl` `flux` `upscaling` `resolution` `batch-processing` `python` `pytorch`
+`comfyui` `custom-nodes` `image-processing` `ai-tools` `sdxl` `flux` `upscaling` `resolution` `batch-processing` `model-downloader` `civitai` `huggingface` `python` `pytorch`
 
 ## 🔗 Links
 
@@ -992,17 +1080,18 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 📈 Stats
 
-- **Nodes**: 19 (13 core tools + 6 xyz-helpers)
+- **Nodes**: 21 (15 core tools + 6 xyz-helpers)
 - **Features**: Embedding Autocomplete (settings-based, not a node)
 - **Categories**: 9 emoji-based categories for better organization
+- **Download Platforms**: 3 (CivitAI, HuggingFace, Custom URLs)
 - **Format Support**: 3 (PNG, JPEG, WebP with advanced controls)
 - **Presets**: 26 curated resolution presets
 - **Interactive Features**: 8+ (swap buttons, history UI, popup viewers, parameter visualization)
 - **AI Integration**: Gemini API with 40+ model support
-- **Test Coverage**: 100% (300+ comprehensive tests)
+- **Test Coverage**: Enforced 85% Python statement/branch coverage and per-file frontend coverage floors
 - **Python Version**: 3.8+
 - **ComfyUI Compatibility**: Latest
-- **Dependencies**: Minimal (PyTorch, NumPy, Pillow, google-generativeai for Gemini)
+- **Dependencies**: Minimal (PyTorch, NumPy, Pillow, google-genai for Gemini)
 
 ## 🙏 Attribution
 
@@ -1028,3 +1117,8 @@ All adaptations maintain compatibility while adding new features and optimizatio
 [⭐ Star this repo](https://github.com/ComfyAssets/ComfyUI-KikoTools) • [🐛 Report Bug](https://github.com/ComfyAssets/ComfyUI-KikoTools/issues) • [💡 Request Feature](https://github.com/ComfyAssets/ComfyUI-KikoTools/issues)
 
 </div>
+
+## Automated testing
+
+See [TESTING.md](TESTING.md) for Python and JavaScript tests, cross-browser
+workflows, coverage gates, CI reports, and required merge checks.

TESTING.md

@@ -0,0 +1,126 @@
+# Testing and merge confidence
+
+Use regression tests before fixing a bug. Confirm that the test fails on the
+original implementation, then run the relevant suites after the fix.
+
+## What runs
+
+| Layer | Real components | Replaced boundaries |
+| --- | --- | --- |
+| Python | Tool logic, tensors, image files, API validation | ComfyUI services and external models where needed |
+| JavaScript | Production extension hooks and callback behavior | Minimal host objects; controlled timers for focused regressions |
+| Browser | All shipped extension imports and lifecycle registration; real plugin startup, HTTP routes, PNG thumbnails, selection persistence, and image loading | ComfyUI graph/widgets/settings/event interfaces and its saved-image serving endpoint |
+
+Browser workflows cover swaps, local image browsing/selection, pagination,
+sorting, hidden folders, directory autocomplete, saved paths,
+denied paths and network recovery, display output, seed persistence/cleanup, and
+workflow timing, autocomplete insertion, and saved-image previews. They run in Chromium, Firefox, WebKit, and touch Chromium.
+The harness binds to localhost and writes configuration, selections, and fixture
+images only inside a temporary directory. External browser requests fail tests;
+custom-word downloads are disabled in the fixture. No credentials, model
+weights, running ComfyUI, or GPU are required.
+
+## Run locally
+
+Use Python 3.10–3.13 and Node.js 24. Install the CPU PyTorch wheel on Linux if you
+do not need CUDA, then install the development dependencies:
+
+```sh
+python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
+python -m pip install -r requirements-dev.txt
+python -m pytest tests
+python -m pytest tests --cov=kikotools --cov-report=term-missing
+npm ci --prefix tools/testing --ignore-scripts
+npx --prefix tools/testing playwright install --with-deps chromium firefox webkit
+npm test --prefix tools/testing
+npm run --prefix tools/testing test:coverage
+npm run --prefix tools/testing test:browser -- --project firefox --project webkit
+```
+
+`make test` runs the full pytest suite and propagates failures. `make coverage`,
+`make frontend-test`, `make browser-test`, and `make frontend-coverage` provide
+shortcuts. The Python Make targets use the existing virtual-environment setup.
+Install local commit and push hooks with `pre-commit install --hook-type
+pre-commit --hook-type pre-push`. The push hooks run Python and JavaScript
+regressions; CI additionally runs all browser workflows and coverage gates.
+For a quick browser check, use `test:browser -- --project chromium`.
+`KIKO_TEST_PYTHON` selects a Python executable with the development dependencies;
+`KIKO_TEST_PORT` changes the default port 8766. Servers are never reused.
+Unsupported Linux distributions may lack WebKit libraries; Ubuntu CI validates
+all engines.
+
+## Coverage and diagnosis
+
+Python CI checks all twelve Python/OS combinations and enforces 85% combined
+statement/branch coverage. Every production `web/*.js` file appears in frontend
+coverage, including code without behavioral coverage. V8 unit coverage and
+Chromium desktop/touch coverage are merged through c8. The committed per-file
+floors are an honest starting point, not a claim that every feature is tested.
+
+`npm run --prefix tools/testing coverage:update` reruns the suites and raises
+floors with two percentage points of runtime allowance. It cannot lower existing
+floors; new source files require 80% line coverage when added with this command.
+Missing measurements, missing baselines, and per-file regressions fail CI.
+
+CI artifacts include Python JUnit results, Python HTML/XML coverage, and
+`frontend-test-reports` with frontend HTML coverage and browser failure traces
+and screenshots. Open traces using Playwright's `show-trace` command. Local
+frontend coverage is at `coverage/js/index.html`.
+
+Real ComfyUI/LiteGraph compatibility, GPU execution, cloud inference, network
+model downloads, and visual design still need targeted live checks when changed.
+The browser host is a test double; these workflows do not run the real ComfyUI
+frontend or certify every node's UI. Type checking and security jobs retain their
+existing advisory behavior.
+
+### Actual ComfyUI frontend smoke test
+
+The Local Image Loader also has an opt-in suite using the actual ComfyUI frontend,
+graph, DOM widgets, renderer switch and palette settings. Start a local ComfyUI
+0.39.0 with frontend 1.55.14 and KikoTools installed, then run:
+
+```sh
+KIKO_COMFY_URL=http://127.0.0.1:8188/ node \
+  tools/testing/node_modules/@playwright/test/cli.js test \
+  --config tools/testing/comfyui.config.mjs
+```
+
+The suite requires those exact versions and records them in its artifacts. It
+serves the current checkout's extensions to a separate browser context and loads
+only KikoTools extensions. Media requests use the existing real Python routes
+with disposable fixture data on port 8771. Other HTTP writes are intercepted,
+so user settings, saved workflows and selections are not written to the live
+server. It does not execute a workflow or download models.
+
+Checks cover Classic/Nodes 2.0/live switching, theme changes, workflow save/reload
+and removal for the loader. Save Image additionally checks real image output,
+window close/reopen through the node control across renderer switches, theme
+changes, exclusion of the launcher from serialized values and owner removal.
+Its `/view` requests also use disposable fixture output rather than live files.
+Seed History checks keyboard-operable rows through renderer switches, list growth
+and scrolling on resize, palettes, saved history/node dimensions, serialization
+and polling cleanup on removal.
+Workflow Timer covers execution events, Classic/Nodes 2.0 switching, themes,
+custom node colors, persisted time/dimensions and the actual settings picker.
+Screenshots/traces appear in
+`tools/testing/test-results/comfyui/`. This opt-in smoke suite is separate from
+the required fixture CI job; fully provisioned, pinned ComfyUI CI and testing
+alongside other node packs remain follow-up work in issue #81.
+
+## Required merge checks
+
+The manifest in `.github/branch-protection.json` requires all Python matrix jobs,
+Python coverage, frontend syntax, frontend workflows/coverage, and the existing
+`code-quality` job (including Black and fatal lint checks). Administrators follow
+the same checks and branches must be current with main. No extra human approval
+is required. Workflows run on every pull request without path filters.
+
+After the checks pass, an administrator applies and verifies the manifest:
+
+```sh
+gh api --method PUT repos/ComfyAssets/ComfyUI-KikoTools/branches/main/protection \
+  --input .github/branch-protection.json
+gh api repos/ComfyAssets/ComfyUI-KikoTools/branches/main/protection/required_status_checks
+```
+
+Keep the manifest synchronized with job names when changing CI.

__init__.py

@@ -105,7 +105,7 @@ def get_version():
     try:
         pyproject_path = Path(__file__).parent / "pyproject.toml"
         if pyproject_path.exists():
-            content = pyproject_path.read_text()
+            content = pyproject_path.read_text(encoding="utf-8")
             match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
             if match:
                 return match.group(1)
@@ -118,7 +118,10 @@ def get_version():
 print()
 print(f"\033[94m[ComfyUI-KikoTools] Version:\033[0m {get_version()}")
 for node_key, display_name in NODE_DISPLAY_NAME_MAPPINGS.items():
-    print(f"🫶 \033[94mLoaded:\033[0m {display_name}")
+    # ASCII only: a Windows console using a legacy code page cannot print emoji,
+    # and a UnicodeEncodeError here would abort loading the whole node.
+    ascii_name = display_name.encode("ascii", "ignore").decode().strip()
+    print(f"  \033[94mLoaded:\033[0m {ascii_name}")
 print(f"\033[94mTotal: {len(NODE_CLASS_MAPPINGS)} tools loaded\033[0m")
 print()
 

examples/documentation/batch_prompts.md

@@ -103,4 +103,4 @@ The node provides several ways to track progress:
 ### State persistence
 - State is stored in your system's temp directory
 - Clear `/tmp/comfyui_batch_prompts/` to reset all counters
-- Use `reload_file` to reset counter for a specific file
+- Use `reload_file` to reset counter for a specific file

examples/documentation/display_any.md

@@ -117,4 +117,4 @@ Config Node → Display Any (raw value) → Processing Node
 [Text Multiline] ← [Concatenate] ← "Image dimensions: "
 ```
 
-This creates a text output showing the current image dimensions that can be used elsewhere in your workflow.
+This creates a text output showing the current image dimensions that can be used elsewhere in your workflow.

examples/documentation/display_text.md

@@ -85,7 +85,7 @@ Display long text content with scrolling and word wrapping.
 
 The node intelligently detects prompt formats:
 
-1. **SDXL Format**: 
+1. **SDXL Format**:
    - Looks for "Positive prompt:" and "Negative prompt:" markers
    - Case-insensitive detection
    - Handles various formatting styles
@@ -98,7 +98,7 @@ The node intelligently detects prompt formats:
 ## Styling
 
 - **Font**: Monospace for consistent alignment
-- **Colors**: 
+- **Colors**:
   - Text: Light gray (#ddd) on dark background
   - Background: Semi-transparent dark (#1a1a1a)
   - Borders: Subtle gray (#333)
@@ -144,4 +144,4 @@ The node intelligently detects prompt formats:
    SDXL Format            Split View Display    Clean Prompts
 ```
 
-This creates a seamless workflow from prompt generation to usage, with the Display Text node providing the visual interface for review and interaction.
+This creates a seamless workflow from prompt generation to usage, with the Display Text node providing the visual interface for review and interaction.

examples/documentation/flux_sampler_params.md

@@ -149,4 +149,4 @@ base_shift: 0.4
 - **1.0.3**: Improved UI elements and parameter validation
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/documentation/gemini_prompt.md

@@ -21,7 +21,7 @@ Get your free Gemini API key from [Google AI Studio](https://makersuite.google.c
 ### 2. Install Dependencies
 
 ```bash
-pip install google-generativeai
+pip install google-genai
 ```
 
 ### 3. Configure API Key
@@ -204,6 +204,6 @@ Errors are displayed in the prompt output for easy debugging.
 - Verify API key is valid
 - Image might be too large (resize if needed)
 
-**Import error for google-generativeai**:
-- Run `pip install google-generativeai` in your ComfyUI environment
-- Restart ComfyUI after installation
+**Import error for google-genai**:
+- Run `pip install google-genai` in your ComfyUI environment
+- Restart ComfyUI after installation

examples/documentation/image_to_multiple_of.md

@@ -79,4 +79,4 @@ Load Images → Image to Multiple Of (multiple_of: 16, method: rescale) → Batc
 The node will raise an error if:
 - The image dimensions are smaller than the specified multiple_of value
 - Invalid input types are provided
-- The resulting dimensions would be 0 or negative
+- The resulting dimensions would be 0 or negative

examples/documentation/kiko_film_grain.md

@@ -122,4 +122,4 @@ Creates monochrome grain perfect for black and white photography.
 - Works with any image format supported by ComfyUI
 - Preserves image properties (alpha channel, batch size)
 - Compatible with both RGB and RGBA images
-- Efficient batch processing support
+- Efficient batch processing support

examples/documentation/kiko_save_image.md

@@ -50,7 +50,7 @@ Enhanced image saving node with multiple format support, quality controls, and a
 ### Image Grid
 - **Thumbnails**: Click any image to open full-size in new tab
 - **File Info**: Shows filename and size for each image
-- **Quality Indicators**: 
+- **Quality Indicators**:
   - PNG: Compression level (0-9)
   - JPEG/WebP: Quality percentage
 - **Batch Selection**: Checkboxes for multi-select operations
@@ -210,4 +210,4 @@ Batch Generate → Kiko Save Image → Popup Viewer
 **Can't see all images**:
 - Scroll within the popup grid
 - Maximize the popup window
-- Images are shown newest first
+- Images are shown newest first

examples/documentation/local_image_loader.md

@@ -155,4 +155,4 @@ The node creates a visual widget that runs in the ComfyUI interface and communic
 - Save user preferences
 - Handle file selection
 
-All file operations are performed server-side for security, with proper path validation to prevent directory traversal attacks.
+All file operations are performed server-side for security, with proper path validation to prevent directory traversal attacks.

examples/documentation/lora_folder_batch.md

@@ -261,4 +261,4 @@ batch_mode: sequential
 - **1.0.4**: Added auto-batching for large LoRA collections
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/documentation/plot_parameters.md

@@ -109,12 +109,12 @@ Parameter Grid → PlotParameters → Analysis Display
 x_axis: "guidance"
 y_axis: "perceived_quality"
 
-# Step efficiency analysis  
+# Step efficiency analysis
 x_axis: "steps"
 y_axis: "generation_time"
 
 # LoRA impact assessment
-x_axis: "lora_strength"  
+x_axis: "lora_strength"
 y_axis: "style_adherence"
 ```
 
@@ -231,4 +231,4 @@ Compare multiple generation runs to identify optimal parameters.
 - **1.0.3**: Improved export capabilities
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/documentation/sampler_select_helper.md

@@ -257,4 +257,4 @@ Compare all compatible samplers for specific model/prompt combination.
 - **1.0.3**: Improved auto-detection
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/documentation/scheduler_select_helper.md

@@ -297,4 +297,4 @@ Progress through schedulers from fast to quality for different use cases.
 - **1.0.3**: Improved compatibility matrix
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/documentation/text_encode_sampler_params.md

@@ -142,7 +142,7 @@ steps: 30-40
 cfg: 7-8
 sampler: dpmpp_3m_sde
 
-# Speed over quality  
+# Speed over quality
 steps: 10-15
 cfg: 5-6
 sampler: euler
@@ -307,4 +307,4 @@ Very High (50+): Diminishing returns
 - **1.0.3**: Improved batch processing
 
 ## Credits
-Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.
+Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/test_prompts.txt

@@ -11,4 +11,4 @@ Enchanted forest with magical glowing mushrooms, fairy lights, mystical atmosphe
 Negative: desert, urban, modern, realistic, mundane
 ---
 Space station orbiting Earth, detailed mechanical structures, astronauts performing spacewalk, realistic sci-fi, NASA photography
-Negative: fantasy, medieval, underwater, cartoon style
+Negative: fantasy, medieval, underwater, cartoon style

examples/workflows/display_any_example.json

@@ -376,4 +376,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/display_text_example.json

@@ -141,4 +141,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/empty_latent_batch_example.json

@@ -298,4 +298,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/gemini_prompt_example.json

@@ -204,4 +204,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/image_to_multiple_of_example.json

@@ -549,4 +549,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/kiko_film_grain_example.json

@@ -162,4 +162,4 @@
     }
   },
   "version": 0.4
-}
+}

examples/workflows/kiko_save_image_example.json

@@ -144,4 +144,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/resolution_calculator_example.json

@@ -352,4 +352,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

examples/workflows/xyz_helpers_sampler_comparison.json

@@ -166,4 +166,4 @@
     ],
     "attribution": "xyz_helpers nodes adapted from comfyui-essentials-nodes"
   }
-}
+}

kikotools/__init__.py

@@ -3,7 +3,14 @@ KikoTools package initialization and node registry
 Handles automatic discovery and registration of all ComfyAssets tools
 """
 
+from .tools.batch_list_converter import (
+    ImageBatchToImageListNode,
+    ImageListToImageBatchNode,
+    LatentBatchToLatentListNode,
+    LatentListToLatentBatchNode,
+)
 from .tools.batch_prompts import BatchPromptsNode
+from .tools.checkpoint_folder_iterator import CheckpointFolderIteratorNode
 from .tools.display_any import DisplayAnyNode
 from .tools.display_text import DisplayTextNode
 from .tools.embedding_autocomplete import KikoEmbeddingAutocomplete
@@ -13,12 +20,18 @@ from .tools.image_scale_down_by import ImageScaleDownByNode
 from .tools.image_to_multiple_of import ImageToMultipleOfNode
 from .tools.kiko_film_grain import KikoFilmGrainNode
 from .tools.kiko_purge_vram import KikoPurgeVRAM
+from .tools.kiko_workflow_timer import KikoWorkflowTimerNode
 from .tools.kiko_save_image import KikoSaveImageNode
 from .tools.local_image_loader import LocalImageLoaderNode
+from .tools.project_file_path import ProjectFilePathNode
+from .tools.model_compare_sheet import ModelCompareSheetNode
+from .tools.model_downloader import ModelDownloaderNode
 from .tools.resolution_calculator import ResolutionCalculatorNode
 from .tools.sampler_combo import SamplerComboCompactNode, SamplerComboNode
 from .tools.seed_history import SeedHistoryNode
+from .tools.text_input import TextInputNode
 from .tools.width_height_selector import WidthHeightSelectorNode
+from .tools.width_height_to_vec2 import WidthHeightToVec2Node
 from .tools.xyz_helpers import (
     FluxSamplerParamsNode,
     LoRAFolderBatchNode,
@@ -30,6 +43,10 @@ from .tools.xyz_helpers import (
 
 # ComfyUI node registration mappings
 NODE_CLASS_MAPPINGS = {
+    "ImageBatchToImageList": ImageBatchToImageListNode,
+    "ImageListToImageBatch": ImageListToImageBatchNode,
+    "LatentBatchToLatentList": LatentBatchToLatentListNode,
+    "LatentListToLatentBatch": LatentListToLatentBatchNode,
     "BatchPrompts": BatchPromptsNode,
     "ResolutionCalculator": ResolutionCalculatorNode,
     "WidthHeightSelector": WidthHeightSelectorNode,
@@ -43,20 +60,31 @@ NODE_CLASS_MAPPINGS = {
     "GeminiPrompt": GeminiPromptNode,
     "DisplayAny": DisplayAnyNode,
     "DisplayText": DisplayTextNode,
+    "TextInput": TextInputNode,
     "KikoFilmGrain": KikoFilmGrainNode,
     "KikoPurgeVRAM": KikoPurgeVRAM,
     "KikoLocalImageLoader": LocalImageLoaderNode,
+    "KikoModelDownloader": ModelDownloaderNode,
     "SamplerSelectHelper": SamplerSelectHelperNode,
     "SchedulerSelectHelper": SchedulerSelectHelperNode,
     "TextEncodeSamplerParams": TextEncodeSamplerParamsNode,
     "FluxSamplerParams": FluxSamplerParamsNode,
     "PlotParameters+": PlotParametersNode,
     "LoRAFolderBatch": LoRAFolderBatchNode,
+    "CheckpointFolderIterator": CheckpointFolderIteratorNode,
+    "ModelCompareSheet": ModelCompareSheetNode,
+    "WidthHeightToVec2": WidthHeightToVec2Node,
+    "KikoWorkflowTimer": KikoWorkflowTimerNode,
+    "KikoProjectFilePath": ProjectFilePathNode,
     # Note: KikoEmbeddingAutocomplete is not registered as a node
     # It's a settings-only feature accessed through ComfyUI settings menu
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
+    "ImageBatchToImageList": "Image Batch to Image List",
+    "ImageListToImageBatch": "Image List to Image Batch",
+    "LatentBatchToLatentList": "Latent Batch to Latent List",
+    "LatentListToLatentBatch": "Latent List to Latent Batch",
     "BatchPrompts": "Batch Prompts",
     "ResolutionCalculator": "Resolution Calculator",
     "WidthHeightSelector": "Width Height Selector",
@@ -70,15 +98,22 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "GeminiPrompt": "Gemini Prompt Engineer",
     "DisplayAny": "Display Any",
     "DisplayText": "Display Text",
+    "TextInput": "Text Input",
     "KikoFilmGrain": "Film Grain",
     "KikoPurgeVRAM": "Kiko Purge VRAM",
     "KikoLocalImageLoader": "Local Image Loader",
+    "KikoModelDownloader": "Model Downloader 🌐",
     "SamplerSelectHelper": "Sampler Select Helper",
     "SchedulerSelectHelper": "Scheduler Select Helper",
     "TextEncodeSamplerParams": "Text Encode for Sampler Params",
     "FluxSamplerParams": "Flux Sampler Parameters",
     "PlotParameters+": "Plot Parameters",
     "LoRAFolderBatch": "LoRA Folder Batch",
+    "CheckpointFolderIterator": "Checkpoint Folder Iterator",
+    "ModelCompareSheet": "Model Compare Sheet",
+    "WidthHeightToVec2": "Width Height to VEC2",
+    "KikoWorkflowTimer": "Workflow Timer",
+    "KikoProjectFilePath": "Project File Path",
     # KikoEmbeddingAutocomplete removed - settings only, not a node
 }
 

kikotools/base/model_folders.py

@@ -0,0 +1,106 @@
+"""Scan ComfyUI model folders (loras, checkpoints, ...) for .safetensors files."""
+
+import logging
+import os
+import re
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def get_model_roots(folder_key: str) -> List[str]:
+    """Return every configured root directory for a folder_paths key."""
+    try:
+        import folder_paths
+
+        entry = folder_paths.folder_names_and_paths.get(folder_key)
+        return list(entry[0]) if entry else []
+    except (ImportError, AttributeError, IndexError, TypeError):
+        return []
+
+
+def is_within(path: str, root: str) -> bool:
+    """True if realpath `path` equals or is inside realpath `root`."""
+    try:
+        real_path, real_root = os.path.realpath(path), os.path.realpath(root)
+        return os.path.commonpath([real_path, real_root]) == real_root
+    except ValueError:  # different drives or mixed absolute/relative
+        return False
+
+
+def resolve_scan_targets(
+    folder_path: str, folder_key: str
+) -> List[Tuple[str, Optional[str]]]:
+    """
+    Resolve a folder setting to (directory, base_root) pairs to scan.
+
+    base_root is the model root the directory lives in, or None when the
+    directory is an absolute path outside every known root.
+    """
+    roots = get_model_roots(folder_key)
+
+    if os.path.isabs(folder_path):
+        base = next((r for r in roots if is_within(folder_path, r)), None)
+        return [(folder_path, base)]
+
+    targets = []
+    for root in roots:
+        candidate = os.path.join(root, folder_path)
+        if not is_within(candidate, root):
+            logger.warning(f"Folder escapes the {folder_key} directory: {folder_path}")
+            continue
+        targets.append((candidate, root))
+    return targets
+
+
+def scan_model_entries(folder_path: str, folder_key: str) -> List[Tuple[str, str]]:
+    """Return naturally sorted (relative_name, absolute_path) for every .safetensors."""
+    entries: Dict[str, str] = {}
+    for directory, base in resolve_scan_targets(folder_path, folder_key):
+        if not os.path.isdir(directory):
+            continue
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if not file.endswith(".safetensors"):
+                    continue
+                full = os.path.join(root, file)
+                try:
+                    rel = os.path.relpath(full, base or directory)
+                except ValueError:
+                    rel = os.path.relpath(full, directory)
+                entries.setdefault(rel.replace("\\", "/"), full)
+    return [(name, entries[name]) for name in natural_sort(list(entries))]
+
+
+def natural_sort(items: List[str]) -> List[str]:
+    """Sort strings so embedded numbers compare numerically (v2 < v10)."""
+
+    def natural_key(text):
+        parts = []
+        for part in re.split(r"(\d+)", text):
+            if not part:
+                continue
+            parts.append((0, int(part)) if part.isdigit() else (1, part.lower()))
+        return parts
+
+    return sorted(items, key=natural_key)
+
+
+def filter_by_pattern(
+    names: List[str], include_pattern: str = "", exclude_pattern: str = ""
+) -> List[str]:
+    """Keep names matching include_pattern (if set) and not exclude_pattern (if set)."""
+    filtered = list(names)
+    if include_pattern:
+        try:
+            include_re = re.compile(include_pattern)
+            filtered = [f for f in filtered if include_re.search(f)]
+        except re.error as e:
+            logger.error(f"Invalid include pattern: {e}")
+    if exclude_pattern:
+        try:
+            exclude_re = re.compile(exclude_pattern)
+            filtered = [f for f in filtered if not exclude_re.search(f)]
+        except re.error as e:
+            logger.error(f"Invalid exclude pattern: {e}")
+    return filtered

kikotools/core/registry.py

@@ -1,95 +0,0 @@
-"""Tool registry for KikoTools.
-
-This module provides the central registration system for all KikoTools nodes.
-"""
-
-import importlib
-from typing import Dict, Any
-from pathlib import Path
-
-
-class ToolRegistry:
-    """Central registry for all KikoTools."""
-
-    def __init__(self):
-        self.tools: Dict[str, Any] = {}
-        self.node_classes: Dict[str, Any] = {}
-
-    def register_tool(self, tool_name: str, node_class: Any) -> None:
-        """Register a tool and its node class.
-
-        Args:
-            tool_name: Name of the tool
-            node_class: The ComfyUI node class
-        """
-        self.tools[tool_name] = node_class
-
-        # Also register by class name for ComfyUI
-        class_name = node_class.__name__
-        self.node_classes[class_name] = node_class
-
-    def discover_tools(self) -> None:
-        """Automatically discover and load all tools in the tools directory."""
-        tools_dir = Path(__file__).parent.parent / "tools"
-
-        if not tools_dir.exists():
-            return
-
-        for tool_dir in tools_dir.iterdir():
-            if tool_dir.is_dir() and not tool_dir.name.startswith("_"):
-                self._load_tool(tool_dir.name)
-
-    def _load_tool(self, tool_name: str) -> None:
-        """Load a single tool module.
-
-        Args:
-            tool_name: Name of the tool directory
-        """
-        try:
-            # Try to import the tool's node module
-            module = importlib.import_module(f"kikotools.tools.{tool_name}.node")
-
-            # Look for node classes (classes with ComfyUI node attributes)
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and hasattr(attr, "INPUT_TYPES")
-                    and hasattr(attr, "FUNCTION")
-                ):
-                    self.register_tool(tool_name, attr)
-
-                    # If the tool has settings, register them
-                    if hasattr(attr, "SETTINGS"):
-                        from .settings import settings_registry
-
-                        settings_registry.register_tool_settings(
-                            tool_name,
-                            getattr(
-                                attr,
-                                "DISPLAY_NAME",
-                                tool_name.replace("_", " ").title(),
-                            ),
-                            attr.SETTINGS,
-                        )
-
-        except ImportError:
-            # Tool might not have a node.py file yet
-            pass
-
-    def get_node_class_mappings(self) -> Dict[str, Any]:
-        """Get node class mappings for ComfyUI registration."""
-        return self.node_classes.copy()
-
-    def get_node_display_name_mappings(self) -> Dict[str, str]:
-        """Get display name mappings for ComfyUI."""
-        mappings = {}
-        for class_name, node_class in self.node_classes.items():
-            if hasattr(node_class, "DISPLAY_NAME"):
-                mappings[class_name] = node_class.DISPLAY_NAME
-            else:
-                # Generate a display name from class name
-                mappings[class_name] = class_name.replace("Kiko", "").replace(
-                    "Node", ""
-                )
-        return mappings

kikotools/core/settings.py

@@ -1,201 +0,0 @@
-"""Settings registry for KikoTools.
-
-This module provides a centralized settings management system for all KikoTools.
-Tools can register their settings, which are then exposed in ComfyUI's settings UI.
-"""
-
-import json
-import os
-from typing import Dict, Any, List, Optional, Union
-from dataclasses import dataclass, field
-
-
-@dataclass
-class SettingDefinition:
-    """Definition of a single setting."""
-
-    id: str
-    name: str
-    type: str  # "boolean", "combo", "number", "string", "custom"
-    default: Any
-    description: Optional[str] = None
-    options: Optional[Union[List[Any], Dict[str, Any]]] = None
-    min_value: Optional[float] = None
-    max_value: Optional[float] = None
-    step: Optional[float] = None
-    on_change: Optional[str] = None  # JavaScript callback as string
-
-
-@dataclass
-class ToolSettings:
-    """Settings collection for a single tool."""
-
-    tool_name: str
-    display_name: str
-    settings: List[SettingDefinition] = field(default_factory=list)
-
-
-class SettingsRegistry:
-    """Central registry for all KikoTools settings."""
-
-    def __init__(self):
-        self.tools: Dict[str, ToolSettings] = {}
-        self.settings_by_id: Dict[str, SettingDefinition] = {}
-
-    def register_tool_settings(
-        self, tool_name: str, display_name: str, settings: Dict[str, Dict[str, Any]]
-    ) -> None:
-        """Register settings for a tool.
-
-        Args:
-            tool_name: Internal tool identifier (e.g., "embedding_autocomplete")
-            display_name: Display name for the tool (e.g., "Embedding Autocomplete")
-            settings: Dictionary of setting configurations
-                {
-                    "enabled": {
-                        "type": "boolean",
-                        "default": True,
-                        "description": "Enable embedding autocomplete"
-                    },
-                    "max_suggestions": {
-                        "type": "combo",
-                        "default": 20,
-                        "options": [10, 20, 50],
-                        "description": "Maximum number of suggestions"
-                    }
-                }
-        """
-        tool_settings = ToolSettings(tool_name, display_name)
-
-        for setting_key, config in settings.items():
-            # Generate fully qualified setting ID
-            setting_id = f"kikotools.{tool_name}.{setting_key}"
-
-            # Create display name with branding
-            setting_name = f"🫶 {display_name}: {setting_key.replace('_', ' ').title()}"
-
-            setting_def = SettingDefinition(
-                id=setting_id,
-                name=setting_name,
-                type=config.get("type", "string"),
-                default=config.get("default"),
-                description=config.get("description"),
-                options=config.get("options"),
-                min_value=config.get("min"),
-                max_value=config.get("max"),
-                step=config.get("step"),
-                on_change=config.get("on_change"),
-            )
-
-            tool_settings.settings.append(setting_def)
-            self.settings_by_id[setting_id] = setting_def
-
-        self.tools[tool_name] = tool_settings
-
-    def get_setting(self, setting_id: str) -> Optional[SettingDefinition]:
-        """Get a setting definition by ID."""
-        return self.settings_by_id.get(setting_id)
-
-    def get_tool_settings(self, tool_name: str) -> Optional[ToolSettings]:
-        """Get all settings for a tool."""
-        return self.tools.get(tool_name)
-
-    def generate_frontend_registration(self) -> str:
-        """Generate JavaScript code for frontend settings registration."""
-        js_lines = [
-            "// Auto-generated KikoTools settings registration",
-            "// This file is automatically generated by the settings registry",
-            "",
-            "import { app } from '../../scripts/app.js';",
-            "",
-            "app.registerExtension({",
-            "    name: 'kikotools.settings',",
-            "    async init() {",
-            "        // Register all KikoTools settings",
-        ]
-
-        for tool_name, tool_settings in self.tools.items():
-            js_lines.append(f"        // {tool_settings.display_name} settings")
-
-            for setting in tool_settings.settings:
-                js_lines.append("        app.ui.settings.addSetting({")
-                js_lines.append(f'            id: "{setting.id}",')
-                js_lines.append(f'            name: "{setting.name}",')
-                js_lines.append(
-                    f"            defaultValue: {self._js_value(setting.default)},"
-                )
-                js_lines.append(f'            type: "{setting.type}",')
-
-                if setting.description:
-                    js_lines.append(f'            tooltip: "{setting.description}",')
-
-                if setting.type == "combo" and setting.options:
-                    js_lines.append("            options: (value) => {")
-                    js_lines.append(
-                        f"                const options = {json.dumps(setting.options)};"
-                    )
-                    js_lines.append("                return options.map(opt => ({")
-                    js_lines.append("                    value: opt,")
-                    js_lines.append("                    text: String(opt),")
-                    js_lines.append("                    selected: opt === value")
-                    js_lines.append("                }));")
-                    js_lines.append("            }},")
-
-                if setting.type == "number":
-                    if setting.min_value is not None:
-                        js_lines.append(f"            min: {setting.min_value},")
-                    if setting.max_value is not None:
-                        js_lines.append(f"            max: {setting.max_value},")
-                    if setting.step is not None:
-                        js_lines.append(f"            step: {setting.step},")
-
-                if setting.on_change:
-                    js_lines.append("            onChange(value) {")
-                    js_lines.append(f"                {setting.on_change}")
-                    js_lines.append("            }")
-
-                js_lines.append("        }});")
-                js_lines.append("")
-
-        js_lines.extend(["    }", "});", ""])
-
-        return "\n".join(js_lines)
-
-    def _js_value(self, value: Any) -> str:
-        """Convert Python value to JavaScript literal."""
-        if isinstance(value, bool):
-            return "true" if value else "false"
-        elif isinstance(value, str):
-            return f'"{value}"'
-        elif value is None:
-            return "null"
-        else:
-            return str(value)
-
-    def save_frontend_settings(
-        self, output_path: str = "web/js/kikoSettings.js"
-    ) -> None:
-        """Save the generated frontend settings to a file."""
-        js_content = self.generate_frontend_registration()
-
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        with open(output_path, "w") as f:
-            f.write(js_content)
-
-    def get_all_settings(self) -> Dict[str, Any]:
-        """Get all registered settings as a dictionary."""
-        result = {}
-        for tool_name, tool_settings in self.tools.items():
-            result[tool_name] = {
-                "display_name": tool_settings.display_name,
-                "settings": {
-                    setting.id.split(".")[-1]: {
-                        "type": setting.type,
-                        "default": setting.default,
-                        "description": setting.description,
-                        "options": setting.options,
-                    }
-                    for setting in tool_settings.settings
-                },
-            }
-        return result

kikotools/tools/batch_list_converter/__init__.py

@@ -0,0 +1,15 @@
+"""Batch/List conversion tool for ComfyUI."""
+
+from .node import (
+    ImageBatchToImageListNode,
+    ImageListToImageBatchNode,
+    LatentBatchToLatentListNode,
+    LatentListToLatentBatchNode,
+)
+
+__all__ = [
+    "ImageBatchToImageListNode",
+    "ImageListToImageBatchNode",
+    "LatentBatchToLatentListNode",
+    "LatentListToLatentBatchNode",
+]

kikotools/tools/batch_list_converter/logic.py

@@ -0,0 +1,55 @@
+"""Pure tensor split/join functions for batch-list conversions."""
+
+import torch
+from typing import Dict, List
+
+
+def split_image_batch(images: torch.Tensor) -> List[torch.Tensor]:
+    """Split [B,H,W,C] image batch into list of [1,H,W,C] tensors."""
+    return [images[i : i + 1] for i in range(images.shape[0])]
+
+
+def join_image_batch(image_list: List[torch.Tensor]) -> torch.Tensor:
+    """Join list of image tensors into single [B,H,W,C] batch."""
+    return torch.cat(image_list, dim=0)
+
+
+def split_latent_batch(
+    latent: Dict[str, torch.Tensor],
+) -> List[Dict[str, torch.Tensor]]:
+    """Split latent dict into list of single-item latent dicts.
+
+    Preserves all keys (e.g. noise_mask, batch_index). Tensor values whose
+    first dimension matches the batch size of ``samples`` are sliced along
+    dim-0; all other values are copied as-is to every item.
+    """
+    samples = latent["samples"]
+    batch_size = samples.shape[0]
+    result: List[Dict[str, torch.Tensor]] = []
+    for i in range(batch_size):
+        item: Dict[str, torch.Tensor] = {}
+        for key, value in latent.items():
+            if isinstance(value, torch.Tensor) and value.shape[0] == batch_size:
+                item[key] = value[i : i + 1]
+            else:
+                item[key] = value
+        result.append(item)
+    return result
+
+
+def join_latent_batch(
+    latent_list: List[Dict[str, torch.Tensor]],
+) -> Dict[str, torch.Tensor]:
+    """Join list of latent dicts into single batched latent dict.
+
+    Tensor values that were sliced during split are concatenated along dim-0.
+    Non-tensor values are taken from the first item.
+    """
+    result: Dict[str, torch.Tensor] = {}
+    first = latent_list[0]
+    for key in first:
+        if isinstance(first[key], torch.Tensor):
+            result[key] = torch.cat([lat[key] for lat in latent_list], dim=0)
+        else:
+            result[key] = first[key]
+    return result

kikotools/tools/batch_list_converter/node.py

@@ -0,0 +1,130 @@
+"""Batch/List conversion nodes for ComfyUI."""
+
+from typing import Dict, List, Tuple
+
+import torch
+
+from ...base.base_node import ComfyAssetsBaseNode
+from .logic import (
+    split_image_batch,
+    join_image_batch,
+    split_latent_batch,
+    join_latent_batch,
+)
+
+
+class ImageBatchToImageListNode(ComfyAssetsBaseNode):
+    """Split an IMAGE batch [B,H,W,C] into a list of individual images."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT")
+    RETURN_NAMES = ("images", "count")
+    OUTPUT_IS_LIST = (True, False)
+    FUNCTION = "split_batch"
+    CATEGORY = "🫶 ComfyAssets/📦 Latents"
+
+    def split_batch(self, images: torch.Tensor) -> Tuple[List[torch.Tensor], int]:
+        image_list = split_image_batch(images)
+        count = len(image_list)
+        self.log_info(f"Split image batch of {count} into list")
+        return (image_list, count)
+
+
+class ImageListToImageBatchNode(ComfyAssetsBaseNode):
+    """Join a list of IMAGE tensors into a single batched IMAGE [B,H,W,C]."""
+
+    INPUT_IS_LIST = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT")
+    RETURN_NAMES = ("images", "count")
+    FUNCTION = "join_batch"
+    CATEGORY = "🫶 ComfyAssets/📦 Latents"
+
+    def join_batch(self, images: List[torch.Tensor]) -> Tuple[torch.Tensor, int]:
+        batch = join_image_batch(images)
+        count = batch.shape[0]
+        self.log_info(f"Joined {count} images into batch")
+        return (batch, count)
+
+
+class LatentBatchToLatentListNode(ComfyAssetsBaseNode):
+    """Split a LATENT batch into a list of individual latent dicts."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "latent": ("LATENT",),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT", "INT")
+    RETURN_NAMES = ("latents", "count")
+    OUTPUT_IS_LIST = (True, False)
+    FUNCTION = "split_batch"
+    CATEGORY = "🫶 ComfyAssets/📦 Latents"
+
+    def split_batch(
+        self, latent: Dict[str, torch.Tensor]
+    ) -> Tuple[List[Dict[str, torch.Tensor]], int]:
+        latent_list = split_latent_batch(latent)
+        count = len(latent_list)
+        self.log_info(f"Split latent batch of {count} into list")
+        return (latent_list, count)
+
+
+class LatentListToLatentBatchNode(ComfyAssetsBaseNode):
+    """Join a list of LATENT dicts into a single batched LATENT."""
+
+    INPUT_IS_LIST = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "latents": ("LATENT",),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT", "INT")
+    RETURN_NAMES = ("latent", "count")
+    FUNCTION = "join_batch"
+    CATEGORY = "🫶 ComfyAssets/📦 Latents"
+
+    def join_batch(
+        self, latents: List[Dict[str, torch.Tensor]]
+    ) -> Tuple[Dict[str, torch.Tensor], int]:
+        batch = join_latent_batch(latents)
+        count = batch["samples"].shape[0]
+        self.log_info(f"Joined {count} latents into batch")
+        return (batch, count)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ImageBatchToImageList": ImageBatchToImageListNode,
+    "ImageListToImageBatch": ImageListToImageBatchNode,
+    "LatentBatchToLatentList": LatentBatchToLatentListNode,
+    "LatentListToLatentBatch": LatentListToLatentBatchNode,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ImageBatchToImageList": "Image Batch to Image List",
+    "ImageListToImageBatch": "Image List to Image Batch",
+    "LatentBatchToLatentList": "Latent Batch to Latent List",
+    "LatentListToLatentBatch": "Latent List to Latent Batch",
+}

kikotools/tools/batch_prompts/node_simple.py

@@ -1,72 +0,0 @@
-"""Simple Batch Prompts node for ComfyUI - debugging version."""
-
-import os
-from typing import Tuple
-from ...base.base_node import ComfyAssetsBaseNode
-from .logic import (
-    load_prompts_from_file,
-    get_prompt_at_index,
-    split_prompt_into_positive_negative,
-)
-
-# Global counter that persists across all executions
-GLOBAL_COUNTER = {"count": 0}
-
-
-class SimpleBatchPromptsNode(ComfyAssetsBaseNode):
-    """
-    Simplified Batch Prompts node for debugging.
-    Uses a global counter to ensure prompts change.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        """Define the input types for the ComfyUI node."""
-        return {
-            "required": {
-                "prompt_file": ("STRING", {"default": "prompts.txt"}),
-            }
-        }
-
-    RETURN_TYPES = ("STRING", "STRING", "INT")
-    RETURN_NAMES = ("positive", "negative", "index")
-    FUNCTION = "get_next_prompt"
-    CATEGORY = "🫶 ComfyAssets/📝 Text"
-
-    @classmethod
-    def IS_CHANGED(cls, **kwargs):
-        """Force re-execution every time."""
-        GLOBAL_COUNTER["count"] += 1
-        return GLOBAL_COUNTER["count"]
-
-    def get_next_prompt(self, prompt_file: str) -> Tuple[str, str, int]:
-        """Get the next prompt in sequence."""
-        # Resolve file path
-        if not os.path.isabs(prompt_file):
-            try:
-                import folder_paths
-
-                input_dir = folder_paths.get_input_directory()
-                full_path = os.path.join(input_dir, prompt_file)
-            except ImportError:
-                full_path = os.path.abspath(prompt_file)
-        else:
-            full_path = prompt_file
-
-        # Load prompts
-        prompts = load_prompts_from_file(full_path)
-        if not prompts:
-            return ("No prompts found", "", 0)
-
-        # Get current prompt based on global counter
-        index = GLOBAL_COUNTER["count"] % len(prompts)
-        current_prompt, _ = get_prompt_at_index(prompts, index, wrap=True)
-
-        # Split positive/negative
-        positive, negative = split_prompt_into_positive_negative(current_prompt)
-
-        print(
-            f"[SimpleBatchPrompts] Counter={GLOBAL_COUNTER['count']}, Index={index}, Prompt={positive[:30]}..."
-        )
-
-        return (positive, negative, index)

kikotools/tools/batch_prompts/state_manager.py

@@ -19,7 +19,7 @@ class StateManager:
         """Load state from file."""
         if self.state_file.exists():
             try:
-                with open(self.state_file, "r") as f:
+                with open(self.state_file, "r", encoding="utf-8") as f:
                     return json.load(f)
             except (json.JSONDecodeError, IOError):
                 pass
@@ -28,7 +28,7 @@ class StateManager:
     def save_state(self, state: Dict[str, Any]):
         """Save state to file."""
         try:
-            with open(self.state_file, "w") as f:
+            with open(self.state_file, "w", encoding="utf-8") as f:
                 json.dump(state, f)
         except Exception as e:
             print(f"[BatchPrompts] Failed to save state: {e}")

kikotools/tools/checkpoint_folder_iterator/__init__.py

@@ -0,0 +1,5 @@
+"""Checkpoint Folder Iterator module."""
+
+from .node import CheckpointFolderIteratorNode
+
+__all__ = ["CheckpointFolderIteratorNode"]

kikotools/tools/checkpoint_folder_iterator/logic.py

@@ -0,0 +1,52 @@
+"""Logic for the Checkpoint Folder Iterator node."""
+
+import os
+from typing import List, Sequence, Tuple, TypeVar
+
+from ...base.model_folders import filter_by_pattern, scan_model_entries
+
+T = TypeVar("T")
+
+
+def list_checkpoint_entries(
+    folder_path: str, include_pattern: str = "", exclude_pattern: str = ""
+) -> List[Tuple[str, str]]:
+    """(name, absolute_path) pairs for every checkpoint, filtered, in natural order.
+
+    The absolute path is what gets loaded, so folders outside the configured
+    checkpoints roots work too; the name is relative to the root (or to the
+    folder itself when it lives outside every root) and is used for labels.
+    """
+    entries = scan_model_entries(folder_path, "checkpoints")
+    names = [name for name, _ in entries]
+    kept = set(filter_by_pattern(names, include_pattern, exclude_pattern))
+    return [(name, path) for name, path in entries if name in kept]
+
+
+def list_checkpoints(
+    folder_path: str, include_pattern: str = "", exclude_pattern: str = ""
+) -> List[str]:
+    """Checkpoint names (relative to the checkpoints roots) in natural order."""
+    entries = list_checkpoint_entries(folder_path, include_pattern, exclude_pattern)
+    return [name for name, _ in entries]
+
+
+def pick_checkpoint(items: Sequence[T], index: int) -> T:
+    """Return items[index], or raise when the sweep has run past the end.
+
+    Wrapping would silently restart the sweep (and, downstream, archive the
+    grid that just finished), so an over-queued run fails loudly instead.
+    """
+    if not items:
+        raise ValueError("No checkpoints found")
+    if not 0 <= index < len(items):
+        raise ValueError(
+            f"Index {index} is past the end: only {len(items)} checkpoints matched. "
+            "The sweep is complete; reset index to 0 to start a new one."
+        )
+    return items[index]
+
+
+def label_for(ckpt_name: str) -> str:
+    """Label drawn under a tile for this checkpoint. Default: the file stem."""
+    return os.path.splitext(os.path.basename(ckpt_name))[0]

kikotools/tools/checkpoint_folder_iterator/node.py

@@ -0,0 +1,80 @@
+"""Checkpoint Folder Iterator node for ComfyUI."""
+
+from typing import Tuple
+
+from ...base.base_node import ComfyAssetsBaseNode
+from .logic import label_for, list_checkpoint_entries, pick_checkpoint
+
+
+class CheckpointFolderIteratorNode(ComfyAssetsBaseNode):
+    """
+    Load one checkpoint from a folder per queued run.
+
+    Set index to 0 with "increment" and queue as many runs as there are
+    checkpoints: each run loads the next file, so only one model is in
+    memory at a time. A run past the last checkpoint fails with a clear
+    error rather than wrapping around, so over-queuing never restarts the
+    sweep. Pairs with Model Compare Sheet to build a labeled grid.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "folder": (
+                    "STRING",
+                    {
+                        "default": ".",
+                        "multiline": False,
+                        "tooltip": "Folder relative to models/checkpoints (or absolute)",
+                    },
+                ),
+                "index": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 9999,
+                        "control_after_generate": True,
+                        "tooltip": "Which checkpoint to load; errors past the end",
+                    },
+                ),
+            },
+            "optional": {
+                "include_pattern": (
+                    "STRING",
+                    {"default": "", "tooltip": "Regex to include (empty = all)"},
+                ),
+                "exclude_pattern": (
+                    "STRING",
+                    {"default": "", "tooltip": "Regex to exclude (empty = none)"},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP", "VAE", "STRING", "STRING", "INT", "INT")
+    RETURN_NAMES = ("model", "clip", "vae", "ckpt_name", "label", "index", "count")
+    FUNCTION = "load"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
+
+    def load(
+        self,
+        folder: str,
+        index: int,
+        include_pattern: str = "",
+        exclude_pattern: str = "",
+    ) -> Tuple[object, object, object, str, str, int, int]:
+        import folder_paths
+        import comfy.sd
+
+        entries = list_checkpoint_entries(folder, include_pattern, exclude_pattern)
+        ckpt_name, ckpt_path = pick_checkpoint(entries, index)
+        self.log_info(f"Loading {index + 1}/{len(entries)}: {ckpt_name}")
+
+        model, clip, vae = comfy.sd.load_checkpoint_guess_config(
+            ckpt_path,
+            output_vae=True,
+            output_clip=True,
+            embedding_directory=folder_paths.get_folder_paths("embeddings"),
+        )[:3]
+        return model, clip, vae, ckpt_name, label_for(ckpt_name), index, len(entries)

kikotools/tools/empty_latent_batch/node.py

@@ -93,14 +93,14 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
             }
         }
 
-    RETURN_TYPES = ("LATENT", "INT", "INT")
-    RETURN_NAMES = ("latent", "width", "height")
+    RETURN_TYPES = ("LATENT", "INT", "INT", "INT")
+    RETURN_NAMES = ("latent", "width", "height", "batch_size")
     FUNCTION = "create_empty_latent"
     CATEGORY = "🫶 ComfyAssets/📦 Latents"
 
     def create_empty_latent(
         self, preset: str, width: int, height: int, batch_size: int
-    ) -> Tuple[Dict[str, torch.Tensor], int, int]:
+    ) -> Tuple[Dict[str, torch.Tensor], int, int, int]:
         """
         Create empty latent tensor with specified dimensions and batch size.
 
@@ -111,7 +111,7 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
             batch_size: Number of latents in the batch
 
         Returns:
-            Tuple containing (latent dictionary with 'samples' tensor, width, height)
+            Tuple containing (latent dict, width, height, batch_size)
         """
         try:
             # Extract original preset name from formatted string if needed
@@ -160,7 +160,7 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
                 f"(pixel dims: {final_width}×{final_height})"
             )
 
-            return (latent_dict, final_width, final_height)
+            return (latent_dict, final_width, final_height, batch_size)
 
         except Exception as e:
             # Handle any unexpected errors gracefully

kikotools/tools/gemini_prompt/.gemini_models_cache.json

@@ -1,89 +0,0 @@
-{
-  "models": [
-    "gemini-2.5-pro",
-    "gemini-2.5-flash",
-    "gemini-2.5-flash-lite",
-    "gemini-2.5-pro-preview-03-25",
-    "gemini-2.5-flash-preview-05-20",
-    "gemini-2.5-pro-preview-05-06",
-    "gemini-2.5-pro-preview-06-05",
-    "gemini-2.5-flash-lite-preview-06-17",
-    "gemini-2.0-flash",
-    "gemini-2.0-flash-001",
-    "gemini-2.0-flash-lite-001",
-    "gemini-2.0-flash-lite",
-    "gemini-2.5-flash-preview-tts",
-    "gemini-2.5-pro-preview-tts",
-    "gemini-2.0-flash-preview-image-generation",
-    "gemini-2.0-flash-exp",
-    "gemini-2.0-flash-exp-image-generation",
-    "gemini-2.0-flash-lite-preview-02-05",
-    "gemini-2.0-flash-lite-preview",
-    "gemini-2.0-pro-exp",
-    "gemini-2.0-pro-exp-02-05",
-    "learnlm-2.0-flash-experimental",
-    "gemini-1.5-pro-latest",
-    "gemini-1.5-pro-002",
-    "gemini-1.5-pro",
-    "gemini-1.5-flash-latest",
-    "gemini-1.5-flash",
-    "gemini-1.5-flash-002",
-    "gemini-1.5-flash-8b",
-    "gemini-1.5-flash-8b-001",
-    "gemini-1.5-flash-8b-latest",
-    "gemini-2.0-flash-thinking-exp-01-21",
-    "gemini-2.0-flash-thinking-exp",
-    "gemini-2.0-flash-thinking-exp-1219",
-    "gemma-3-1b-it",
-    "gemma-3-4b-it",
-    "gemma-3-12b-it",
-    "gemma-3-27b-it",
-    "gemma-3n-e4b-it",
-    "gemma-3n-e2b-it",
-    "gemini-exp-1206"
-  ],
-  "descriptions": {
-    "gemini-1.5-pro-latest": "Gemini 1.5 Pro Latest",
-    "gemini-1.5-pro-002": "Gemini 1.5 Pro 002",
-    "gemini-1.5-pro": "Gemini 1.5 Pro",
-    "gemini-1.5-flash-latest": "Gemini 1.5 Flash Latest",
-    "gemini-1.5-flash": "Gemini 1.5 Flash",
-    "gemini-1.5-flash-002": "Gemini 1.5 Flash 002",
-    "gemini-1.5-flash-8b": "Gemini 1.5 Flash-8B",
-    "gemini-1.5-flash-8b-001": "Gemini 1.5 Flash-8B 001",
-    "gemini-1.5-flash-8b-latest": "Gemini 1.5 Flash-8B Latest",
-    "gemini-2.5-pro-preview-03-25": "Gemini 2.5 Pro Preview 03-25",
-    "gemini-2.5-flash-preview-05-20": "Gemini 2.5 Flash Preview 05-20",
-    "gemini-2.5-flash": "Gemini 2.5 Flash",
-    "gemini-2.5-flash-lite-preview-06-17": "Gemini 2.5 Flash-Lite Preview 06-17",
-    "gemini-2.5-pro-preview-05-06": "Gemini 2.5 Pro Preview 05-06",
-    "gemini-2.5-pro-preview-06-05": "Gemini 2.5 Pro Preview",
-    "gemini-2.5-pro": "Gemini 2.5 Pro",
-    "gemini-2.0-flash-exp": "Gemini 2.0 Flash Experimental",
-    "gemini-2.0-flash": "Gemini 2.0 Flash",
-    "gemini-2.0-flash-001": "Gemini 2.0 Flash 001",
-    "gemini-2.0-flash-exp-image-generation": "Gemini 2.0 Flash (Image Generation) Experimental",
-    "gemini-2.0-flash-lite-001": "Gemini 2.0 Flash-Lite 001",
-    "gemini-2.0-flash-lite": "Gemini 2.0 Flash-Lite",
-    "gemini-2.0-flash-preview-image-generation": "Gemini 2.0 Flash Preview Image Generation",
-    "gemini-2.0-flash-lite-preview-02-05": "Gemini 2.0 Flash-Lite Preview 02-05",
-    "gemini-2.0-flash-lite-preview": "Gemini 2.0 Flash-Lite Preview",
-    "gemini-2.0-pro-exp": "Gemini 2.0 Pro Experimental",
-    "gemini-2.0-pro-exp-02-05": "Gemini 2.0 Pro Experimental 02-05",
-    "gemini-exp-1206": "Gemini Experimental 1206",
-    "gemini-2.0-flash-thinking-exp-01-21": "Gemini 2.5 Flash Preview 05-20",
-    "gemini-2.0-flash-thinking-exp": "Gemini 2.5 Flash Preview 05-20",
-    "gemini-2.0-flash-thinking-exp-1219": "Gemini 2.5 Flash Preview 05-20",
-    "gemini-2.5-flash-preview-tts": "Gemini 2.5 Flash Preview TTS",
-    "gemini-2.5-pro-preview-tts": "Gemini 2.5 Pro Preview TTS",
-    "learnlm-2.0-flash-experimental": "LearnLM 2.0 Flash Experimental",
-    "gemma-3-1b-it": "Gemma 3 1B",
-    "gemma-3-4b-it": "Gemma 3 4B",
-    "gemma-3-12b-it": "Gemma 3 12B",
-    "gemma-3-27b-it": "Gemma 3 27B",
-    "gemma-3n-e4b-it": "Gemma 3n E4B",
-    "gemma-3n-e2b-it": "Gemma 3n E2B",
-    "gemini-2.5-flash-lite": "Gemini 2.5 Flash-Lite"
-  },
-  "timestamp": 1754568195.1098156
-}

kikotools/tools/gemini_prompt/logic.py

@@ -30,7 +30,7 @@ def tensor_to_pil(tensor: np.ndarray) -> Image.Image:
     image_array = (tensor * 255).astype(np.uint8)
 
     # Convert to PIL
-    return Image.fromarray(image_array, mode="RGB")
+    return Image.fromarray(image_array)
 
 
 def image_to_base64(image: Image.Image, format: str = "PNG") -> str:
@@ -65,7 +65,7 @@ def get_api_key() -> Optional[str]:
                 os.path.dirname(__file__), "..", "..", "..", "gemini_config.json"
             )
             if os.path.exists(config_path):
-                with open(config_path, "r") as f:
+                with open(config_path, "r", encoding="utf-8") as f:
                     config = json.load(f)
                     api_key = config.get("api_key")
         except Exception:
@@ -115,30 +115,24 @@ def analyze_image_with_gemini(
     else:
         system_prompt = PROMPT_TEMPLATES.get(prompt_type, PROMPT_TEMPLATES["flux"])
 
-    # Here we would normally make the API call to Gemini
-    # For now, we'll import the google-generativeai library
     try:
-        import google.generativeai as genai
+        from google import genai
     except ImportError:
         return (
             "",
-            "google-generativeai library not installed. Please run: pip install google-generativeai",
+            "google-genai library not installed. Please run: pip install google-genai",
         )
 
     try:
-        # Configure Gemini
-        genai.configure(api_key=api_key)
+        client = genai.Client(api_key=api_key)
 
-        # Create model
-        model = genai.GenerativeModel(model_name)
-
-        # Generate content
-        response = model.generate_content(
-            [
+        response = client.models.generate_content(
+            model=model_name,
+            contents=[
                 system_prompt,
                 pil_image,
                 "Analyze this image and generate an appropriate prompt according to the instructions.",
-            ]
+            ],
         )
 
         # Extract text from response

kikotools/tools/gemini_prompt/models.py

@@ -59,10 +59,10 @@ def _fetch_models_from_api(
         Tuple of (model_names_list, model_descriptions_dict)
     """
     try:
-        import google.generativeai as genai
+        from google import genai
     except ImportError:
         if not silent:
-            logger.error("google-generativeai not installed")
+            logger.error("google-genai not installed")
         return [], {}
 
     # Get API key
@@ -77,15 +77,15 @@ def _fetch_models_from_api(
         return [], {}
 
     try:
-        genai.configure(api_key=api_key)
+        client = genai.Client(api_key=api_key)
 
         models = []
         descriptions = {}
 
         # Fetch all models
-        for model in genai.list_models():
+        for model in client.models.list():
             # Only include models that support generateContent
-            if "generateContent" in model.supported_generation_methods:
+            if "generateContent" in (model.supported_actions or []):
                 # Remove "models/" prefix from name
                 model_name = model.name.replace("models/", "")
                 models.append(model_name)
@@ -154,7 +154,7 @@ def _load_cache() -> Optional[Dict]:
         return None
 
     try:
-        with open(CACHE_FILE, "r") as f:
+        with open(CACHE_FILE, "r", encoding="utf-8") as f:
             data = json.load(f)
 
         # Check if cache is expired
@@ -176,7 +176,7 @@ def _save_cache(models: List[str], descriptions: Dict[str, str]) -> None:
             "timestamp": time.time(),
         }
 
-        with open(CACHE_FILE, "w") as f:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
     except Exception as e:
         logger.warning(f"Failed to save cache: {e}")

kikotools/tools/gemini_prompt/node.py

@@ -63,7 +63,7 @@ Supports multiple prompt formats:
 - Video: Motion and temporal descriptions for video generation
 
 Requires Gemini API key (set GEMINI_API_KEY env var or provide in node).
-Install: pip install google-generativeai
+Install: pip install google-genai
 """
 
     def generate_prompt(

kikotools/tools/kiko_film_grain/logic.py

@@ -100,13 +100,15 @@ def generate_grain_texture(
     Returns:
         Grain texture tensor of shape [B, H/scale, W/scale, 3]
     """
-    torch.manual_seed(seed)
+    # Local generator: never touch the global RNG state
+    generator = torch.Generator()
+    generator.manual_seed(int(seed))
 
     grain_height = max(1, int(height / scale))
     grain_width = max(1, int(width / scale))
 
     # Generate random noise
-    grain = torch.rand(batch_size, grain_height, grain_width, 3)
+    grain = torch.rand(batch_size, grain_height, grain_width, 3, generator=generator)
 
     return grain
 
@@ -140,7 +142,8 @@ def apply_film_grain(
     Returns:
         Image with film grain applied
     """
-    if strength == 0.0:
+    # Only short-circuit when nothing at all would change (toe still applies)
+    if strength == 0.0 and toe == 0.0:
         return image
 
     # Handle empty batch

kikotools/tools/kiko_film_grain/node.py

@@ -75,7 +75,7 @@ class KikoFilmGrainNode(ComfyAssetsBaseNode):
                     {
                         "default": 0,
                         "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
+                        "max": 0xFFFFFFFF,  # 2**32 - 1
                         "description": "Random seed for grain pattern generation",
                     },
                 ),

kikotools/tools/kiko_purge_vram/node.py

@@ -55,6 +55,11 @@ class KikoPurgeVRAM(BaseNode):
     OUTPUT_NODE = True
     DESCRIPTION = "Purge VRAM to free up GPU memory during workflow execution. Passes through any input unchanged."
 
+    @classmethod
+    def IS_CHANGED(cls, *args: Any, **kwargs: Any) -> float:
+        """Always re-run: a purge must never be skipped by ComfyUI caching."""
+        return float("nan")
+
     def purge_vram(
         self,
         anything: Any,

kikotools/tools/kiko_save_image/logic.py

@@ -10,7 +10,6 @@ from PIL import Image
 from PIL.PngImagePlugin import PngInfo
 import torch
 from typing import Dict, List, Any, Optional, Tuple
-import time
 
 try:
     import folder_paths
@@ -22,9 +21,70 @@ except ImportError:
             return "./output"
 
 
+def get_next_counter(output_dir: str, prefix: str) -> int:
+    """
+    Get next available counter value from persistent counter file
+
+    This prevents file overwrites when the node is called multiple times
+    within the same second by maintaining a persistent counter.
+
+    Args:
+        output_dir: Directory to store counter file
+        prefix: Filename prefix to create unique counter per prefix
+
+    Returns:
+        Next available counter value
+    """
+    # Create a safe counter filename
+    safe_prefix = "".join(c for c in prefix if c.isalnum() or c in "._-")
+    counter_file = os.path.join(output_dir, f".{safe_prefix}_counter.txt")
+
+    # Read current counter
+    counter = 0
+    if os.path.exists(counter_file):
+        try:
+            with open(counter_file, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+                counter = int(content) if content else 0
+        except (ValueError, IOError):
+            # If file is corrupted or unreadable, start from 0
+            counter = 0
+
+    # Increment counter
+    counter += 1
+
+    # Save updated counter
+    try:
+        with open(counter_file, "w", encoding="utf-8") as f:
+            f.write(str(counter))
+    except IOError:
+        # If we can't write the counter file, continue anyway
+        # Better to risk overwrites than to fail completely
+        pass
+
+    return counter
+
+
+def _ensure_inside_output_dir(
+    folder: str, output_dir: str, prefix_dir: str, subfolder: str
+) -> None:
+    """Raise ValueError unless folder resolves to a location inside output_dir."""
+    real_root = os.path.realpath(output_dir)
+    real_folder = os.path.realpath(folder)
+    try:
+        inside = os.path.commonpath([real_root, real_folder]) == real_root
+    except ValueError:  # e.g. different drives on Windows
+        inside = False
+    if not inside:
+        raise ValueError(
+            "Resolved output folder is outside the output directory "
+            f"(prefix directory {prefix_dir!r}, subfolder {subfolder!r})"
+        )
+
+
 def get_save_image_path(
     filename_prefix: str,
-    batch_number: int,
+    counter: int,
     format_ext: str,
     output_dir: str,
     subfolder: str = "",
@@ -34,16 +94,21 @@ def get_save_image_path(
 
     Args:
         filename_prefix: Base filename prefix
-        batch_number: Batch index for multiple images
+        counter: Persistent counter to ensure unique filenames
         format_ext: File extension (.png, .jpg, .webp)
         output_dir: Output directory path
         subfolder: Optional subfolder within output directory
 
     Returns:
-        Tuple of (full_path, relative_filename)
+        Tuple of (full_path, preview_filename, relative_subfolder)
     """
     # Split filename_prefix into directory path and actual filename prefix
     # This allows for directory structures like "kittybear/anime/images/kittybear"
+    if os.path.isabs(filename_prefix) or os.path.isabs(subfolder or ""):
+        raise ValueError(
+            "Absolute paths are not allowed in filename_prefix or subfolder: "
+            f"{filename_prefix!r}"
+        )
     prefix_dir = os.path.dirname(filename_prefix)
     prefix_name = os.path.basename(filename_prefix)
 
@@ -53,9 +118,10 @@ def get_save_image_path(
     )  # Only sanitize problematic chars for filenames
     safe_prefix = "".join(c for c in safe_prefix if c.isalnum() or c in "._-")
 
-    # Create unique filename with timestamp to avoid conflicts
-    timestamp = int(time.time())
-    filename = f"{safe_prefix}_{timestamp:010d}_{batch_number:05d}{format_ext}"
+    # Create unique filename with counter to avoid conflicts
+    # Using counter instead of timestamp+batch_number prevents overwrites
+    # when multiple images are processed separately
+    filename = f"{safe_prefix}_{counter:05d}{format_ext}"
 
     # Handle subfolder and prefix directory (but not the filename part)
     path_components = []
@@ -70,6 +136,9 @@ def get_save_image_path(
 
     full_output_folder = os.path.join(*path_components)
 
+    # Reject anything that would resolve outside the output directory
+    _ensure_inside_output_dir(full_output_folder, output_dir, prefix_dir, subfolder)
+
     # Ensure directory exists
     os.makedirs(full_output_folder, exist_ok=True)
 
@@ -221,7 +290,7 @@ def process_image_batch(
     popup: bool = True,
     prompt: Optional[Dict] = None,
     extra_pnginfo: Optional[Dict] = None,
-) -> List[Dict[str, Any]]:
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
     """
     Process and save a batch of images with specified format settings
 
@@ -237,7 +306,7 @@ def process_image_batch(
         extra_pnginfo: Additional PNG metadata
 
     Returns:
-        List of saved image information dicts
+        Tuple of (ComfyUI preview result dicts, enhanced info dicts)
     """
     # Get output directory
     output_dir = folder_paths.get_output_directory()
@@ -262,13 +331,17 @@ def process_image_batch(
     results = []
     enhanced_data = []
 
-    for batch_number, image_tensor in enumerate(images):
+    for image_tensor in images:
         # Convert tensor to PIL Image
         img = convert_tensor_to_pil(image_tensor)
 
-        # Generate save path
+        # Get next counter value to ensure unique filenames
+        # This counter persists across node calls, preventing overwrites
+        counter = get_next_counter(output_dir, filename_prefix)
+
+        # Generate save path with persistent counter
         filepath, preview_filename, relative_subfolder = get_save_image_path(
-            filename_prefix, batch_number, format_ext, output_dir, ""
+            filename_prefix, counter, format_ext, output_dir, ""
         )
 
         # Save with format-specific settings

kikotools/tools/kiko_workflow_timer/__init__.py

@@ -0,0 +1,10 @@
+"""
+KikoWorkflow Timer - Display real-time execution timer for ComfyUI workflows.
+
+Provides a visual timer that tracks workflow execution duration with
+millisecond precision.
+"""
+
+from .node import KikoWorkflowTimerNode
+
+__all__ = ["KikoWorkflowTimerNode"]

kikotools/tools/kiko_workflow_timer/node.py

@@ -0,0 +1,52 @@
+"""
+KikoWorkflow Timer Node
+
+A display-only node that shows real-time execution timing for ComfyUI workflows.
+The timer is managed entirely on the frontend via WebSocket events.
+"""
+
+from ...base import ComfyAssetsBaseNode
+
+
+class KikoWorkflowTimerNode(ComfyAssetsBaseNode):
+    """
+    A UI node that displays a real-time timer for workflow execution.
+
+    The timer starts when execution begins and stops when the workflow
+    completes, showing the total elapsed time in MM:SS:mmm format.
+
+    This is a display-only node with no inputs or outputs - all timing
+    logic is handled by the JavaScript frontend via WebSocket events.
+    """
+
+    DISPLAY_NAME = "Workflow Timer"
+    CATEGORY = "🫶 ComfyAssets/🛠️ Utils"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {},
+            "hidden": {
+                "prompt": "PROMPT",
+                "unique_id": "UNIQUE_ID",
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "execute"
+    OUTPUT_NODE = True
+
+    def execute(self, **kwargs):
+        """
+        Execute method - returns empty since this is a display-only node.
+
+        The actual timer functionality is handled entirely by the JavaScript
+        frontend which hooks into ComfyUI's WebSocket events.
+
+        Args:
+            **kwargs: Hidden parameters (prompt, unique_id)
+
+        Returns:
+            Empty dict - no outputs
+        """
+        return {}

kikotools/tools/local_image_loader/config.json

@@ -1,7 +0,0 @@
-{
-    "last_path": "/home/vito/ai-apps/ComfyUI-3.12/output",
-    "saved_paths": [
-        "/home/vito/ai-apps/ComfyUI-3.12/output/2025-05-01",
-        "/home/vito/ai-apps/ComfyUI-3.12/output/"
-    ]
-}

kikotools/tools/local_image_loader/logic.py

@@ -5,7 +5,7 @@ import json
 import torch
 import numpy as np
 from PIL import Image
-from typing import Tuple, Dict, Any, List
+from typing import Tuple, Dict, Any, List, Optional, Iterable
 
 
 def get_supported_extensions() -> Dict[str, List[str]]:
@@ -17,6 +17,108 @@ def get_supported_extensions() -> Dict[str, List[str]]:
     }
 
 
+def resolve_path(path: Any) -> Optional[str]:
+    """Resolve a user supplied path with realpath (symlinks and ``..``).
+
+    Returns None for anything that is not a usable non-empty string.
+    """
+    if not isinstance(path, str) or not path or "\0" in path:
+        return None
+    return os.path.realpath(path)
+
+
+def is_within_roots(path: Any, roots: Iterable[Any]) -> bool:
+    """Return True if the resolved path is inside (or equal to) one of the roots.
+
+    Uses os.path.commonpath on realpath-resolved values, so sibling
+    directories sharing a string prefix, ``..`` and symlinks cannot escape.
+    """
+    real = resolve_path(path)
+    if real is None:
+        return False
+    for root in roots:
+        real_root = resolve_path(root)
+        if real_root is None:
+            continue
+        try:
+            if os.path.commonpath([real, real_root]) == real_root:
+                return True
+        except ValueError:  # different drives / mixed absolute and relative
+            continue
+    return False
+
+
+def is_too_broad_root(path: Any, home: Optional[str] = None) -> bool:
+    """Return True if path is unusable or too broad to be a saved root.
+
+    Refuses filesystem/drive roots, the home directory itself and any
+    ancestor of it (e.g. /home), since those would expose every media file
+    a user owns. Folders inside home are fine.
+    """
+    real = resolve_path(path)
+    if real is None:
+        return True
+    if os.path.dirname(real) == real:  # "/" or a drive root like "C:\\"
+        return True
+    real_home = os.path.realpath(home or os.path.expanduser("~"))
+    try:
+        return os.path.commonpath([real, real_home]) == real
+    except ValueError:  # different drives
+        return False
+
+
+def is_allowed_media_path(
+    path: Any, roots: Iterable[Any], kinds: Iterable[str] = ("image",)
+) -> bool:
+    """Return True if path is a media file of the given kinds inside a root.
+
+    ``kinds`` are keys of get_supported_extensions() (image/video/audio).
+    The extension is checked on the resolved path so a symlink named
+    ``x.png`` pointing at a non-media file is refused.
+    """
+    real = resolve_path(path)
+    if real is None:
+        return False
+    extensions = get_supported_extensions()
+    allowed = {e for k in kinds for e in extensions.get(k, [])}
+    if os.path.splitext(real)[1].lower() not in allowed:
+        return False
+    return is_within_roots(real, roots)
+
+
+def is_allowed_image_path(path: Any, roots: Iterable[Any]) -> bool:
+    """Return True if path is an image file located inside one of the roots."""
+    return is_allowed_media_path(path, roots, ("image",))
+
+
+def list_subdirectories(path: str, limit: int = 50) -> List[str]:
+    """List sub-directory paths (never files) for the folder picker.
+
+    If ``path`` ends with a separator, its child directories are returned;
+    otherwise sibling directories whose name starts with the last component.
+    May raise PermissionError.
+    """
+    if path.endswith(os.sep) or (os.name == "nt" and path.endswith("/")):
+        parent_dir, prefix = path, ""
+    else:
+        parent_dir = os.path.dirname(path)
+        prefix = os.path.basename(path).lower()
+        if not parent_dir:
+            return []
+
+    if not os.path.isdir(parent_dir):
+        return []
+
+    dirs = [
+        os.path.join(parent_dir, entry)
+        for entry in os.listdir(parent_dir)
+        if entry.lower().startswith(prefix)
+        and os.path.isdir(os.path.join(parent_dir, entry))
+    ]
+    dirs.sort(key=lambda x: x.lower())
+    return dirs[:limit]
+
+
 def load_image_from_path(path: str) -> Tuple[torch.Tensor, Dict[str, Any]]:
     """
     Load an image from the given path and convert it to a tensor.
@@ -73,6 +175,7 @@ def scan_directory(
     show_audio: bool = False,
     sort_by: str = "name",
     sort_order: str = "asc",
+    hide_dot_folders: bool = True,
 ) -> List[Dict[str, Any]]:
     """
     Scan a directory for supported media files.
@@ -83,6 +186,7 @@ def scan_directory(
         show_audio: Include audio files
         sort_by: Sort criteria ('name', 'date', 'size')
         sort_order: Sort order ('asc', 'desc')
+        hide_dot_folders: Hide folders starting with a dot
 
     Returns:
         List of file information dictionaries
@@ -94,6 +198,10 @@ def scan_directory(
     items = []
 
     for item in os.listdir(directory):
+        # Skip dot folders/files if hide_dot_folders is enabled
+        if hide_dot_folders and item.startswith("."):
+            continue
+
         full_path = os.path.join(directory, item)
 
         try:
@@ -139,6 +247,98 @@ def scan_directory(
     return items
 
 
+def search_files(
+    root_directory: str,
+    query: str,
+    show_videos: bool = False,
+    show_audio: bool = False,
+    max_results: int = 100,
+) -> List[Dict[str, Any]]:
+    """
+    Recursively search for files matching the query.
+
+    Args:
+        root_directory: Root directory to start search
+        query: Search query (case-insensitive filename match)
+        show_videos: Include video files
+        show_audio: Include audio files
+        max_results: Maximum number of results to return
+
+    Returns:
+        List of file information dictionaries
+    """
+    if not os.path.isdir(root_directory):
+        raise NotADirectoryError(f"Not a directory: {root_directory}")
+
+    if not query or len(query.strip()) == 0:
+        return []
+
+    extensions = get_supported_extensions()
+    results = []
+    query_lower = query.lower().strip()
+
+    def search_recursive(directory: str) -> None:
+        """Recursively search directory."""
+        if len(results) >= max_results:
+            return
+
+        try:
+            items = os.listdir(directory)
+        except (PermissionError, FileNotFoundError):
+            return
+
+        for item in items:
+            if len(results) >= max_results:
+                break
+
+            full_path = os.path.join(directory, item)
+
+            try:
+                # Check if item name matches query
+                if query_lower not in item.lower():
+                    # If directory, search inside
+                    if os.path.isdir(full_path):
+                        search_recursive(full_path)
+                    continue
+
+                stats = os.stat(full_path)
+                item_data = {
+                    "path": full_path,
+                    "name": item,
+                    "directory": directory,
+                    "mtime": stats.st_mtime,
+                    "size": stats.st_size,
+                }
+
+                if os.path.isdir(full_path):
+                    results.append({**item_data, "type": "dir"})
+                    # Continue searching inside matching directories
+                    search_recursive(full_path)
+                else:
+                    ext = os.path.splitext(item)[1].lower()
+                    item_type = None
+
+                    if ext in extensions["image"]:
+                        item_type = "image"
+                    elif show_videos and ext in extensions["video"]:
+                        item_type = "video"
+                    elif show_audio and ext in extensions["audio"]:
+                        item_type = "audio"
+
+                    if item_type:
+                        results.append({**item_data, "type": item_type})
+
+            except (PermissionError, FileNotFoundError):
+                continue
+
+    search_recursive(root_directory)
+
+    # Sort by name
+    results.sort(key=lambda x: x["name"].lower())
+
+    return results
+
+
 def create_empty_tensor() -> torch.Tensor:
     """Create an empty tensor for when no image is selected."""
     return torch.zeros(1, 1, 1, 4)

kikotools/tools/local_image_loader/node.py

@@ -1,13 +1,37 @@
 """Local Image Loader node for ComfyUI."""
 
-import os
+import io
 import json
+import logging
+import os
+from typing import Any, Dict, List, Tuple
+
 import torch
-from typing import Dict, Any, Tuple
 
 from ...base.base_node import ComfyAssetsBaseNode
-from .logic import load_image_from_path, create_empty_tensor
+from .logic import (
+    create_empty_tensor,
+    is_allowed_image_path,
+    is_allowed_media_path,
+    is_too_broad_root,
+    is_within_roots,
+    list_subdirectories,
+    load_image_from_path,
+    resolve_path,
+    scan_directory,
+)
 
+try:
+    from aiohttp import web
+except ImportError:  # pragma: no cover - aiohttp ships with ComfyUI
+    web = None
+
+logger = logging.getLogger(__name__)
+
+MEDIA_KINDS = ("image", "video", "audio")
+MAX_PER_PAGE = 200
+DEFAULT_PER_PAGE = 50
+MAX_DIRECTORY_SUGGESTIONS = 50
 
 NODE_DIR = os.path.dirname(os.path.abspath(__file__))
 SELECTIONS_FILE = os.path.join(NODE_DIR, "selections.json")
@@ -31,7 +55,7 @@ def save_selections(data: Dict[str, Any]) -> None:
         with open(SELECTIONS_FILE, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=4, ensure_ascii=False)
     except Exception as e:
-        print(f"KikoLocalImageLoader: Error saving selections: {e}")
+        logger.error("Error saving selections: %s", e)
 
 
 def load_config() -> Dict[str, Any]:
@@ -51,7 +75,28 @@ def save_config(data: Dict[str, Any]) -> None:
         with open(CONFIG_FILE, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=4)
     except Exception as e:
-        print(f"KikoLocalImageLoader: Error saving config: {e}")
+        logger.error("Error saving config: %s", e)
+
+
+def get_allowed_roots() -> List[str]:
+    """Directories whose contents may be served: saved paths + ComfyUI in/out."""
+    roots: List[str] = []
+    saved = load_config().get("saved_paths", [])
+    if isinstance(saved, list):
+        # Skip broad roots saved before save_paths refused them
+        roots.extend(
+            p for p in saved if isinstance(p, str) and p and not is_too_broad_root(p)
+        )
+    try:
+        import folder_paths
+
+        for getter in ("get_input_directory", "get_output_directory"):
+            value = getattr(folder_paths, getter)()
+            if isinstance(value, str) and value:
+                roots.append(value)
+    except Exception:  # folder_paths missing or misbehaving outside ComfyUI
+        pass
+    return roots
 
 
 class LocalImageLoaderNode(ComfyAssetsBaseNode):
@@ -68,13 +113,9 @@ class LocalImageLoaderNode(ComfyAssetsBaseNode):
     RETURN_TYPES = (
         "IMAGE",
         "STRING",
-        "STRING",
-        "STRING",
     )
     RETURN_NAMES = (
         "image",
-        "video_path",
-        "audio_path",
         "info",
     )
     FUNCTION = "load_media"
@@ -87,7 +128,7 @@ class LocalImageLoaderNode(ComfyAssetsBaseNode):
             return os.path.getmtime(SELECTIONS_FILE)
         return float("inf")
 
-    def load_media(self, unique_id: str) -> Tuple[torch.Tensor, str, str, str]:
+    def load_media(self, unique_id: str) -> Tuple[torch.Tensor, str]:
         """
         Load selected media based on node's unique ID.
 
@@ -95,11 +136,9 @@ class LocalImageLoaderNode(ComfyAssetsBaseNode):
             unique_id: Unique identifier for this node instance
 
         Returns:
-            Tuple of (image tensor, video path, audio path, info string)
+            Tuple of (image tensor, info string)
         """
         image_tensor = create_empty_tensor()
-        video_path = ""
-        audio_path = ""
         info_string = ""
 
         selections = load_selections()
@@ -108,150 +147,223 @@ class LocalImageLoaderNode(ComfyAssetsBaseNode):
         # Load image if selected
         image_selection = node_selections.get("image")
         if image_selection and image_selection.get("path"):
-            image_path = image_selection["path"]
-            if os.path.exists(image_path):
+            # Load the resolved path we validated, so a symlink swapped after
+            # the check can't redirect the read.
+            image_path = resolve_path(image_selection["path"])
+            if not is_allowed_image_path(image_path, get_allowed_roots()):
+                # selections.json may have been tampered with
+                logger.warning("Refusing to load disallowed path: %s", image_path)
+            elif os.path.exists(image_path):
                 try:
                     image_tensor, metadata = load_image_from_path(image_path)
                     info_string = json.dumps(metadata, indent=4, ensure_ascii=False)
                 except Exception as e:
-                    print(f"KikoLocalImageLoader: Error loading image: {e}")
+                    logger.error("Error loading image: %s", e)
 
-        # Get video path if selected
-        video_selection = node_selections.get("video")
-        if video_selection and video_selection.get("path"):
-            if os.path.exists(video_selection["path"]):
-                video_path = video_selection["path"]
-
-        # Get audio path if selected
-        audio_selection = node_selections.get("audio")
-        if audio_selection and audio_selection.get("path"):
-            if os.path.exists(audio_selection["path"]):
-                audio_path = audio_selection["path"]
-
-        return (image_tensor, video_path, audio_path, info_string)
+        return (image_tensor, info_string)
 
 
-# Setup API routes
-try:
-    import server
-    from aiohttp import web
-    import urllib.parse
-    import io
-    from PIL import Image
-    from .logic import scan_directory
+# ---------------------------------------------------------------------------
+# API route handlers (module level so they can be tested without a server)
+# ---------------------------------------------------------------------------
 
-    prompt_server = server.PromptServer.instance
 
-    @prompt_server.routes.post("/kiko_local_image_loader/set_node_selection")
-    async def set_node_selection(request):
-        """API endpoint to set node selection."""
-        try:
-            data = await request.json()
-            node_id = str(data.get("node_id"))
-            path = data.get("path")
-            media_type = data.get("type")
+def _error(status: int, message: str):
+    return web.json_response({"status": "error", "error": message}, status=status)
 
-            if not all([node_id, path, media_type]):
-                return web.json_response(
-                    {"status": "error", "message": "Missing required data."}, status=400
-                )
 
-            selections = load_selections()
-            if node_id not in selections:
-                selections[node_id] = {}
+def _check_file(filepath: Any, kinds: Tuple[str, ...] = ("image",)):
+    """Validate a requested file. Returns (resolved_path, error_response)."""
+    if not isinstance(filepath, str) or not filepath or "\0" in filepath:
+        return None, web.Response(status=400)
+    real = resolve_path(filepath)
+    if not is_allowed_media_path(real, get_allowed_roots(), kinds):
+        return None, web.Response(status=403)
+    if not os.path.isfile(real):
+        return None, web.Response(status=404)
+    return real, None
 
-            selections[node_id][media_type] = {"path": path}
-            save_selections(selections)
 
-            return web.json_response({"status": "ok"})
-        except Exception as e:
-            return web.json_response({"status": "error", "message": str(e)}, status=500)
+def _parse_paging(query) -> Tuple[int, int]:
+    """Parse page/per_page; raises ValueError on garbage."""
+    page = int(query.get("page", 1))
+    per_page = int(query.get("per_page", DEFAULT_PER_PAGE))
+    if page < 1:
+        raise ValueError("page must be >= 1")
+    return page, max(1, min(per_page, MAX_PER_PAGE))
 
-    @prompt_server.routes.get("/kiko_local_image_loader/get_saved_paths")
-    async def get_saved_paths(request):
-        """API endpoint to get saved directory paths."""
-        config = load_config()
-        return web.json_response({"saved_paths": config.get("saved_paths", [])})
 
-    @prompt_server.routes.post("/kiko_local_image_loader/save_paths")
-    async def save_paths(request):
-        """API endpoint to save directory paths."""
-        try:
-            data = await request.json()
-            paths = data.get("paths", [])
-            config = load_config()
-            config["saved_paths"] = paths
-            save_config(config)
-            return web.json_response({"status": "ok"})
-        except Exception as e:
-            return web.json_response({"status": "error", "message": str(e)}, status=500)
+async def set_node_selection(request):
+    """Store the selected image for a node (image files in allowed roots only)."""
+    try:
+        data = await request.json()
+    except Exception:
+        return _error(400, "Invalid JSON.")
+    if not isinstance(data, dict):
+        return _error(400, "Invalid payload.")
 
-    @prompt_server.routes.get("/kiko_local_image_loader/images")
-    async def get_local_images(request):
-        """API endpoint to get images from a directory."""
-        directory = request.query.get("directory", "")
+    node_id = data.get("node_id")
+    path = data.get("path")
+    media_type = data.get("type")
+    if (
+        node_id is None
+        or not isinstance(path, str)
+        or not path
+        or "\0" in path
+        or not isinstance(media_type, str)
+        or not media_type
+    ):
+        return _error(400, "Missing required data.")
 
-        if not directory or not os.path.isdir(directory):
-            return web.json_response({"error": "Directory not found."}, status=404)
+    # The frontend also selects video/audio; load_media only ever reads images.
+    if not is_allowed_media_path(path, get_allowed_roots(), MEDIA_KINDS):
+        return _error(403, "Path not allowed.")
 
-        # Save last path
-        config = load_config()
-        config["last_path"] = directory
-        save_config(config)
+    selections = load_selections()
+    selections.setdefault(str(node_id), {})[media_type] = {"path": path}
+    save_selections(selections)
+    return web.json_response({"status": "ok"})
 
-        show_videos = request.query.get("show_videos", "false").lower() == "true"
-        show_audio = request.query.get("show_audio", "false").lower() == "true"
 
-        page = int(request.query.get("page", 1))
-        per_page = int(request.query.get("per_page", 50))
-        sort_by = request.query.get("sort_by", "name")
-        sort_order = request.query.get("sort_order", "asc")
+async def get_saved_paths(request):
+    """Return saved directory paths."""
+    return web.json_response({"saved_paths": load_config().get("saved_paths", [])})
 
-        try:
-            items = scan_directory(
-                directory, show_videos, show_audio, sort_by, sort_order
-            )
 
-            # Get parent directory
-            parent_directory = os.path.dirname(directory)
-            if parent_directory == directory:
-                parent_directory = None
+async def save_paths(request):
+    """Persist the list of saved directory paths."""
+    try:
+        data = await request.json()
+    except Exception:
+        return _error(400, "Invalid JSON.")
+    paths = data.get("paths", []) if isinstance(data, dict) else None
+    if not isinstance(paths, list) or not all(isinstance(p, str) for p in paths):
+        return _error(400, "paths must be a list of strings.")
+    too_broad = [p for p in paths if is_too_broad_root(p)]
+    if too_broad:
+        return _error(
+            400,
+            f"Folder too broad to share: {', '.join(too_broad)}. "
+            "Pick a folder inside your home directory or another media folder.",
+        )
+    config = load_config()
+    config["saved_paths"] = paths
+    save_config(config)
+    return web.json_response({"status": "ok"})
 
-            # Paginate results
-            start = (page - 1) * per_page
-            end = start + per_page
-            paginated_items = items[start:end]
 
-            return web.json_response(
-                {
-                    "items": paginated_items,
-                    "total_pages": (len(items) + per_page - 1) // per_page,
-                    "current_page": page,
-                    "current_directory": directory,
-                    "parent_directory": parent_directory,
-                }
-            )
-        except Exception as e:
-            return web.json_response({"error": str(e)}, status=500)
+async def get_local_images(request):
+    """List images and sub-directories of a directory inside an allowed root."""
+    query = request.query
+    directory = query.get("directory", "")
+    if not directory or "\0" in directory:
+        return _error(400, "Directory is required.")
+    try:
+        page, per_page = _parse_paging(query)
+    except ValueError:
+        return _error(400, "Invalid page or per_page.")
 
-    @prompt_server.routes.get("/kiko_local_image_loader/get_last_path")
-    async def get_last_path(request):
-        """API endpoint to get last used directory path."""
-        return web.json_response({"last_path": load_config().get("last_path", "")})
+    if not is_within_roots(directory, get_allowed_roots()):
+        return _error(403, "Directory not allowed.")
+    real = resolve_path(directory)
+    if not os.path.isdir(real):
+        return _error(404, "Directory not found.")
 
-    @prompt_server.routes.get("/kiko_local_image_loader/thumbnail")
-    async def get_thumbnail(request):
-        """API endpoint to get image thumbnail."""
-        filepath = request.query.get("filepath")
-        if not filepath or ".." in filepath:
-            return web.Response(status=400)
+    # Normalize path (trailing slashes etc.) but keep the user-visible spelling
+    directory = os.path.normpath(directory)
 
-        filepath = urllib.parse.unquote(filepath)
-        if not os.path.exists(filepath):
-            return web.Response(status=404)
+    config = load_config()
+    config["last_path"] = directory
+    save_config(config)
 
-        try:
-            img = Image.open(filepath)
+    show_videos = query.get("show_videos", "false").lower() == "true"
+    show_audio = query.get("show_audio", "false").lower() == "true"
+    hide_dot_folders = query.get("hide_dot_folders", "true").lower() == "true"
+
+    try:
+        items = scan_directory(
+            directory,
+            show_videos,
+            show_audio,
+            query.get("sort_by", "name"),
+            query.get("sort_order", "asc"),
+            hide_dot_folders,
+        )
+    except Exception:
+        logger.exception("Error scanning directory %s", directory)
+        return _error(500, "Error reading directory.")
+
+    # Do not offer navigation above the allowed roots
+    parent_directory = os.path.dirname(directory)
+    if parent_directory == directory or not is_within_roots(
+        parent_directory, get_allowed_roots()
+    ):
+        parent_directory = None
+
+    start = (page - 1) * per_page
+    return web.json_response(
+        {
+            "items": items[start : start + per_page],
+            "total_pages": (len(items) + per_page - 1) // per_page,
+            "current_page": page,
+            "current_directory": directory,
+            "parent_directory": parent_directory,
+        }
+    )
+
+
+async def get_last_path(request):
+    """Return the last used directory path."""
+    return web.json_response({"last_path": load_config().get("last_path", "")})
+
+
+async def list_directories(request):
+    """List directory names for the folder-picker autocomplete.
+
+    Trade-off: this is how users browse to a location that is not yet a saved
+    root, so it is intentionally NOT restricted to the allowed roots. It only
+    ever returns directory paths (never files), capped at
+    MAX_DIRECTORY_SUGGESTIONS; file contents stay protected by the root and
+    extension checks on every other route.
+    """
+    path = request.query.get("path", "")
+    if "\0" in path:
+        return web.json_response({"directories": []})
+
+    try:
+        if not path:
+            if os.name == "nt":
+                import string
+
+                drives = [
+                    f"{d}:\\"
+                    for d in string.ascii_uppercase
+                    if os.path.exists(f"{d}:\\")
+                ]
+                return web.json_response({"directories": drives})
+            return web.json_response({"directories": [os.sep]})
+
+        dirs = list_subdirectories(os.path.expanduser(path), MAX_DIRECTORY_SUGGESTIONS)
+        return web.json_response({"directories": dirs})
+    except PermissionError:
+        return web.json_response({"directories": [], "error": "Permission denied"})
+    except Exception:
+        logger.exception("Error listing directories for %s", path)
+        return web.json_response(
+            {"directories": [], "error": "Error listing directories"}
+        )
+
+
+async def get_thumbnail(request):
+    """Return a thumbnail of an allowed image."""
+    real, error = _check_file(request.query.get("filepath"))
+    if error is not None:
+        return error
+
+    try:
+        from PIL import Image
+
+        with Image.open(real) as img:
             has_alpha = img.mode == "RGBA" or (
                 img.mode == "P" and "transparency" in img.info
             )
@@ -259,33 +371,39 @@ try:
             img.thumbnail([320, 320], Image.LANCZOS)
 
             buffer = io.BytesIO()
-            format, content_type = (
+            fmt, content_type = (
                 ("PNG", "image/png") if has_alpha else ("JPEG", "image/jpeg")
             )
-            img.save(buffer, format=format, quality=90 if format == "JPEG" else None)
-            buffer.seek(0)
+            img.save(buffer, format=fmt, quality=90 if fmt == "JPEG" else None)
+        return web.Response(body=buffer.getvalue(), content_type=content_type)
+    except Exception:
+        logger.exception("Error generating thumbnail for %s", real)
+        return web.Response(status=500)
 
-            return web.Response(body=buffer.read(), content_type=content_type)
-        except Exception as e:
-            print(f"KikoLocalImageLoader: Error generating thumbnail: {e}")
-            return web.Response(status=500)
 
-    @prompt_server.routes.get("/kiko_local_image_loader/view")
-    async def view_image(request):
-        """API endpoint to view full image."""
-        filepath = request.query.get("filepath")
-        if not filepath or ".." in filepath:
-            return web.Response(status=400)
+async def view_image(request):
+    """Serve a full-size allowed media file (image, video or audio)."""
+    real, error = _check_file(request.query.get("filepath"), MEDIA_KINDS)
+    if error is not None:
+        return error
+    return web.FileResponse(real)
 
-        filepath = urllib.parse.unquote(filepath)
-        if not os.path.exists(filepath):
-            return web.Response(status=404)
 
-        try:
-            return web.FileResponse(filepath)
-        except Exception:
-            return web.Response(status=500)
+# Setup API routes
+try:
+    import server
 
+    prompt_server = server.PromptServer.instance
+    _routes = prompt_server.routes
+    _prefix = "/kiko_local_image_loader"
+    _routes.post(f"{_prefix}/set_node_selection")(set_node_selection)
+    _routes.get(f"{_prefix}/get_saved_paths")(get_saved_paths)
+    _routes.post(f"{_prefix}/save_paths")(save_paths)
+    _routes.get(f"{_prefix}/images")(get_local_images)
+    _routes.get(f"{_prefix}/get_last_path")(get_last_path)
+    _routes.get(f"{_prefix}/list_directories")(list_directories)
+    _routes.get(f"{_prefix}/thumbnail")(get_thumbnail)
+    _routes.get(f"{_prefix}/view")(view_image)
 except ImportError:
     # Server not available during testing
     pass

kikotools/tools/local_image_loader/selections.json

@@ -1,12 +0,0 @@
-{
-    "57": {
-        "image": {
-            "path": "/home/vito/ai-apps/ComfyUI-3.12/output/2025-05-01/HiDream_00001_.png"
-        }
-    },
-    "58": {
-        "image": {
-            "path": "/home/vito/ai-apps/ComfyUI-3.12/output/CharacterName_00016_.png"
-        }
-    }
-}

kikotools/tools/model_compare_sheet/__init__.py

@@ -0,0 +1,5 @@
+"""Model Compare Sheet module."""
+
+from .node import ModelCompareSheetNode
+
+__all__ = ["ModelCompareSheetNode"]

kikotools/tools/model_compare_sheet/logic.py

@@ -0,0 +1,163 @@
+"""Logic for the Model Compare Sheet node: tile files on disk into a labeled grid."""
+
+import math
+import os
+import re
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+from PIL import Image, ImageDraw, ImageFont
+
+from ...base.model_folders import is_within, natural_sort
+
+GRID_FILENAME = "grid.png"
+PREVIEW_FILENAME = "grid_preview.png"
+PREVIEW_WIDTH = 1024
+BACKGROUND = (28, 28, 28)
+LABEL_COLOR = (235, 235, 235)
+
+
+def resolve_run_dir(output_dir: str, run_name: str) -> str:
+    """Directory for one compare run, always strictly inside output/model_compare.
+
+    run_name may be nested ("project/date/sweep"). Every segment must be a plain
+    name: no empty, "." or ".." parts, on either separator, and the resolved
+    path must stay below model_compare even after symlinks are followed.
+    """
+    parts = re.split(r"[\\/]", run_name)
+    if not run_name or os.path.isabs(run_name) or ":" in run_name:
+        raise ValueError(f"Invalid run_name: {run_name!r}")
+    if any(part in ("", ".", "..") for part in parts):
+        raise ValueError(f"Invalid run_name: {run_name!r}")
+    base = os.path.join(output_dir, "model_compare")
+    run_dir = os.path.join(base, *parts)
+    if not is_within(run_dir, base) or os.path.realpath(run_dir) == os.path.realpath(
+        base
+    ):
+        raise ValueError(f"Invalid run_name: {run_name!r}")
+    return run_dir
+
+
+def tile_filename(index: int, label: str, batch_index: int, batch_size: int) -> str:
+    """'03_label.png', or '03_label_2.png' for the second image of a batch."""
+    safe = re.sub(r"[^A-Za-z0-9._-]+", "_", label)
+    suffix = f"_{batch_index + 1}" if batch_size > 1 else ""
+    return f"{index:02d}_{safe}{suffix}.png"
+
+
+def label_from_filename(filename: str) -> str:
+    stem = os.path.splitext(os.path.basename(filename))[0]
+    return re.sub(r"^\d+_", "", stem)
+
+
+def list_tiles(run_dir: str) -> List[str]:
+    """PNG tiles in a run directory in natural order, excluding the grid itself."""
+    names = [
+        f
+        for f in os.listdir(run_dir)
+        if f.lower().endswith(".png")
+        and f not in (GRID_FILENAME, PREVIEW_FILENAME)
+        and os.path.isfile(os.path.join(run_dir, f))
+    ]
+    return [os.path.join(run_dir, f) for f in natural_sort(names)]
+
+
+def replace_index_tiles(
+    run_dir: str, index: int, staged_dir: str, names: List[str]
+) -> None:
+    """Publish one index's staged tiles, restoring old files on a rename failure."""
+    previous_dir = os.path.join(staged_dir, "previous")
+    os.mkdir(previous_dir)
+    prefix = f"{index:02d}_"
+    old_tiles = [
+        path
+        for path in list_tiles(run_dir)
+        if os.path.basename(path).startswith(prefix)
+    ]
+    moved: List[Tuple[str, str]] = []
+    published: List[str] = []
+    try:
+        for path in old_tiles:
+            backup = os.path.join(previous_dir, os.path.basename(path) + ".previous")
+            os.replace(path, backup)
+            moved.append((path, backup))
+        for name in names:
+            destination = os.path.join(run_dir, name)
+            os.replace(os.path.join(staged_dir, name + ".tmp"), destination)
+            published.append(destination)
+    except OSError:
+        for path in published:
+            os.remove(path)
+        for original, backup in reversed(moved):
+            os.replace(backup, original)
+        raise
+
+
+def archive_previous_sweep(run_dir: str) -> Optional[str]:
+    """Rename a run folder that already holds tiles to '<run_dir>_<timestamp>'.
+
+    Called when a sweep starts over (index 0) so stale tiles from an
+    interrupted sweep never end up in the new grid. Returns the archive path,
+    or None when there was nothing to archive.
+    """
+    if not os.path.isdir(run_dir) or not list_tiles(run_dir):
+        return None
+    stamp = datetime.fromtimestamp(os.path.getmtime(run_dir)).strftime("%Y%m%d-%H%M%S")
+    archive = f"{run_dir}_{stamp}"
+    n = 1
+    while os.path.exists(archive):
+        n += 1
+        archive = f"{run_dir}_{stamp}_{n}"
+    os.rename(run_dir, archive)
+    return archive
+
+
+def _font(font_size: int) -> ImageFont.ImageFont:
+    try:
+        return ImageFont.truetype("DejaVuSans.ttf", font_size)
+    except OSError:
+        return ImageFont.load_default(size=font_size)
+
+
+def _fit_label(draw: ImageDraw.ImageDraw, text: str, font, max_width: int) -> str:
+    while text and draw.textlength(text, font=font) > max_width:
+        text = text[:-2] + "…" if len(text) > 1 else ""
+    return text
+
+
+def build_contact_sheet(
+    paths: List[str], columns: int, tile_width: int, font_size: int
+) -> Image.Image:
+    """Tile the images at `paths` into a grid with each file's label underneath."""
+    tiles = []
+    for path in paths:
+        with Image.open(path) as im:
+            im = im.convert("RGB")
+            tile_height = max(1, round(im.height * tile_width / im.width))
+            tiles.append((im.resize((tile_width, tile_height), Image.LANCZOS), path))
+
+    band = font_size * 2
+    cell_height = max(t.height for t, _ in tiles) + band
+    cols = min(len(tiles), columns)
+    rows = math.ceil(len(tiles) / cols)
+    sheet = Image.new("RGB", (cols * tile_width, rows * cell_height), BACKGROUND)
+    draw = ImageDraw.Draw(sheet)
+    font = _font(font_size)
+
+    for i, (tile, path) in enumerate(tiles):
+        x = (i % cols) * tile_width
+        y = (i // cols) * cell_height
+        sheet.paste(tile, (x, y))
+        label = _fit_label(draw, label_from_filename(path), font, tile_width - 8)
+        text_x = x + (tile_width - draw.textlength(label, font=font)) / 2
+        text_y = y + tile.height + (band - font_size) / 2
+        draw.text((text_x, text_y), label, fill=LABEL_COLOR, font=font)
+    return sheet
+
+
+def preview_of(sheet: Image.Image) -> Image.Image:
+    """A copy of the sheet no wider than PREVIEW_WIDTH, for the node preview and galleries."""
+    if sheet.width <= PREVIEW_WIDTH:
+        return sheet
+    height = max(1, round(sheet.height * PREVIEW_WIDTH / sheet.width))
+    return sheet.resize((PREVIEW_WIDTH, height), Image.LANCZOS)

kikotools/tools/model_compare_sheet/node.py

@@ -0,0 +1,125 @@
+"""Model Compare Sheet node for ComfyUI."""
+
+import json
+import os
+from tempfile import TemporaryDirectory
+from typing import Any, Dict, Optional
+
+import numpy as np
+import torch
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+
+from ...base.base_node import ComfyAssetsBaseNode
+from .logic import (
+    GRID_FILENAME,
+    PREVIEW_FILENAME,
+    archive_previous_sweep,
+    build_contact_sheet,
+    list_tiles,
+    preview_of,
+    replace_index_tiles,
+    resolve_run_dir,
+    tile_filename,
+)
+
+
+class ModelCompareSheetNode(ComfyAssetsBaseNode):
+    """
+    Save each run's image into output/model_compare/<run_name>/ and rebuild a
+    labeled contact sheet from every tile saved so far. Pair with Checkpoint
+    Folder Iterator: after the last queued run the grid holds every model.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "label": ("STRING", {"forceInput": True}),
+                "index": ("INT", {"forceInput": True}),
+                "run_name": (
+                    "STRING",
+                    {
+                        "default": "illustrious",
+                        "tooltip": "Subfolder of output/model_compare for this run",
+                    },
+                ),
+                "columns": ("INT", {"default": 5, "min": 1, "max": 32}),
+                "tile_width": ("INT", {"default": 512, "min": 64, "max": 4096}),
+                "font_size": ("INT", {"default": 28, "min": 8, "max": 256}),
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("grid",)
+    FUNCTION = "collect"
+    OUTPUT_NODE = True
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
+
+    def collect(
+        self,
+        images: torch.Tensor,
+        label: str,
+        index: int,
+        run_name: str,
+        columns: int,
+        tile_width: int,
+        font_size: int,
+        prompt: Optional[Dict] = None,
+        extra_pnginfo: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        import folder_paths
+
+        if images.shape[0] == 0:
+            raise ValueError("images must contain at least one image")
+
+        output_dir = folder_paths.get_output_directory()
+        run_dir = resolve_run_dir(output_dir, run_name)
+        metadata = PngInfo()
+        if prompt is not None:
+            metadata.add_text("prompt", json.dumps(prompt))
+        for key, value in (extra_pnginfo or {}).items():
+            metadata.add_text(key, json.dumps(value))
+
+        parent = os.path.dirname(run_dir)
+        os.makedirs(parent, exist_ok=True)
+        with TemporaryDirectory(prefix=".model-compare-", dir=parent) as staging:
+            names = []
+            for i, image in enumerate(images):
+                array = (image.cpu().numpy().clip(0, 1) * 255).round().astype(np.uint8)
+                name = tile_filename(index, label, i, images.shape[0])
+                with Image.fromarray(array) as tile:
+                    tile.save(
+                        os.path.join(staging, name + ".tmp"),
+                        format="PNG",
+                        pnginfo=metadata,
+                    )
+                names.append(name)
+            if index == 0:
+                archived = archive_previous_sweep(run_dir)
+                if archived:
+                    self.log_info(f"New sweep: previous tiles moved to {archived}")
+            os.makedirs(run_dir, exist_ok=True)
+            replace_index_tiles(run_dir, index, staging, names)
+
+        sheet = build_contact_sheet(list_tiles(run_dir), columns, tile_width, font_size)
+        sheet.save(os.path.join(run_dir, GRID_FILENAME))
+        preview_of(sheet).save(os.path.join(run_dir, PREVIEW_FILENAME))
+        self.log_info(f"Contact sheet: {run_dir}/{GRID_FILENAME}")
+
+        grid = torch.from_numpy(np.asarray(sheet).astype(np.float32) / 255.0)[None]
+        subfolder = os.path.relpath(run_dir, output_dir)
+        return {
+            "ui": {
+                "images": [
+                    {
+                        "filename": PREVIEW_FILENAME,
+                        "subfolder": subfolder,
+                        "type": "output",
+                    }
+                ]
+            },
+            "result": (grid,),
+        }

kikotools/tools/model_downloader/__init__.py

@@ -0,0 +1,13 @@
+"""Model Downloader Tool for ComfyUI-KikoTools
+
+Downloads models from CivitAI, HuggingFace, and custom URLs.
+"""
+
+from .node import ModelDownloaderNode
+
+__all__ = ["ModelDownloaderNode"]
+
+# Node registration
+NODE_CLASS_MAPPINGS = {"KikoModelDownloader": ModelDownloaderNode}
+
+NODE_DISPLAY_NAME_MAPPINGS = {"KikoModelDownloader": "Model Downloader 🌐"}

kikotools/tools/model_downloader/base.py

@@ -0,0 +1,483 @@
+"""Base downloader class with common functionality"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Callable, List, Optional, Sequence, Union
+from urllib.parse import urlparse, unquote
+import logging
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+DOWNLOAD_TIMEOUT = 60  # seconds, applied to every network operation
+CHUNK_SIZE = 1638400
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+ALLOWED_SCHEMES = ("http", "https")
+PART_SUFFIX = ".part"
+# Only model weights and inert data files may be written; never code.
+ALLOWED_FILE_EXTENSIONS = frozenset(
+    {
+        ".safetensors",
+        ".sft",
+        ".ckpt",
+        ".pt",
+        ".pt2",
+        ".pth",
+        ".bin",
+        ".gguf",
+        ".onnx",
+        ".model",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".txt",
+    }
+)
+# folder_paths entries that hold code rather than models.
+EXCLUDED_FOLDER_NAMES = frozenset({"custom_nodes"})
+
+try:
+    import comfy.model_management
+
+    COMFY_AVAILABLE = True
+except ImportError:
+    COMFY_AVAILABLE = False
+
+
+def validate_url_scheme(url: str) -> None:
+    """Raise ValueError unless url uses an allowed scheme (http/https)."""
+    scheme = urlparse(url or "").scheme.lower()
+    if scheme not in ALLOWED_SCHEMES:
+        raise ValueError(
+            f"Unsupported URL scheme '{scheme}'. Only http and https are allowed."
+        )
+
+
+def validate_filename(name: Optional[str]) -> str:
+    """Validate a user-supplied filename.
+
+    Raises:
+        ValueError: If the name is empty, a dot name, or contains path parts.
+    """
+    if (
+        not name
+        or name in (".", "..")
+        or os.path.basename(name) != name
+        or "/" in name
+        or "\\" in name
+        or "\x00" in name
+    ):
+        raise ValueError(f"Invalid filename: {name!r}")
+    return name
+
+
+def safe_server_filename(name: Optional[str], default: str) -> str:
+    """Reduce a server-derived filename to a safe basename, or use default."""
+    if name:
+        candidate = os.path.basename(name.replace("\\", "/"))
+        try:
+            return validate_filename(candidate)
+        except ValueError:
+            pass
+    return default
+
+
+class _SafeRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Only follow http(s) redirects and drop credentials on cross-host hops."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        if urlparse(newurl).scheme.lower() not in ALLOWED_SCHEMES:
+            raise urllib.error.HTTPError(
+                newurl, code, "Redirect to disallowed URL scheme", headers, fp
+            )
+        new_request = super().redirect_request(req, fp, code, msg, headers, newurl)
+        if new_request is not None and (
+            urlparse(newurl).netloc.lower() != urlparse(req.full_url).netloc.lower()
+        ):
+            new_request.remove_header("Authorization")
+        return new_request
+
+
+class _NoRedirectProcessor(urllib.request.HTTPErrorProcessor):
+    """Return every response as-is so redirects can be handled manually."""
+
+    def http_response(self, request, response):
+        return response
+
+    https_response = http_response
+
+
+def _folder_paths():
+    """Return the folder_paths module, or None when unavailable."""
+    try:
+        import folder_paths
+
+        return folder_paths
+    except ImportError:
+        return None
+
+
+def _default_model_roots() -> List[str]:
+    """Return ComfyUI's models dir plus every registered model folder.
+
+    Covers extra_model_paths.yaml entries on other drives.
+    """
+    fp = _folder_paths()
+    if fp is None:
+        return []
+    roots: List[str] = []
+    models_dir = getattr(fp, "models_dir", None)
+    if isinstance(models_dir, str) and models_dir:
+        roots.append(models_dir)
+    registry = getattr(fp, "folder_names_and_paths", None)
+    if isinstance(registry, dict):
+        for name, entry in registry.items():
+            if name in EXCLUDED_FOLDER_NAMES:
+                continue
+            try:
+                paths = entry[0]
+            except (TypeError, IndexError, KeyError):
+                continue
+            if isinstance(paths, (list, tuple)):
+                roots.extend(p for p in paths if isinstance(p, str) and p)
+    return roots
+
+
+def _default_base_path() -> Optional[str]:
+    """Return ComfyUI's base path used to resolve relative save paths."""
+    fp = _folder_paths()
+    base = getattr(fp, "base_path", None) if fp is not None else None
+    return base if isinstance(base, str) and base else None
+
+
+class BaseDownloader(ABC):
+    """Abstract base class for all downloaders"""
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        models_root: Union[str, Sequence[str], None] = None,
+    ):
+        """Initialize downloader with optional API token
+
+        Args:
+            token: Optional API token for authentication
+            models_root: Directory (or list of directories) downloads must
+                stay inside. Defaults to ComfyUI's models directory plus all
+                registered model folders.
+        """
+        self.token = token
+        if isinstance(models_root, str):
+            models_root = [models_root]
+        self._models_root = list(models_root) if models_root else None
+        self._progress_callback: Optional[Callable[[int, int, str], None]] = None
+
+    def set_progress_callback(self, callback: Callable[[int, int, str], None]) -> None:
+        """Set callback function for progress updates
+
+        Args:
+            callback: Function(downloaded_bytes, total_bytes, message)
+        """
+        self._progress_callback = callback
+
+    def report_progress(self, downloaded: int, total: int, message: str = "") -> None:
+        """Report download progress to callback
+
+        Args:
+            downloaded: Bytes downloaded so far
+            total: Total bytes to download
+            message: Optional status message
+        """
+        if self._progress_callback:
+            self._progress_callback(downloaded, total, message)
+
+    def check_interrupt(self) -> None:
+        """Check if processing has been interrupted by user
+
+        Raises:
+            comfy.model_management.InterruptProcessingException: If user cancelled
+        """
+        if COMFY_AVAILABLE:
+            comfy.model_management.throw_exception_if_processing_interrupted()
+
+    def extract_filename(self, url: str, default: str = "downloaded_file") -> str:
+        """Extract filename from URL
+
+        Args:
+            url: URL to extract filename from
+            default: Default filename if extraction fails
+
+        Returns:
+            Extracted or default filename
+        """
+        try:
+            parsed = urlparse(url)
+            path = unquote(parsed.path)
+            filename = os.path.basename(path)
+
+            # Remove query parameters from filename
+            if "?" in filename:
+                filename = filename.split("?")[0]
+
+            # Validate filename
+            if filename and len(filename) > 0 and "." in filename:
+                return filename
+        except Exception:
+            pass
+
+        return default
+
+    def extract_filename_from_header(self, content_disposition: str) -> Optional[str]:
+        """Extract filename from Content-Disposition header
+
+        Args:
+            content_disposition: Content-Disposition header value
+
+        Returns:
+            Extracted filename or None
+        """
+        if not content_disposition:
+            return None
+        match = re.search(r"filename\*\s*=\s*[^']*'[^']*'([^;]+)", content_disposition)
+        if match:
+            return unquote(match.group(1).strip()) or None
+        match = re.search(
+            r'filename\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|([^;]+))', content_disposition
+        )
+        if match:
+            value = next(g for g in match.groups() if g is not None)
+            return value.strip() or None
+        return None
+
+    @staticmethod
+    def _is_within(path: str, root: str) -> bool:
+        try:
+            return os.path.commonpath([root, path]) == root
+        except ValueError:  # different drives
+            return False
+
+    def resolve_output_dir(self, output_path: str) -> str:
+        """Resolve output_path and ensure it lives inside the models root.
+
+        Returns:
+            Real (symlink-resolved) directory path, created if missing.
+
+        Raises:
+            ValueError: If the path escapes the models directory.
+        """
+        roots = self._models_root or _default_model_roots()
+        if not roots:
+            raise ValueError("Models directory is unavailable; refusing to download")
+        if not os.path.isabs(output_path):
+            output_path = os.path.join(_default_base_path() or os.getcwd(), output_path)
+        real_dir = os.path.realpath(output_path)
+        real_roots = [os.path.realpath(r) for r in roots]
+        if not any(self._is_within(real_dir, r) for r in real_roots):
+            raise ValueError(
+                f"Save path must be inside a ComfyUI models directory "
+                f"({', '.join(real_roots)})"
+            )
+        self.validate_output_path(real_dir)
+        return real_dir
+
+    def open_url(self, request: urllib.request.Request, follow_redirects: bool = True):
+        """Open a request with scheme checks, timeout and safe redirects."""
+        validate_url_scheme(request.full_url)
+        handler = _SafeRedirectHandler if follow_redirects else _NoRedirectProcessor
+        opener = urllib.request.build_opener(handler)
+        return opener.open(request, timeout=DOWNLOAD_TIMEOUT)
+
+    @staticmethod
+    def parse_content_length(response: Any) -> Optional[int]:
+        """Return Content-Length as int, or None if absent/invalid."""
+        value = response.getheader("Content-Length")
+        try:
+            return int(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+
+    def save_response(
+        self,
+        response: Any,
+        output_file: str,
+        total_size: Optional[int],
+        strict_size: bool = True,
+    ) -> str:
+        """Stream response to output_file atomically via a .part file.
+
+        The .part file is removed on any failure (including interrupts).
+
+        Raises:
+            ValueError: If output_file is not a model/data file type.
+        """
+        extension = os.path.splitext(output_file)[1].lower()
+        if extension not in ALLOWED_FILE_EXTENSIONS:
+            raise ValueError(
+                f"Refusing to save file type '{extension or 'none'}': "
+                f"only model files ({', '.join(sorted(ALLOWED_FILE_EXTENSIONS))})"
+            )
+        part_file = output_file + PART_SUFFIX
+        try:
+            downloaded = 0
+            start_time = time.time()
+            with open(part_file, "wb") as f:
+                while True:
+                    chunk_start = time.time()
+                    buffer = response.read(CHUNK_SIZE)
+                    chunk_time = time.time() - chunk_start
+                    if not buffer:
+                        break
+                    downloaded += len(buffer)
+                    f.write(buffer)
+                    self.check_interrupt()
+                    speed = self.calculate_speed(len(buffer), chunk_time)
+                    self._report_chunk(downloaded, total_size, speed)
+            sys.stdout.write("\n")
+
+            actual_size = os.path.getsize(part_file)
+            if total_size and actual_size != total_size:
+                message = (
+                    f"Download incomplete. Expected {total_size} bytes, "
+                    f"got {actual_size} bytes"
+                )
+                if strict_size:
+                    raise Exception(message)
+                logger.warning(message)
+
+            os.replace(part_file, output_file)
+            logger.info(
+                "Download completed in %.0fs: %s", time.time() - start_time, output_file
+            )
+            return output_file
+        except BaseException:
+            if os.path.exists(part_file):
+                os.remove(part_file)
+            raise
+        finally:
+            close = getattr(response, "close", None)
+            if callable(close):
+                close()
+
+    def _report_chunk(
+        self, downloaded: int, total_size: Optional[int], speed: float
+    ) -> None:
+        """Write console progress and notify the callback."""
+        if total_size:
+            progress = downloaded / total_size
+            sys.stdout.write(
+                f'\r[{"=" * int(progress * 50):<50}] {progress * 100:.2f}% - {speed:.2f} MB/s'
+            )
+            self.report_progress(downloaded, total_size, f"{speed:.2f} MB/s")
+        else:
+            sys.stdout.write(
+                f"\rDownloaded: {self.format_size(downloaded)} - {speed:.2f} MB/s"
+            )
+            self.report_progress(downloaded, 0, f"{speed:.2f} MB/s")
+        sys.stdout.flush()
+
+    def raise_for_http_status(self, code: int, reason: str, hints: dict) -> None:
+        """Raise a friendly Exception for an HTTP error status."""
+        message = hints.get(code)
+        if message is None and code == 429:
+            message = "Rate limited. Please wait a moment before trying again."
+        raise Exception(message or f"HTTP error {code}: {reason}")
+
+    def validate_output_path(self, output_path: str) -> bool:
+        """Validate and create output path if needed
+
+        Args:
+            output_path: Directory path to validate
+
+        Returns:
+            True if valid
+
+        Raises:
+            ValueError: If path exists but is not a directory
+        """
+        path = Path(output_path)
+
+        if path.exists():
+            if not path.is_dir():
+                raise ValueError(
+                    f"Output path {output_path} exists but is not a directory"
+                )
+            return True
+
+        # Create directory if it doesn't exist
+        path.mkdir(parents=True, exist_ok=True)
+        return True
+
+    def should_download(self, file_path: str, force: bool = False) -> bool:
+        """Check if file should be downloaded
+
+        Args:
+            file_path: Full path to file
+            force: Force download even if file exists
+
+        Returns:
+            True if should download, False if file exists and force=False
+        """
+        if force:
+            return True
+
+        return not Path(file_path).exists()
+
+    def format_size(self, size_bytes: int) -> str:
+        """Format file size in human-readable format
+
+        Args:
+            size_bytes: Size in bytes
+
+        Returns:
+            Formatted size string (e.g., "5.00 MB")
+        """
+        for unit in ["B", "KB", "MB", "GB"]:
+            if size_bytes < 1024.0:
+                return f"{size_bytes:.2f} {unit}"
+            size_bytes /= 1024.0
+        return f"{size_bytes:.2f} TB"
+
+    def calculate_speed(self, bytes_downloaded: int, elapsed_seconds: float) -> float:
+        """Calculate download speed in MB/s
+
+        Args:
+            bytes_downloaded: Number of bytes downloaded
+            elapsed_seconds: Time elapsed in seconds
+
+        Returns:
+            Download speed in MB/s
+        """
+        if elapsed_seconds <= 0:
+            return 0.0
+
+        mb_downloaded = bytes_downloaded / (1024 * 1024)
+        return mb_downloaded / elapsed_seconds
+
+    @abstractmethod
+    def download(
+        self,
+        url: str,
+        output_path: str,
+        filename: Optional[str] = None,
+        force: bool = False,
+    ) -> str:
+        """Download file from URL
+
+        Args:
+            url: URL to download from
+            output_path: Directory to save file
+            filename: Optional filename override
+            force: Force re-download if file exists
+
+        Returns:
+            Path to downloaded file
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
+        raise NotImplementedError("Subclasses must implement download()")

kikotools/tools/model_downloader/civitai.py

@@ -0,0 +1,238 @@
+"""CivitAI downloader implementation"""
+
+import json
+import logging
+import os
+import urllib.request
+import urllib.parse
+import urllib.error
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse, parse_qs, unquote, urljoin
+
+from .base import (
+    USER_AGENT,
+    BaseDownloader,
+    safe_server_filename,
+    validate_filename,
+    validate_url_scheme,
+)
+
+logger = logging.getLogger(__name__)
+
+API_BASE = "https://civitai.com/api/v1"
+REDIRECT_STATUSES = (301, 302, 303, 307, 308)
+
+HTTP_ERROR_HINTS = {
+    401: "Authentication required. Please provide a valid API token.",
+    403: "Access forbidden. The model might be restricted or require special permissions.",
+    404: "Model not found. The URL might be incorrect or the model was removed.",
+}
+
+
+class CivitAIDownloader(BaseDownloader):
+    """Downloader for CivitAI models"""
+
+    def _make_request(
+        self, url: str, headers: Optional[Dict[str, str]] = None
+    ) -> urllib.request.Request:
+        """Create HTTP request with authentication
+
+        Args:
+            url: URL to request
+            headers: Optional additional headers
+
+        Returns:
+            urllib Request object
+        """
+        if headers is None:
+            headers = {}
+
+        headers["User-Agent"] = USER_AGENT
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        return urllib.request.Request(url, headers=headers)
+
+    def _parse_civitai_url(self, url: str) -> Dict[str, Optional[int]]:
+        """Extract model and version IDs from CivitAI URL
+
+        Args:
+            url: CivitAI URL to parse
+
+        Returns:
+            Dict with 'model_id' and 'version_id' keys
+        """
+        parsed = urlparse(url)
+        result = {"model_id": None, "version_id": None}
+
+        # Handle different URL patterns
+        # 1. Direct API download URL: /api/download/models/123456
+        if "/api/download/models/" in url:
+            match = url.split("/api/download/models/")[-1].split("?")[0]
+            if match.isdigit():
+                result["version_id"] = int(match)
+                return result
+
+        # 2. Model page URL: /models/123456 or /models/123456/model-name
+        if "/models/" in url:
+            parts = parsed.path.split("/")
+            if "models" in parts:
+                idx = parts.index("models")
+                if idx + 1 < len(parts) and parts[idx + 1].isdigit():
+                    result["model_id"] = int(parts[idx + 1])
+
+        # 3. Version specific URL with ?modelVersionId=789012
+        query_params = parse_qs(parsed.query)
+        if "modelVersionId" in query_params:
+            version_id = query_params["modelVersionId"][0]
+            if version_id.isdigit():
+                result["version_id"] = int(version_id)
+
+        return result
+
+    def get_model_details(self, model_id: int) -> Dict[str, Any]:
+        """Get model details from API
+
+        Args:
+            model_id: CivitAI model ID
+
+        Returns:
+            Model details dictionary
+
+        Raises:
+            Exception: If API request fails
+        """
+        url = f"{API_BASE}/models/{model_id}"
+        request = self._make_request(url)
+
+        try:
+            with self.open_url(request) as response:
+                return json.loads(response.read().decode())
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                raise Exception(f"Model {model_id} not found")
+            raise Exception(f"API request failed: {e}")
+
+    def download(
+        self,
+        url: str,
+        output_path: str,
+        filename: Optional[str] = None,
+        force: bool = False,
+    ) -> str:
+        """Download file from CivitAI
+
+        Args:
+            url: CivitAI URL to download
+            output_path: Directory to save file
+            filename: Optional filename override
+            force: Force re-download if file exists
+
+        Returns:
+            Path to downloaded file
+
+        Raises:
+            Exception: If download fails
+        """
+        validate_url_scheme(url)
+        if filename:
+            validate_filename(filename)
+        output_dir = self.resolve_output_dir(output_path)
+
+        # Validate that URL is from civitai.com domain
+        parsed_url = urlparse(url)
+        if parsed_url.netloc not in ("civitai.com", "www.civitai.com"):
+            raise ValueError(
+                f"Invalid URL: Only civitai.com URLs are supported, got {parsed_url.netloc}"
+            )
+
+        # Convert web URL to API URL if needed
+        if "/api/download/models/" not in url:
+            ids = self._parse_civitai_url(url)
+
+            # If we have a version ID, use it directly
+            if ids["version_id"]:
+                url = f"https://civitai.com/api/download/models/{ids['version_id']}"
+            # If we only have a model ID, get the latest version
+            elif ids["model_id"]:
+                try:
+                    model_details = self.get_model_details(ids["model_id"])
+                    if model_details.get("modelVersions"):
+                        version_id = model_details["modelVersions"][0]["id"]
+                        url = f"https://civitai.com/api/download/models/{version_id}"
+                    else:
+                        raise Exception(
+                            f"No versions found for model {ids['model_id']}"
+                        )
+                except Exception as e:
+                    raise Exception(f"Failed to get model details: {e}")
+            else:
+                raise Exception("Could not parse model or version ID from URL")
+
+        headers = {"User-Agent": USER_AGENT}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        request = urllib.request.Request(url, headers=headers)
+
+        try:
+            response = self.open_url(request, follow_redirects=False)
+        except urllib.error.HTTPError as e:
+            self.raise_for_http_status(e.code, e.reason, HTTP_ERROR_HINTS)
+        except urllib.error.URLError as e:
+            raise Exception(f"Network error: {e.reason}")
+
+        if response.status in REDIRECT_STATUSES:
+            redirect_url = response.getheader("Location")
+            response.close()
+            if not redirect_url:
+                raise Exception("Redirect response did not include a Location header")
+            redirect_url = urljoin(url, redirect_url)
+            validate_url_scheme(redirect_url)
+
+            if not filename:
+                filename = self._filename_from_redirect(redirect_url)
+
+            # The signed redirect target gets no credentials
+            try:
+                response = self.open_url(
+                    urllib.request.Request(
+                        redirect_url, headers={"User-Agent": USER_AGENT}
+                    )
+                )
+            except urllib.error.HTTPError as e:
+                self.raise_for_http_status(e.code, e.reason, HTTP_ERROR_HINTS)
+            except urllib.error.URLError as e:
+                raise Exception(f"Network error: {e.reason}")
+        elif response.status != 200:
+            code = response.status
+            response.close()
+            self.raise_for_http_status(
+                code, "Download failed", {**HTTP_ERROR_HINTS, 404: "File not found"}
+            )
+
+        if not filename:
+            filename = safe_server_filename(
+                self.extract_filename(url, default="model.safetensors"),
+                "model.safetensors",
+            )
+
+        output_file = os.path.join(output_dir, filename)
+        if not self.should_download(output_file, force):
+            response.close()
+            logger.info("File already exists: %s", output_file)
+            return output_file
+
+        total_size = self.parse_content_length(response)
+        logger.info("Downloading %s to %s", filename, output_file)
+        return self.save_response(response, output_file, total_size)
+
+    def _filename_from_redirect(self, redirect_url: str) -> str:
+        """Derive a safe filename from a CivitAI redirect URL."""
+        parsed = urlparse(redirect_url)
+        disposition = parse_qs(parsed.query).get("response-content-disposition", [""])[
+            0
+        ]
+        name = self.extract_filename_from_header(unquote(disposition))
+        if not name:
+            name = parsed.path.rsplit("/", 1)[-1]
+        return safe_server_filename(name, "downloaded_file.safetensors")

kikotools/tools/model_downloader/custom.py

@@ -0,0 +1,98 @@
+"""Custom URL downloader - best effort for direct download links"""
+
+import logging
+import os
+import urllib.error
+import urllib.request
+from typing import Optional
+
+from .base import (
+    USER_AGENT,
+    BaseDownloader,
+    safe_server_filename,
+    validate_filename,
+    validate_url_scheme,
+)
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_FILENAME = "downloaded_model.safetensors"
+
+HTTP_ERROR_HINTS = {
+    401: "Authentication required. Please provide a valid token if needed.",
+    403: "Access forbidden. The URL might require authentication or special permissions.",
+    404: "File not found. Please check the URL.",
+}
+
+
+class CustomDownloader(BaseDownloader):
+    """Best-effort downloader for custom/direct URLs
+
+    The optional token is sent as a Bearer token and is dropped automatically
+    if the server redirects to a different host.
+    """
+
+    def download(
+        self,
+        url: str,
+        output_path: str,
+        filename: Optional[str] = None,
+        force: bool = False,
+    ) -> str:
+        """Download file from custom URL
+
+        Args:
+            url: Direct download URL (http or https)
+            output_path: Directory to save file (must be inside models dir)
+            filename: Optional filename override (plain name, no path parts)
+            force: Force re-download if file exists
+
+        Returns:
+            Path to downloaded file
+
+        Raises:
+            ValueError: For bad scheme, filename or save path
+            Exception: If download fails
+        """
+        validate_url_scheme(url)
+        if filename:
+            validate_filename(filename)
+        output_dir = self.resolve_output_dir(output_path)
+
+        # Fast path: a known filename lets us skip the request entirely
+        if filename:
+            output_file = os.path.join(output_dir, filename)
+            if not self.should_download(output_file, force):
+                logger.info("File already exists: %s", output_file)
+                return output_file
+
+        headers = {"User-Agent": USER_AGENT}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        request = urllib.request.Request(url, headers=headers)
+
+        try:
+            response = self.open_url(request)
+        except urllib.error.HTTPError as e:
+            self.raise_for_http_status(e.code, e.reason, HTTP_ERROR_HINTS)
+        except urllib.error.URLError as e:
+            raise Exception(f"Network error: {e.reason}")
+
+        if not filename:
+            header_name = self.extract_filename_from_header(
+                response.getheader("Content-Disposition") or ""
+            )
+            filename = safe_server_filename(
+                header_name, self.extract_filename(url, default=DEFAULT_FILENAME)
+            )
+            output_file = os.path.join(output_dir, filename)
+            if not self.should_download(output_file, force):
+                response.close()
+                logger.info("File already exists: %s", output_file)
+                return output_file
+
+        total_size = self.parse_content_length(response)
+        logger.info("Downloading %s to %s", filename, output_file)
+
+        # Size mismatch is only a warning for arbitrary URLs
+        return self.save_response(response, output_file, total_size, strict_size=False)

kikotools/tools/model_downloader/detector.py

@@ -0,0 +1,137 @@
+"""URL detection and downloader selection logic"""
+
+from __future__ import annotations
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from .base import BaseDownloader
+
+
+class DownloaderType(Enum):
+    """Types of supported downloaders"""
+
+    CIVITAI = "civitai"
+    HUGGINGFACE = "huggingface"
+    CUSTOM = "custom"
+
+
+class URLDetector:
+    """Detects URL type and returns appropriate downloader"""
+
+    def detect(self, url: Optional[str]) -> DownloaderType:
+        """Detect which downloader to use based on URL
+
+        Args:
+            url: URL to analyze
+
+        Returns:
+            DownloaderType enum value
+
+        Raises:
+            ValueError: If URL is invalid or empty
+        """
+        if not url:
+            raise ValueError("URL cannot be empty")
+
+        url = url.strip()
+        if not url:
+            raise ValueError("URL cannot be empty")
+
+        try:
+            parsed = urlparse(url)
+            if not parsed.scheme or not parsed.netloc:
+                raise ValueError("Invalid URL format")
+        except Exception:
+            raise ValueError("Invalid URL")
+
+        # Check for CivitAI
+        if self._is_civitai_url(url, parsed):
+            return DownloaderType.CIVITAI
+
+        # Check for HuggingFace
+        if self._is_huggingface_url(url, parsed):
+            return DownloaderType.HUGGINGFACE
+
+        # Default to custom downloader
+        return DownloaderType.CUSTOM
+
+    def _is_civitai_url(self, url: str, parsed) -> bool:
+        """Check if URL is from CivitAI
+
+        Args:
+            url: Full URL string
+            parsed: Parsed URL object
+
+        Returns:
+            True if CivitAI URL
+        """
+        # Validate exact domain match to prevent subdomain attacks
+        if parsed.netloc not in ("civitai.com", "www.civitai.com"):
+            return False
+
+        # Check for API download endpoint
+        if "/api/download/models/" in url:
+            return True
+
+        # Check for model page
+        if "/models/" in url:
+            return True
+
+        return False
+
+    def _is_huggingface_url(self, url: str, parsed) -> bool:
+        """Check if URL is from HuggingFace
+
+        Args:
+            url: Full URL string
+            parsed: Parsed URL object
+
+        Returns:
+            True if HuggingFace URL
+        """
+        # Validate exact domain match to prevent subdomain attacks
+        # Support both main domain and CDN domains
+        allowed_domains = (
+            "huggingface.co",
+            "www.huggingface.co",
+            "cdn.huggingface.co",
+            "cdn-lfs.huggingface.co",
+        )
+        if parsed.netloc in allowed_domains:
+            return True
+
+        return False
+
+    def get_downloader(
+        self, url: str, api_token: Optional[str] = None
+    ) -> "BaseDownloader":
+        """Get appropriate downloader instance for URL
+
+        Args:
+            url: URL to download from
+            api_token: Optional API token for authentication
+
+        Returns:
+            Appropriate downloader instance
+
+        Raises:
+            ValueError: If URL is invalid
+        """
+        downloader_type = self.detect(url)
+
+        if downloader_type == DownloaderType.CIVITAI:
+            from .civitai import CivitAIDownloader
+
+            return CivitAIDownloader(token=api_token)
+
+        elif downloader_type == DownloaderType.HUGGINGFACE:
+            from .huggingface import HuggingFaceDownloader
+
+            return HuggingFaceDownloader(token=api_token)
+
+        else:  # CUSTOM
+            from .custom import CustomDownloader
+
+            return CustomDownloader(token=api_token)

kikotools/tools/model_downloader/huggingface.py

@@ -0,0 +1,161 @@
+"""HuggingFace downloader implementation"""
+
+import logging
+import os
+import urllib.request
+import urllib.error
+from typing import Optional
+from urllib.parse import urlparse, quote
+
+from .base import (
+    USER_AGENT,
+    BaseDownloader,
+    safe_server_filename,
+    validate_filename,
+    validate_url_scheme,
+)
+
+logger = logging.getLogger(__name__)
+
+HTTP_ERROR_HINTS = {
+    401: "Authentication required. Please provide a valid HuggingFace token.",
+    403: "Access forbidden. The model might be gated or require special permissions.",
+    404: "File not found. The URL might be incorrect or the file was removed.",
+}
+
+
+class HuggingFaceDownloader(BaseDownloader):
+    """Downloader for HuggingFace models"""
+
+    def _parse_huggingface_url(self, url: str) -> dict:
+        """Parse HuggingFace URL to extract repo and file information
+
+        Args:
+            url: HuggingFace URL
+
+        Returns:
+            Dict with 'repo_id', 'filename', 'revision' keys
+        """
+        parsed = urlparse(url)
+        parts = parsed.path.strip("/").split("/")
+
+        result = {"repo_id": None, "filename": None, "revision": "main"}
+
+        # Handle blob URLs (web UI format) - convert to resolve format
+        # /{username}/{repo}/blob/{revision}/{file_path}
+        if len(parts) >= 5 and "blob" in parts:
+            blob_idx = parts.index("blob")
+            if blob_idx >= 2:
+                # Extract repo_id (username/repo)
+                result["repo_id"] = "/".join(parts[:blob_idx])
+                # Extract revision
+                if blob_idx + 1 < len(parts):
+                    result["revision"] = parts[blob_idx + 1]
+                # Extract filename (everything after revision)
+                if blob_idx + 2 < len(parts):
+                    result["filename"] = "/".join(parts[blob_idx + 2 :])
+
+        # Standard HF URL format: /{username}/{repo}/resolve/{revision}/{file_path}
+        elif len(parts) >= 5 and "resolve" in parts:
+            resolve_idx = parts.index("resolve")
+            if resolve_idx >= 2:
+                # Extract repo_id (username/repo)
+                result["repo_id"] = "/".join(parts[:resolve_idx])
+                # Extract revision
+                if resolve_idx + 1 < len(parts):
+                    result["revision"] = parts[resolve_idx + 1]
+                # Extract filename (everything after revision)
+                if resolve_idx + 2 < len(parts):
+                    result["filename"] = "/".join(parts[resolve_idx + 2 :])
+
+        # Alternative CDN format: Extract what we can
+        elif "cdn" in parsed.netloc:
+            # CDN URLs might have different structure
+            # Try to extract filename from path
+            if len(parts) > 0:
+                result["filename"] = parts[-1]
+
+        return result
+
+    def _construct_download_url(
+        self, repo_id: str, filename: str, revision: str = "main"
+    ) -> str:
+        """Construct HuggingFace download URL
+
+        Args:
+            repo_id: Repository ID (username/repo)
+            filename: File path within repo
+            revision: Branch/tag/commit (default: main)
+
+        Returns:
+            Download URL
+        """
+        # URL encode the filename to handle special characters
+        encoded_filename = quote(filename, safe="/")
+        return f"https://huggingface.co/{repo_id}/resolve/{revision}/{encoded_filename}"
+
+    def download(
+        self,
+        url: str,
+        output_path: str,
+        filename: Optional[str] = None,
+        force: bool = False,
+    ) -> str:
+        """Download file from HuggingFace
+
+        Args:
+            url: HuggingFace URL to download (http or https)
+            output_path: Directory to save file (must be inside models dir)
+            filename: Optional filename override (plain name, no path parts)
+            force: Force re-download if file exists
+
+        Returns:
+            Path to downloaded file
+
+        Raises:
+            ValueError: For bad scheme, filename or save path
+            Exception: If download fails
+        """
+        validate_url_scheme(url)
+        if filename:
+            validate_filename(filename)
+        output_dir = self.resolve_output_dir(output_path)
+
+        url_info = self._parse_huggingface_url(url)
+
+        # Convert blob URL to resolve URL if needed
+        if url_info["repo_id"] and url_info["filename"]:
+            download_url = self._construct_download_url(
+                url_info["repo_id"], url_info["filename"], url_info["revision"]
+            )
+            logger.info("Converted URL to: %s", download_url)
+        else:
+            download_url = url
+
+        if not filename:
+            if url_info["filename"]:
+                name = os.path.basename(url_info["filename"])
+            else:
+                name = self.extract_filename(url, default="model.safetensors")
+            filename = safe_server_filename(name, "model.safetensors")
+
+        output_file = os.path.join(output_dir, filename)
+        if not self.should_download(output_file, force):
+            logger.info("File already exists: %s", output_file)
+            return output_file
+
+        headers = {"User-Agent": USER_AGENT}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        request = urllib.request.Request(download_url, headers=headers)
+
+        try:
+            response = self.open_url(request)
+        except urllib.error.HTTPError as e:
+            self.raise_for_http_status(e.code, e.reason, HTTP_ERROR_HINTS)
+        except urllib.error.URLError as e:
+            raise Exception(f"Network error: {e.reason}")
+
+        total_size = self.parse_content_length(response)
+        logger.info("Downloading %s to %s", filename, output_file)
+        return self.save_response(response, output_file, total_size)

kikotools/tools/model_downloader/node.py

@@ -0,0 +1,157 @@
+"""ComfyUI Model Downloader Node"""
+
+import logging
+
+from ...base import ComfyAssetsBaseNode
+from .detector import URLDetector
+
+logger = logging.getLogger(__name__)
+
+
+class ModelDownloaderNode(ComfyAssetsBaseNode):
+    """ComfyUI node for downloading models from CivitAI, HuggingFace, and custom URLs"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """Define input types for the node"""
+        return {
+            "required": {
+                "url": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "placeholder": "https://civitai.com/... or https://huggingface.co/...",
+                    },
+                ),
+                "save_path": (
+                    "STRING",
+                    {
+                        "default": "models/checkpoints",
+                        "multiline": False,
+                        "placeholder": "Path to save downloaded models",
+                    },
+                ),
+            },
+            "optional": {
+                "filename": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "placeholder": "Leave empty for auto-detection",
+                    },
+                ),
+                "api_token": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": False,
+                        "placeholder": "API token (CivitAI or HuggingFace)",
+                    },
+                ),
+                "force_download": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "label_on": "Force Redownload",
+                        "label_off": "Skip if Exists",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "download_model"
+    CATEGORY = "🫶 ComfyAssets/🛠️ Utils"
+    OUTPUT_NODE = True
+
+    def download_model(
+        self,
+        url: str,
+        save_path: str,
+        filename: str = "",
+        api_token: str = "",
+        force_download: bool = False,
+    ):
+        """Download model from URL
+
+        Args:
+            url: URL to download from
+            save_path: Directory to save file
+            filename: Optional filename override
+            api_token: Optional API token
+            force_download: Force re-download if file exists
+
+        Returns:
+            Dictionary with 'ui' key for ComfyUI display
+        """
+        # Validate inputs
+        if not url or not url.strip():
+            error_msg = "URL cannot be empty"
+            return {"ui": {"text": [error_msg]}}
+
+        if not save_path or not save_path.strip():
+            error_msg = "Save path cannot be empty"
+            return {"ui": {"text": [error_msg]}}
+
+        url = url.strip()
+        save_path = save_path.strip()
+        filename = filename.strip() if filename else None
+        api_token = api_token.strip() if api_token else None
+
+        try:
+            # Detect downloader type and get appropriate downloader
+            detector = URLDetector()
+            downloader_type = detector.detect(url)
+
+            logger.info("Detected downloader type: %s", downloader_type.value)
+            logger.info("URL: %s", url)
+            logger.info("Save path: %s", save_path)
+            if filename:
+                logger.info("Filename: %s", filename)
+            if force_download:
+                logger.info("Force download: enabled")
+
+            # Get downloader instance
+            downloader = detector.get_downloader(url, api_token=api_token)
+
+            # Download file
+            file_path = downloader.download(
+                url=url, output_path=save_path, filename=filename, force=force_download
+            )
+
+            message = f"Successfully downloaded to {file_path}"
+            logger.info(message)
+
+            return {"ui": {"text": [message]}}
+
+        except ValueError as e:
+            error_msg = f"Invalid URL: {str(e)}"
+            logger.error(error_msg)
+            return {"ui": {"text": [error_msg]}}
+
+        except Exception as e:
+            error_msg = f"Download failed: {str(e)}"
+            logger.error(error_msg)
+            return {"ui": {"text": [error_msg]}}
+
+    @classmethod
+    def IS_CHANGED(
+        cls, url, save_path, filename="", api_token="", force_download=False
+    ):
+        """Force re-evaluation on every execution or when inputs change"""
+        # Include hash of inputs plus timestamp to force execution
+        # This ensures the node re-runs even if the download failed previously
+        import time
+        import hashlib
+
+        # Create a unique hash based on non-sensitive inputs and current time
+        # Note: api_token is excluded to avoid sensitive data in hash
+        # The token doesn't affect cache invalidation - URL changes are sufficient
+        input_str = f"{url}|{save_path}|{filename}|{force_download}|{time.time()}"
+        return hashlib.sha256(input_str.encode()).hexdigest()
+
+
+# Node display name
+NODE_DISPLAY_NAME = "Model Downloader 🌐"

kikotools/tools/project_file_path/__init__.py

@@ -0,0 +1,5 @@
+"""Project File Path tool for ComfyUI-KikoTools."""
+
+from .node import ProjectFilePathNode
+
+__all__ = ["ProjectFilePathNode"]

kikotools/tools/project_file_path/logic.py

@@ -0,0 +1,107 @@
+"""Path building logic for the Project File Path node."""
+
+import os
+import re
+from datetime import date
+from typing import Optional
+
+# Characters that are invalid in Windows paths (and awkward elsewhere)
+_UNSAFE_CHARS = re.compile(r'[<>:"|?*\x00-\x1f]')
+_SEPARATORS = re.compile(r"[\\/]+")
+
+# Only these are treated as a file extension and stripped from the filename,
+# so names like "render_v1.5" keep their dot.
+FILE_EXTENSIONS = frozenset(
+    {
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".webp",
+        ".gif",
+        ".bmp",
+        ".tif",
+        ".tiff",
+        ".mp4",
+        ".webm",
+        ".mov",
+        ".mkv",
+        ".avi",
+        ".wav",
+        ".mp3",
+        ".flac",
+        ".ogg",
+        ".txt",
+        ".json",
+        ".latent",
+    }
+)
+
+SEPARATOR_OPTIONS = ("auto", "forward_slash", "backslash")
+
+
+def _clean_part(part: str) -> str:
+    """Clean one path segment: drop unsafe chars, spaces to underscores."""
+    part = _UNSAFE_CHARS.sub("", part).strip(" .")
+    return part.replace(" ", "_")
+
+
+def sanitize_component(text: str) -> str:
+    """Clean a folder component, keeping nested folders as 'a/b'.
+
+    Splits on both / and \\, drops empty, '.' and '..' segments, so the
+    result is always relative and can never climb out of its parent.
+    """
+    parts = (_clean_part(p) for p in _SEPARATORS.split(text or ""))
+    return "/".join(p for p in parts if p and p not in (".", ".."))
+
+
+def sanitize_filename(text: str) -> str:
+    """Clean a filename: no folders, and a known file extension removed."""
+    name = _UNSAFE_CHARS.sub("", _SEPARATORS.sub("", text or ""))
+    stem, extension = os.path.splitext(name)
+    if extension.lower() in FILE_EXTENSIONS:
+        name = stem
+    elif name.strip().lower() in FILE_EXTENSIONS:  # just ".png": splitext sees no ext
+        name = ""
+    return _clean_part(name)
+
+
+def _resolve_separator(separator: str) -> str:
+    if separator == "auto":
+        return os.sep
+    if separator == "forward_slash":
+        return "/"
+    if separator == "backslash":
+        return "\\"
+    raise ValueError(
+        f"Unknown separator '{separator}'; use one of {', '.join(SEPARATOR_OPTIONS)}"
+    )
+
+
+def build_project_path(
+    root: str,
+    project_name: str,
+    subfolder: str,
+    filename: str,
+    date_folder: bool = False,
+    separator: str = "auto",
+    today: Optional[date] = None,
+) -> str:
+    """Build 'root/project/[YYYY-MM-DD/]subfolder/filename'.
+
+    Raises:
+        ValueError: If the filename is empty after cleaning, or the
+            separator is unknown.
+    """
+    sep = _resolve_separator(separator)
+    clean_filename = sanitize_filename(filename)
+    if not clean_filename:
+        raise ValueError(f"filename {filename!r} is empty after removing unsafe parts")
+
+    folders = [sanitize_component(root), sanitize_component(project_name)]
+    if date_folder:
+        folders.append((today or date.today()).isoformat())
+    folders.append(sanitize_component(subfolder))
+
+    path = "/".join([f for f in folders if f] + [clean_filename])
+    return path.replace("/", sep)

kikotools/tools/project_file_path/node.py

@@ -0,0 +1,89 @@
+"""ComfyUI node implementation for Project File Path."""
+
+from datetime import date
+from typing import Any, Dict, Tuple
+
+from ...base import ComfyAssetsBaseNode
+from .logic import SEPARATOR_OPTIONS, build_project_path
+
+
+def _today() -> date:
+    return date.today()
+
+
+class ProjectFilePathNode(ComfyAssetsBaseNode):
+    """
+    Builds a save prefix like 'MyProject/2026-10-13/images/image'.
+
+    Wire the output into a save node's filename_prefix. Every component is
+    sanitized so the result stays inside ComfyUI's output folder.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls) -> Dict[str, Any]:
+        return {
+            "required": {
+                "root": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "tooltip": "Optional top folder inside the output folder",
+                    },
+                ),
+                "project_name": ("STRING", {"default": "MyProject"}),
+                "subfolder": (
+                    "STRING",
+                    {"default": "images", "tooltip": "Use a/b for nested folders"},
+                ),
+                "filename": (
+                    "STRING",
+                    {
+                        "default": "image",
+                        "tooltip": "File extensions like .png are removed",
+                    },
+                ),
+            },
+            "optional": {
+                "date_folder": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "Insert a YYYY-MM-DD folder after the project",
+                    },
+                ),
+                "separator": (list(SEPARATOR_OPTIONS), {"default": "auto"}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "generate_path"
+    CATEGORY = "🫶 ComfyAssets/🛠️ Utils"
+
+    @classmethod
+    def IS_CHANGED(cls, date_folder: bool = False, **kwargs) -> str:
+        # Output depends only on the inputs, except for the date folder:
+        # re-run when the day changes so open workflows get the new date.
+        return _today().isoformat() if date_folder else ""
+
+    def generate_path(
+        self,
+        root: str,
+        project_name: str,
+        subfolder: str,
+        filename: str,
+        date_folder: bool = False,
+        separator: str = "auto",
+    ) -> Tuple[str]:
+        try:
+            path = build_project_path(
+                root,
+                project_name,
+                subfolder,
+                filename,
+                date_folder=date_folder,
+                separator=separator,
+                today=_today(),
+            )
+        except ValueError as e:
+            self.handle_error(str(e), e)
+        return (path,)

kikotools/tools/resolution_calculator/logic.py

@@ -6,6 +6,8 @@ Pure functions for dimension extraction and scaling calculations
 import torch
 from typing import Tuple, Optional, Dict
 
+MIN_DIMENSION = 8
+
 
 def extract_dimensions(
     image: Optional[torch.Tensor] = None,
@@ -100,8 +102,9 @@ def calculate_scaled_dimensions(
     new_width = int(width * scale_factor)
     new_height = int(height * scale_factor)
 
-    # Ensure divisible by 8
-    return ensure_divisible_by_8(new_width, new_height)
+    # Ensure divisible by 8, never collapsing to zero for tiny inputs
+    new_width, new_height = ensure_divisible_by_8(new_width, new_height)
+    return max(new_width, MIN_DIMENSION), max(new_height, MIN_DIMENSION)
 
 
 def validate_scale_factor(

kikotools/tools/sampler_combo/compact_node.py

@@ -59,7 +59,7 @@ class SamplerComboCompactNode(ComfyAssetsBaseNode):
             }
         }
 
-    RETURN_TYPES = ("SAMPLER", SCHEDULERS, "INT", "FLOAT")
+    RETURN_TYPES = (SAMPLERS, SCHEDULERS, "INT", "FLOAT")
     RETURN_NAMES = ("sampler", "scheduler", "steps", "cfg")
     FUNCTION = "get_combo"
     CATEGORY = "🫶 ComfyAssets/🌀 Samplers"
@@ -82,27 +82,13 @@ class SamplerComboCompactNode(ComfyAssetsBaseNode):
         try:
             # Use the same validation logic but with compact interface
             result = get_sampler_combo(sampler, sched, steps, cfg)
-            # Create the sampler object
-            try:
-                import comfy.samplers
-
-                sampler_obj = comfy.samplers.sampler_object(result[0])
-            except ImportError:
-                # Return sampler name for testing
-                sampler_obj = result[0]
-            return (sampler_obj, result[1], result[2], result[3])
+            # Return the sampler name as string, not object
+            return result
 
         except Exception as e:
             # Graceful fallback
             self.handle_error(f"Error in compact combo: {str(e)}")
-            try:
-                import comfy.samplers
-
-                sampler_obj = comfy.samplers.sampler_object("euler")
-            except ImportError:
-                # Return sampler name for testing
-                sampler_obj = "euler"
-            return (sampler_obj, "normal", 20, 7.0)
+            return ("euler", "normal", 20, 7.0)
 
     def __str__(self) -> str:
         """String representation of the compact node."""

kikotools/tools/sampler_combo/node.py

@@ -64,7 +64,7 @@ class SamplerComboNode(ComfyAssetsBaseNode):
             }
         }
 
-    RETURN_TYPES = ("SAMPLER", SCHEDULERS, "INT", "FLOAT")
+    RETURN_TYPES = (SAMPLERS, SCHEDULERS, "INT", "FLOAT")
     RETURN_NAMES = ("sampler_name", "scheduler", "steps", "cfg")
     FUNCTION = "get_sampler_combo"
     CATEGORY = "🫶 ComfyAssets/🌀 Samplers"
@@ -97,33 +97,18 @@ class SamplerComboNode(ComfyAssetsBaseNode):
                     f"steps={steps}, cfg={cfg}. "
                     f"Using safe defaults: euler, normal, 20 steps, CFG 7.0"
                 )
-                try:
-                    import comfy.samplers
-
-                    sampler = comfy.samplers.sampler_object("euler")
-                except ImportError:
-                    # Return mock object for testing
-                    sampler = "euler"
-                return (sampler, "normal", 20, 7.0)
+                return ("euler", "normal", 20, 7.0)
 
             # Process and return the combo
             result = get_sampler_combo(sampler_name, scheduler, steps, cfg)
 
-            # Create the sampler object
-            try:
-                import comfy.samplers
-
-                sampler = comfy.samplers.sampler_object(result[0])
-            except ImportError:
-                # Return sampler name for testing
-                sampler = result[0]
-
             self.log_info(
                 f"Configured sampler combo: {result[0]}, {result[1]}, "
                 f"{result[2]} steps, CFG {result[3]}"
             )
 
-            return (sampler, result[1], result[2], result[3])
+            # Return the sampler name as string, not object
+            return result
 
         except Exception as e:
             # Handle any unexpected errors gracefully
@@ -134,14 +119,7 @@ class SamplerComboNode(ComfyAssetsBaseNode):
                 f"{self.__class__.__name__}: Error processing sampler combo: {str(e)}. "
                 f"Using safe defaults: euler, normal, 20 steps, CFG 7.0"
             )
-            try:
-                import comfy.samplers
-
-                sampler = comfy.samplers.sampler_object("euler")
-            except ImportError:
-                # Return mock object for testing
-                sampler = "euler"
-            return (sampler, "normal", 20, 7.0)
+            return ("euler", "normal", 20, 7.0)
 
     def validate_inputs(
         self, sampler_name: str, scheduler: str, steps: int, cfg: float

kikotools/tools/seed_history/logic.py

@@ -10,14 +10,14 @@ def generate_random_seed() -> int:
     Generate a cryptographically strong random seed value.
 
     Returns:
-        Random integer in the valid ComfyUI seed range
+        Random integer in the valid ComfyUI seed range (0 to 2**32 - 1)
     """
-    return random.randint(0, 0xFFFFFFFFFFFFFFFF)
+    return random.randint(0, 0xFFFFFFFF)  # 2**32 - 1
 
 
 def validate_seed_value(seed: Any) -> bool:
     """
-    Validate that a seed value is within acceptable range.
+    Validate that a seed value is within acceptable range (0 to 2**32 - 1).
 
     Args:
         seed: Seed value to validate
@@ -30,7 +30,7 @@ def validate_seed_value(seed: Any) -> bool:
 
     try:
         seed_int = int(seed)
-        return 0 <= seed_int <= 0xFFFFFFFFFFFFFFFF
+        return 0 <= seed_int <= 0xFFFFFFFF  # 2**32 - 1
     except (ValueError, TypeError):
         return False
 
@@ -54,11 +54,11 @@ def sanitize_seed_value(seed: Any) -> int:
     try:
         seed_int = int(seed)
 
-        # Clamp to valid range
+        # Clamp to valid range (0 to 2**32 - 1)
         if seed_int < 0:
             seed_int = 0
-        elif seed_int > 0xFFFFFFFFFFFFFFFF:
-            seed_int = 0xFFFFFFFFFFFFFFFF
+        elif seed_int > 0xFFFFFFFF:
+            seed_int = 0xFFFFFFFF
 
         return seed_int
 

kikotools/tools/seed_history/node.py

@@ -27,12 +27,13 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
                     {
                         "default": 12345,
                         "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
+                        "max": 0xFFFFFFFF,  # 2**32 - 1
+                        "control_after_generate": True,
                         "tooltip": "Seed value for generation processes. "
-                        "History UI tracks all changes automatically.",
+                        "Use 'control after generate' to set behavior after each run.",
                     },
                 ),
-            }
+            },
         }
 
     RETURN_TYPES = ("INT",)
@@ -40,12 +41,13 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
     FUNCTION = "output_seed"
     CATEGORY = "🫶 ComfyAssets/🌱 Seeds"
 
-    def output_seed(self, seed: int) -> Tuple[int]:
+    def output_seed(self, seed: int, **kwargs) -> Tuple[int]:
         """
         Output the seed value for use in other nodes.
 
         Args:
             seed: Input seed value
+            **kwargs: Accepts legacy parameters (e.g. mode) for backward compatibility
 
         Returns:
             Tuple containing the seed value
@@ -53,7 +55,6 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
         try:
             # Validate and sanitize the seed
             if not validate_seed_value(seed):
-                # Log the validation error but don't raise
                 import logging
 
                 logger = logging.getLogger(__name__)
@@ -64,11 +65,9 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
                 return (12345,)
 
             clean_seed = sanitize_seed_value(seed)
-
             return (clean_seed,)
 
         except Exception as e:
-            # Handle any unexpected errors gracefully
             import logging
 
             logger = logging.getLogger(__name__)
@@ -142,7 +141,7 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
         Returns:
             Range information string
         """
-        max_seed = 0xFFFFFFFFFFFFFFFF
+        max_seed = 0xFFFFFFFF  # 2**32 - 1
         return f"Valid range: 0 to {max_seed:,} ({hex(max_seed)})"
 
     @classmethod
@@ -166,7 +165,7 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
         Returns:
             True if seed is in valid range
         """
-        return 0 <= seed <= 0xFFFFFFFFFFFFFFFF
+        return 0 <= seed <= 0xFFFFFFFF  # 2**32 - 1
 
     def __str__(self) -> str:
         """String representation of the node."""
@@ -178,6 +177,6 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
             f"SeedHistoryNode("
             f"category='{self.CATEGORY}', "
             f"function='{self.FUNCTION}', "
-            f"max_seed={hex(0xFFFFFFFFFFFFFFFF)}"
+            f"max_seed={hex(0xFFFFFFFF)}"  # 2**32 - 1
             f")"
         )

kikotools/tools/text_input/__init__.py

@@ -0,0 +1,5 @@
+"""Text Input tool for ComfyUI."""
+
+from .node import TextInputNode, NODE_DISPLAY_NAME
+
+__all__ = ["TextInputNode", "NODE_DISPLAY_NAME"]

kikotools/tools/text_input/node.py

@@ -0,0 +1,59 @@
+"""Text Input node implementation."""
+
+from ...base import ComfyAssetsBaseNode
+
+
+class TextInputNode(ComfyAssetsBaseNode):
+    """Provides a text input field for manual text entry in ComfyUI workflows."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """Define input types for the node."""
+        return {
+            "required": {
+                "text": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                        "dynamicPrompts": True,
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+    FUNCTION = "execute"
+    CATEGORY = "🫶 ComfyAssets/📝 Text"
+
+    DESCRIPTION = """
+Simple text input field for entering text manually.
+
+Features:
+- Multiline text editing
+- Supports wildcards and dynamic prompts
+- Direct connection to CLIP text encoders
+- Unicode and special character support
+
+Use Cases:
+- Positive/negative prompts
+- Custom text for workflows
+- Manual text editing
+- Prompt templates
+"""
+
+    def execute(self, text):
+        """Process the input text and return it.
+
+        Args:
+            text: Input text from the widget
+
+        Returns:
+            Tuple containing the text
+        """
+        return (text,)
+
+
+# Node display name
+NODE_DISPLAY_NAME = "Text Input"

kikotools/tools/width_height_selector/presets.py

@@ -78,7 +78,47 @@ PRESET_METADATA: Dict[str, PresetMetadata] = {
         "Portrait",
         "SDXL portrait 5:12 - very tall portrait",
     ),
+    "704×1408": PresetMetadata(
+        704,
+        1408,
+        "1:2",
+        0.5,
+        0.99,
+        "SDXL",
+        "Portrait",
+        "SDXL portrait 1:2 - extreme tall portrait",
+    ),
+    "960×1024": PresetMetadata(
+        960,
+        1024,
+        "15:16",
+        0.938,
+        0.98,
+        "SDXL",
+        "Portrait",
+        "SDXL near-square portrait - subtle portrait",
+    ),
+    "720×1280": PresetMetadata(
+        720,
+        1280,
+        "9:16",
+        0.5625,
+        0.92,
+        "SDXL",
+        "Portrait",
+        "SDXL portrait 9:16 - vertical video/mobile",
+    ),
     # SDXL Presets - Landscape
+    "1024×960": PresetMetadata(
+        1024,
+        960,
+        "16:15",
+        1.067,
+        0.98,
+        "SDXL",
+        "Landscape",
+        "SDXL near-square landscape - subtle landscape",
+    ),
     "1152×896": PresetMetadata(
         1152,
         896,
@@ -119,6 +159,26 @@ PRESET_METADATA: Dict[str, PresetMetadata] = {
         "Landscape",
         "SDXL landscape 12:5 - very wide landscape",
     ),
+    "1728×576": PresetMetadata(
+        1728,
+        576,
+        "3:1",
+        3.0,
+        1.0,
+        "SDXL",
+        "Landscape",
+        "SDXL landscape 3:1 - extreme wide panoramic",
+    ),
+    "1280×720": PresetMetadata(
+        1280,
+        720,
+        "16:9",
+        1.778,
+        0.92,
+        "SDXL",
+        "Landscape",
+        "SDXL landscape 16:9 - HD widescreen video",
+    ),
     # FLUX Presets - High Quality
     "1920×1080": PresetMetadata(
         1920,
@@ -558,21 +618,27 @@ def get_model_recommendation(preset_name: str) -> str:
     return "Custom dimensions"
 
 
+def _console_safe(text: str) -> str:
+    """ASCII for console output: Windows legacy code pages can't print "×"."""
+    return text.replace("×", "x").encode("ascii", "replace").decode()
+
+
 def validate_preset_dimensions() -> bool:
     """Validate that all presets meet ComfyUI requirements."""
-    for preset_name, metadata in PRESET_METADATA.items():
+    for name, metadata in PRESET_METADATA.items():
+        preset_name = _console_safe(name)
         width, height = metadata.width, metadata.height
 
         # Check divisible by 8
         if width % 8 != 0 or height % 8 != 0:
             print(
-                f"ERROR: {preset_name} dimensions not divisible by 8: {width}×{height}"
+                f"ERROR: {preset_name} dimensions not divisible by 8: {width}x{height}"
             )
             return False
 
         # Check reasonable bounds
         if not (64 <= width <= 8192) or not (64 <= height <= 8192):
-            print(f"ERROR: {preset_name} dimensions out of bounds: {width}×{height}")
+            print(f"ERROR: {preset_name} dimensions out of bounds: {width}x{height}")
             return False
 
     return True

kikotools/tools/width_height_to_vec2/__init__.py

@@ -0,0 +1,8 @@
+"""
+Width Height to VEC2 converter node
+Converts width and height inputs to VEC2 tuple for jovi_glsl and similar nodes
+"""
+
+from .node import WidthHeightToVec2Node
+
+__all__ = ["WidthHeightToVec2Node"]

kikotools/tools/width_height_to_vec2/node.py

@@ -0,0 +1,128 @@
+"""
+Width Height to VEC2 Node
+
+Converts width and height inputs to a VEC2 tuple for use with
+nodes like jovi_glsl that expect vector inputs.
+"""
+
+from typing import Any, Dict, Tuple, Union
+
+from ...base import ComfyAssetsBaseNode
+
+
+class WidthHeightToVec2Node(ComfyAssetsBaseNode):
+    """
+    Convert width and height values to VEC2 format.
+
+    Accepts INT, FLOAT, STRING, or ANY types and outputs a VEC2 tuple
+    suitable for nodes expecting vector inputs.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls) -> Dict[str, Any]:
+        """Define ComfyUI input interface."""
+        return {
+            "required": {
+                "width": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 1,
+                        "max": 8192,
+                        "step": 1,
+                        "tooltip": "Width value (x component of VEC2)",
+                    },
+                ),
+                "height": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 1,
+                        "max": 8192,
+                        "step": 1,
+                        "tooltip": "Height value (y component of VEC2)",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    RETURN_NAMES = ("vec2",)
+    FUNCTION = "convert_to_vec2"
+    CATEGORY = "🫶 ComfyAssets/🖼️ Resolution"
+
+    def convert_to_vec2(
+        self,
+        width: Union[int, float, str, Any],
+        height: Union[int, float, str, Any],
+    ) -> Tuple[Tuple[int, int]]:
+        """
+        Convert width and height to VEC2 tuple.
+
+        Args:
+            width: Width value (will be converted to int)
+            height: Height value (will be converted to int)
+
+        Returns:
+            Tuple containing the VEC2 tuple (width, height)
+        """
+        try:
+            # Convert to integers, handling various input types
+            w = self._to_int(width, "width")
+            h = self._to_int(height, "height")
+
+            # Clamp values to valid range
+            w = max(1, min(8192, w))
+            h = max(1, min(8192, h))
+
+            self.log_info(f"Converted to VEC2: ({w}, {h})")
+
+            # Return as tuple wrapped in tuple (ComfyUI return format)
+            return ((w, h),)
+
+        except Exception as e:
+            error_msg = f"Failed to convert to VEC2: {str(e)}"
+            self.handle_error(error_msg, e)
+
+    def _to_int(self, value: Any, name: str) -> int:
+        """
+        Convert a value to integer.
+
+        Args:
+            value: Value to convert (int, float, str, or any)
+            name: Parameter name for error messages
+
+        Returns:
+            Integer value
+
+        Raises:
+            ValueError: If conversion fails
+        """
+        if isinstance(value, int):
+            return value
+        elif isinstance(value, float):
+            return int(value)
+        elif isinstance(value, str):
+            try:
+                # Try parsing as float first (handles "1024.0")
+                return int(float(value.strip()))
+            except ValueError:
+                raise ValueError(f"Cannot convert {name} string '{value}' to integer")
+        else:
+            # Try generic conversion for ANY type
+            try:
+                return int(value)
+            except (ValueError, TypeError):
+                raise ValueError(
+                    f"Cannot convert {name} of type {type(value).__name__} to integer"
+                )
+
+
+# Node registration
+NODE_CLASS_MAPPINGS = {
+    "WidthHeightToVec2": WidthHeightToVec2Node,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "WidthHeightToVec2": "Width Height to VEC2",
+}