Delete custom_nodes

custom_nodes/Cheny_custom_nodes/yolov8_person_detect.py

@@ -1,188 +0,0 @@
-import copy
-import os
-
-import torch
-from PIL import Image
-import glob
-import numpy as np
-from ultralytics import YOLO
-import folder_paths
-
-models_dirs=os.path.join(folder_paths.models_dir,'yolo')
-def get_files(models_dir,file_exp_list):
-    file_list=[]
-    for exp in file_exp_list:
-        # extend可将可迭代对象中的元素，逐个添加进当前列表
-        file_list.extend(glob.glob(os.path.join(models_dir,'*'+exp))) #glob就是模式匹配文件，支持通配符，每个文件返回一个列表，所以用extend
-    file_dict={}
-    for i in range(len(file_list)):
-        _,filename=os.path.split(file_list[i]) # 将文件路径拆成("C:/models/yolo", "model1.pt")
-        # 创建文件名到文件路径的映射
-        file_dict[filename]=file_list[i]
-
-    return file_dict
-
-def tensor2pil(image):
-    if isinstance(image,Image.Image):
-        return image
-    else:
-        if len(image.shape)<3:
-            image=image.unsqueeze(0)
-        return Image.fromarray((image[0].cpu().numpy()*255).astype(np.uint8))
-
-def pil2tensor(image):
-    new_image=image.convert('RGB')
-    image_array=np.array(new_image).astype(np.float32)/255.0
-    image_tensor=torch.tensor(image_array)
-    return image_tensor
-
-def mask2tensor(mask):
-    mask=mask.convert('L')
-    mask_array=np.array(mask).astype(np.float32)/255.0
-    mask_tensor=torch.tensor(mask_array)
-    return mask_tensor
-
-class Yolov8_person_detect:
-    CATEGORY="My Nodes/yolov8 person detect"
-    RETURN_TYPES=("MASK",)
-    RETURN_NAMES=("back_mask",)
-    FUNCTION="yolov8_person_detect"
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        model_exp=["seg.pt"]
-        FILES_DICT=get_files(models_dirs,model_exp)
-        FILE_LIST=list(FILES_DICT.keys())
-
-        return{
-            "required":{
-                "back_image":("IMAGE",),
-                "mask":("MASK",),
-                "yolo_model":(FILE_LIST,),
-            },
-            "optional":{
-                "true_rate":("FLOAT",{
-                    "default":0.85,
-                    "min":0.01,
-                    "max":1.0,
-                    "step":0.01,
-                    "display":"number"
-                }),
-                "img_ratio":("FLOAT",{
-                    "default":float(2/3),
-                    "min":0.01,
-                    "max":1.0,
-                    "step":0.01,
-                    "display":"number"
-                }),
-                "x_ratio":("FLOAT",{
-                    "default":float(0.5),
-                    "min":0.01,
-                    "max":1.0,
-                    "step":0.01,
-                    "display":"number"
-                }),
-                "y_ratio":("FLOAT",{
-                    "default":float(1/10),
-                    "min":0.01,
-                    "max":1.0,
-                    "step":0.01,
-                    "display":"number"
-                })
-            }
-        }
-
-    def yolov8_person_detect(self,mask,back_image,yolo_model,true_rate,img_ratio,x_ratio,y_ratio):
-        back_image=tensor2pil(back_image)
-
-        yolo_model=YOLO(os.path.join(models_dirs,yolo_model))
-        result = yolo_model(
-            back_image,
-            retina_masks=True,
-            classes=[0],
-            conf=true_rate,
-            verbose=False
-        )[0]
-
-        if result.masks is not None and len(result.masks)>0:
-            if result.boxes is not None and len(result.boxes)>0:
-                if result.boxes.conf[0]>=true_rate:
-                    masks_data=result.masks.data
-                    n_mask=masks_data[0]
-                    n_mask=n_mask.unsqueeze(0) 
-                    return(n_mask,)
-
-        # 直接生成mask，按背景 2/3
-        # bd_w,bd_h=back_image.size
-        # n_mask=Image.new('L',(bd_w,bd_h),"black")
-        # target=img_ratio*max(bd_h,bd_w)
-
-        # new_w,new_h=int(img_ratio*bd_w),int(img_ratio*bd_h)
-
-        # paste_mask=Image.new('L',(new_w,new_h),"white")
-
-
-        # x=int(bd_w-new_w)
-        # y=int(bd_h-new_h)
-
-        # x_trap_padding=int(x*x_ratio)
-        # x=x-x_trap_padding
-
-        # y_trap_padding=int(y*y_ratio)
-        # y=y-y_trap_padding
-
-        # n_mask.paste(paste_mask,(x,y))
-        # n_mask=mask2tensor(n_mask)
-       
-        # if len(n_mask.shape)<3:
-        #     n_mask=n_mask.unsqueeze(0) 
-        # print("Yolov8_person_detect done")
-        # return (n_mask,)
-
-
-        # 利用原图人物mask，生成新mask
-        mask=tensor2pil(mask).convert('L')
-
-        bd_w,bd_h=back_image.size
-
-        n_mask=Image.new('L',(bd_w,bd_h),"black")
-        target=img_ratio*max(bd_h,bd_w)
-
-        
-        m_bbox=mask.getbbox()
-       
-        mask=mask.crop(m_bbox)
-
-        m_w,m_h=mask.size
-        ratio=target/max(m_w,m_h)
-        new_w,new_h=int(ratio*m_w),int(ratio*m_h)
-        mask=mask.resize((new_w,new_h),Image.LANCZOS)
-
-        
-        if new_w>=bd_w or new_h>=bd_h:
-            raise ValueError(f'缩放图片的长宽超过背景图大小，请下调img_ratio值')
-
-        x=int(bd_w-new_w)
-        y=int(bd_h-new_h)
-
-        x_trap_padding=int(x*x_ratio)
-        x=x-x_trap_padding
-
-        y_trap_padding=int(y*y_ratio)
-        y=y-y_trap_padding
-
-        n_mask.paste(mask,(x,y))
-        n_mask=mask2tensor(n_mask)
-       
-        if len(n_mask.shape)<3:
-            n_mask=n_mask.unsqueeze(0) 
-        print("Yolov8_person_detect done")
-        return (n_mask,)
-
-NODE_CLASS_MAPPINGS={
-    "Yolov8_person_detect":Yolov8_person_detect
-}
-
-NODE_DISPLAY_NAME_MAPPINGS={
-    "Yolov8_person_detect":"Yolov8_person_detect(My Node)"
-}

custom_nodes/ComfyUI-AK-Pack/.gitignore

@@ -1,18 +0,0 @@
-# Python bytecode
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-
-# Virtual environment
-.venv/
-venv/
-env/
-
-# Editor/IDE specific files
-.idea/
-.vscode/
-
-# Operating System files
-.DS_Store
-Thumbs.db

custom_nodes/ComfyUI-AK-Pack/README.md

@@ -1,183 +0,0 @@
-#### Other My Nodes
-- 📘 [ComfyUI-AK-Pack](https://github.com/akawana/ComfyUI-AK-Pack)
-- 📘 [ComfyUI-AK-XZ-Axis](https://github.com/akawana/ComfyUI-AK-XZ-Axis)
-- 📘 [ComfyUI RGBYP Mask Editor](https://github.com/akawana/ComfyUI-RGBYP-Mask-Editor)
-- 📘 [ComfyUI Folded Prompts](https://github.com/akawana/ComfyUI-Folded-Prompts)
-
-# ComfyUI AK Pack
-This is a pack of useful ComfyUI nodes and UI extensions. It was created for **complex and large** workflows. The main goal of this pack is to unify and simplify working with my other packs: 📘 [ComfyUI-AK-XZ-Axis](https://github.com/akawana/ComfyUI-AK-XZ-Axis), 📘 [ComfyUI RGBYP Mask Editor](https://github.com/akawana/ComfyUI-RGBYP-Mask-Editor), 📘 [ComfyUI Folded Prompts](https://github.com/akawana/ComfyUI-Folded-Prompts).
-
-The most interesting parts of this pack for most users are:
-- Multiple Samplers Control
-- Project Settings
-- AK Base
-
-The other nodes are also useful, but they are of secondary importance. You should be able to figure them out on your own.
-
-I have also created example workflows:
-
----
-#### UI: Multiple Samplers Control
-
-This is not a node in the traditional sense, but a **ComfyUI UI extension**. The panel allows you to control multiple KSamplers or Detailers from a single place.
-
-In my workflows, I often use 6–8 KSamplers and Detailers at the same time. I spent a long time looking for a fast and centralized way to control them, and this panel is the result of that effort.
-
-The panel is integrated into the left toolbar of ComfyUI and can be disabled in Settings.
-
-The panel includes a Settings tab where you configure, using comma-separated lists, which KSampler nodes you want to control. You can specify node names or node IDs in these lists.
-
-For example: "KSampler, 12, 33, My Detailer, BlaBlaSampler" - will find all the samplers mentioned.
-
-Once configured, the detected nodes will appear in a dropdown list in the Control tab, allowing you to adjust the settings of your KSamplers or Detailers from a single centralized interface.
-
-| [![](./img/MSamplers.jpg)](./img/MSamplers.jpg) | [![](./img/MSamplersSettings.jpg)](./img/MSamplersSettings.jpg) | [![](./img/MSamplersChooser.jpg)](./img/MSamplersChooser.jpg) |
-|---|---|---|
-
----
-#### UI: Project Settings
-
-This is not a node in the strict sense. It is a **UI extension** — a panel that allows you to quickly enter the main parameters of your project.
-The panel is embedded into the left toolbar of ComfyUI and can be disabled in the settings.
-
-I work a lot with img2img and often use fairly large workflows. I got tired of constantly navigating to different parts of the workflow every time I needed to adjust input parameters, so I created this panel. Now I can load an image and enter all the required values in one place.
-
-All panel data is stored directly in the workflow graph, except for the image itself. **The image** is copied to the **input/garbage/** folder. If you delete this folder later, nothing bad will happen — you will simply need to select the image again.
-
-To retrieve the data from this panel, I created a separate node called **AKProjectSettingsOut**. Just place it anywhere you need in your workflow to access the panel values.
-
-| [![](./img/ProjectSettings.jpg)](./img/ProjectSettings.jpg) | [![](./img/ProjectSettingsOptions.jpg)](./img/ProjectSettingsOptions.jpg) | [![](./img/AKProjectSettingsOut.jpg)](./img/AKProjectSettingsOut.jpg) |
-|---|---|---|
-
----
-#### Node: AK Base
-
-This node is designed as a central hub for working within a workflow, which is why it is called AK Base. At its core, it provides a preview-based comparison of two images. Similar nodes already exist, but this one adds support for a gallery of multiple images.
-
-In addition, it includes:
-- a button to copy a single image to the clipboard,
-- a button to copy the entire gallery to the clipboard,
-- a dialog that allows you to inspect the results while working in a different part of the workflow.
-
-In the Properties panel, this node provides a setting called node_list.
-This is a text field where you can specify a list of nodes, using either node names or node IDs.
-
-Once configured, AK Base can automatically adjust the parameters seed, denoise, cfg, and xz_steps based on the image selected in the gallery.
-This functionality was implemented specifically to support my 📘 [ComfyUI-AK-XZ-Axis](https://github.com/akawana/ComfyUI-AK-XZ-Axis) nodes.
-
-| [![](./img/AKBase.jpg)](./img/AKBase.jpg) | [![](./img/AKBaseGallery.jpg)](./img/AKBaseGallery.jpg) | [![](./img/AKBasePIP.jpg)](./img/AKBasePIP.jpg) |
-|---|---|---|
-
----
-#### Node: Setter & Getter
-
-These nodes already exist in several other packs. My goal was to make them faster. In my implementation, the nodes do not use JavaScript to store or pass data. All data is passed only through Python and direct connections between nodes. Simply put, they hide links and hide outputs and inputs. 
-
-In my setup, JavaScript is responsible only for updating the list of variables and does not affect the Run process in any way. Based on my comparisons, in complex workflows with 20–30 Getter/Setter nodes, my nodes perform much faster.
-
----
-#### Node: Repeat Group State
-
-A connection-free interactive node that synchronizes the state of its own group with the state of other groups matching a given substring. This allows groups to depend on other groups without wires, similar to rgthree repeaters.
-
-- Finds groups with names containing the target substring.
-- Checks whether any of them are Active.
-- If **all** matching groups are disabled -> it disables **its own group**.
-- If **any** matching group is active -> it enables **its own group**.
-
-<img src="./img/preview_repeater.jpg" height="200"/>
-
----
-#### Node: IsOneOfGroupsActive
-
-Checks the state of all groups whose names **contain a specified substring**.  
-
-- If **at least one** matching group is Active -> output is `true`.  
-- If **all** matching groups are Muted/Bypassed -> output is `false`.
-
-<img src="./img/preview_is_group_active.jpg" height="200"/>
-
----
-#### Node: AK Index Multiple
-
-Extracts a specific range from any **List** (images, masks, latents, text etc..) and creates individual outputs for that range.  
-Optionally replaces missing values with a fallback (`if_none`).
-
-<img src="./img/AKIndexMultiple.jpg" height="200">
-
----
-#### Node: AK CLIP Encode Multiple
-
-Extracts a specific range from any **List** of strings and CLIP encodes individual outputs for that range.  
-
-Same as **AK Index Multiple** but for CLIP encoding. Works faster than regular CLIP Encoders because does only one encoding for all NONE input strings. Caches the stings and does not encode them if no changes. Also outputs combined conditioning.
-
-<img src="./img/AKCLIPEncodeMultiple.jpg" height="200">
-
----
-#### Node: AK KSampler Settings & AK KSampler Settings Out
-
-Allows you to define sampler settings anywhere in the workflow.
-The Out node lets you retrieve these settings wherever they are needed.
-
-- `Seed`, `Sampler`, `Scheduler`, `Steps`, `Cfg`, `Denoise`, `xz_steps`
-
-> [!NOTE]
-> This node includes an additional field called xz_steps.
-> It is used to control the number of steps when working with my 📘 [ComfyUI-AK-XZ-Axis](https://github.com/akawana/ComfyUI-AK-XZ-Axis) nodes.
-> This field is also convenient when used together with the **AK Base** node, because it can automatically set xz_steps = 1 when a single image is selected in the gallery.
-
----
-#### Node: AK Replace Alpha With Color & AK Replace Color With Alpha
-
-`AK Replace Alpha With Color` Replaces alpha with a color.
-
-`AK Replace Color With Alpha` Performs the reverse operation: Replaces a color with alpha. You can specify the color manually, or use automatic modes that detect the color from pixels in different corners of the image. Image **cropping** is also available. This is useful because when rendering images on a flat background, the outermost pixels around the edges often have color artifacts and are better removed.
-
-> [!NOTE]
-> Both of these nodes are useful when working with images that have a transparent background. You can first replace alpha with a color, perform the generation, and then, before saving, remove that color and convert it back to alpha.
-
-<img src="./img/AKReplaceAlphaWithColor.jpg" height="200">
-
----
-#### Other nodes
-
-##### Node: AK Pipe & AK Pipe Loop
-
-AK Pipe is a zero-copy pipeline node that passes a structured pipe object through the graph and updates only explicitly connected inputs. It avoids unnecessary allocations by reusing the original pipe when no values change and creates a new container only on real object replacement. This design minimizes memory churn and Python overhead, making it significantly faster than traditional pipe merge nodes.
-
-`AK Pipe Loop` Always outputs the most recently modified connected AK Pipe.
-
-##### Node: CLIP Text Encode Cached
-
-Simple node for encoding conditioning with a small caching experiment.
-
-##### Node: CLIP Text Encode and Combine Cached
-
-Can combine the input conditioning with the text entered in the node.
-
-<img src="./img/CLIPTextEncodeAndCombineCached.jpg" height="200">
-
-##### Node: AK Resize On Boolean
-
-Resizes the image and optional mask based on a boolean parameter (enable / disable). Useful when working with the **Project Settings** panel.
-
-<img src="./img/AKResizeOnBoolean.jpg" height="200">
-
-##### Node: AK Contrast And Saturate Image
-
-Node for adjusting image contrast and saturation.
-
-##### Node: Preview Raw Text
-
-Displays text and can format **JSON**. It also supports displaying a list of texts.
-
----
-
-# Installation
-
-From your ComfyUI root directory:
-
-```bash
-cd ComfyUI/custom_nodes
-git clone https://github.com/akawana/ComfyUI-Utils-extra.git

custom_nodes/ComfyUI-AK-Pack/__init__.py

@@ -1,109 +0,0 @@
-WEB_DIRECTORY = "./js"
-
-from .nodes.AKIndexMultiple import NODE_CLASS_MAPPINGS as AKIndexMultiple_MAPPINGS
-from .nodes.AKIndexMultiple import NODE_DISPLAY_NAME_MAPPINGS as AKIndexMultiple_DISPLAY
-
-from .nodes.AKCLIPEncodeMultiple import NODE_CLASS_MAPPINGS as AKCLIPEncodeMultiple_MAPPINGS
-from .nodes.AKCLIPEncodeMultiple import NODE_DISPLAY_NAME_MAPPINGS as AKCLIPEncodeMultiple_DISPLAY
-
-from .nodes.IsOneOfGroupsActive import NODE_CLASS_MAPPINGS as GROUPCHK_MAPPINGS
-from .nodes.IsOneOfGroupsActive import NODE_DISPLAY_NAME_MAPPINGS as GROUPCHK_DISPLAY
-
-from .nodes.RepeatGroupState import NODE_CLASS_MAPPINGS as RPSTATE_MAPPINGS
-from .nodes.RepeatGroupState import NODE_DISPLAY_NAME_MAPPINGS as RPSTATE_DISPLAY
-
-from .nodes.PreviewRawText import NODE_CLASS_MAPPINGS as PRTSTATE_MAPPINGS
-from .nodes.PreviewRawText import NODE_DISPLAY_NAME_MAPPINGS as PRTSTATE_DISPLAY
-
-from .nodes.CLIPTextEncodeCached import NODE_CLASS_MAPPINGS as CLCSTATE_MAPPINGS
-from .nodes.CLIPTextEncodeCached import NODE_DISPLAY_NAME_MAPPINGS as CLCSTATE_DISPLAY
-
-from .nodes.CLIPTextEncodeAndCombineCached import NODE_CLASS_MAPPINGS as CLCOMBINE_STATE_MAPPINGS
-from .nodes.CLIPTextEncodeAndCombineCached import NODE_DISPLAY_NAME_MAPPINGS as CLCOMBINE_STATE_DISPLAY
-
-from .nodes.AKBase import NODE_CLASS_MAPPINGS as AKBSTATE_MAPPINGS
-from .nodes.AKBase import NODE_DISPLAY_NAME_MAPPINGS as AKBSTATE_DISPLAY
-
-from .nodes.AKPipe import NODE_CLASS_MAPPINGS as AKPIPESTATE_MAPPINGS
-from .nodes.AKPipe import NODE_DISPLAY_NAME_MAPPINGS as AKPIPESTATE_DISPLAY
-
-from .nodes.AKPipeLoop import NODE_CLASS_MAPPINGS as AKPIPEL_STATE_MAPPINGS
-from .nodes.AKPipeLoop import NODE_DISPLAY_NAME_MAPPINGS as AKPIPEL_STATE_DISPLAY
-
-from .nodes.Setter import NODE_CLASS_MAPPINGS as SETTERSTATE_MAPPINGS
-from .nodes.Setter import NODE_DISPLAY_NAME_MAPPINGS as SETTERSTATE_DISPLAY
-
-from .nodes.Getter import NODE_CLASS_MAPPINGS as GETTERSTATE_MAPPINGS
-from .nodes.Getter import NODE_DISPLAY_NAME_MAPPINGS as GETTERSTATE_DISPLAY
-
-from .nodes.AKResizeOnBoolean import NODE_CLASS_MAPPINGS as RESIZESTATE_MAPPINGS
-from .nodes.AKResizeOnBoolean import NODE_DISPLAY_NAME_MAPPINGS as RESIZESTATE_DISPLAY
-
-from .nodes.IsMaskEmpty import NODE_CLASS_MAPPINGS as ISMSTATE_MAPPINGS
-from .nodes.IsMaskEmpty import NODE_DISPLAY_NAME_MAPPINGS as ISMSTATE_DISPLAY
-
-from .nodes.AKContrastAndSaturateImage import NODE_CLASS_MAPPINGS as AKSAT_STATE_MAPPINGS
-from .nodes.AKContrastAndSaturateImage import NODE_DISPLAY_NAME_MAPPINGS as AKSAT_STATE_DISPLAY
-
-from .nodes.AKReplaceAlphaWithColor import NODE_CLASS_MAPPINGS as AKRALPHA_STATE_MAPPINGS
-from .nodes.AKReplaceAlphaWithColor import NODE_DISPLAY_NAME_MAPPINGS as AKRALPHA_STATE_DISPLAY
-
-from .nodes.AKReplaceColorWithAlpha import NODE_CLASS_MAPPINGS as AKRCOLOR_STATE_MAPPINGS
-from .nodes.AKReplaceColorWithAlpha import NODE_DISPLAY_NAME_MAPPINGS as AKRCOLOR_STATE_DISPLAY
-
-from .nodes.AKControlMultipleKSamplers import NODE_CLASS_MAPPINGS as AK_CONTROL_SAMPLERS_COLOR_STATE_MAPPINGS
-from .nodes.AKControlMultipleKSamplers import NODE_DISPLAY_NAME_MAPPINGS as AK_CONTROL_SAMPLERS_COLOR_STATE_DISPLAY
-
-from .nodes.AKKSamplerSettings import NODE_CLASS_MAPPINGS as AKKSamplerSettings_STATE_MAPPINGS
-from .nodes.AKKSamplerSettings import NODE_DISPLAY_NAME_MAPPINGS as AKKSamplerSettings_STATE_DISPLAY
-
-from .nodes.AKProjectSettingsOut import NODE_CLASS_MAPPINGS as AKProjectSettingsOut_STATE_MAPPINGS
-from .nodes.AKProjectSettingsOut import NODE_DISPLAY_NAME_MAPPINGS as AKProjectSettingsOut_STATE_DISPLAY
-
-NODE_CLASS_MAPPINGS = {
-    **AKIndexMultiple_MAPPINGS,
-    **AKCLIPEncodeMultiple_MAPPINGS,
-    **GROUPCHK_MAPPINGS,
-    **RPSTATE_MAPPINGS,
-    **PRTSTATE_MAPPINGS,
-    **CLCSTATE_MAPPINGS,
-    **CLCOMBINE_STATE_MAPPINGS,
-    **AKBSTATE_MAPPINGS,
-    **AKPIPESTATE_MAPPINGS,
-    **AKPIPEL_STATE_MAPPINGS,
-    **SETTERSTATE_MAPPINGS,
-    **GETTERSTATE_MAPPINGS,
-    **RESIZESTATE_MAPPINGS,
-    **ISMSTATE_MAPPINGS,
-    **AKSAT_STATE_MAPPINGS,
-    **AKRALPHA_STATE_MAPPINGS,
-    **AKRCOLOR_STATE_MAPPINGS,
-    **AK_CONTROL_SAMPLERS_COLOR_STATE_MAPPINGS,
-    **AKKSamplerSettings_STATE_MAPPINGS,
-    **AKProjectSettingsOut_STATE_MAPPINGS,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    **AKIndexMultiple_DISPLAY,
-    **AKCLIPEncodeMultiple_DISPLAY,
-    **GROUPCHK_DISPLAY,
-    **RPSTATE_DISPLAY,
-    **PRTSTATE_DISPLAY,
-    **CLCSTATE_DISPLAY,
-    **CLCOMBINE_STATE_DISPLAY,
-    **AKBSTATE_DISPLAY,
-    **AKPIPESTATE_DISPLAY,
-    **AKPIPEL_STATE_DISPLAY,
-    **SETTERSTATE_DISPLAY,
-    **GETTERSTATE_DISPLAY,
-    **RESIZESTATE_DISPLAY,
-    **ISMSTATE_DISPLAY,
-    **AKSAT_STATE_DISPLAY,
-    **AKRALPHA_STATE_DISPLAY,
-    **AKRCOLOR_STATE_DISPLAY,
-    **AK_CONTROL_SAMPLERS_COLOR_STATE_DISPLAY,
-    **AKKSamplerSettings_STATE_DISPLAY,
-    **AKProjectSettingsOut_STATE_DISPLAY,
-}
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

custom_nodes/ComfyUI-AK-Pack/nodes/AKBase.py

@@ -1,248 +0,0 @@
-
-# === AKXZ embedded JSON fallback (read from IMAGE tensors) ===
-import json as _akxz_json
-import torch as _akxz_torch
-
-_AKXZ_MAGIC = b"AKXZ"
-_AKXZ_HEADER_LEN = 8
-
-def _akxz_float01_to_bytes(x: _akxz_torch.Tensor) -> bytes:
-    x = _akxz_torch.clamp(x * 255.0 + 0.5, 0, 255).to(_akxz_torch.uint8).cpu()
-    return x.numpy().tobytes()
-
-def akxz_extract_image_cfg_list(images: _akxz_torch.Tensor):
-    if not isinstance(images, _akxz_torch.Tensor) or images.ndim != 4:
-        return []
-    b = int(images.shape[0])
-    out = []
-    for i in range(b):
-        row = images[i, 0, :, :3].reshape(-1)
-        raw = _akxz_float01_to_bytes(row)
-        if len(raw) < _AKXZ_HEADER_LEN or raw[:4] != _AKXZ_MAGIC:
-            continue
-        size = int.from_bytes(raw[4:8], "big")
-        if size <= 0 or (8 + size) > len(raw):
-            continue
-        payload = raw[8:8+size]
-        try:
-            obj = _akxz_json.loads(payload.decode("utf-8"))
-            if isinstance(obj, dict):
-                out.append(obj)
-        except Exception:
-            pass
-    return out
-
-
-import os
-import json
-
-import numpy as np
-from PIL import Image
-from PIL.PngImagePlugin import PngInfo
-
-import folder_paths
-
-
-AKBASE_STATE_FILENAME = "ak_base_state.json"
-AKBASE_XZ_CONFIG_FILENAME = "ak_base_xz_config.json"
-
-AKBASE_A_FILENAME = "ak_base_image_a.png"
-AKBASE_B_FILENAME = "ak_base_image_b.png"
-
-AKBASE_GALLERY_PREFIX = "ak_base_image_xy_"
-AKBASE_GALLERY_MAX = 512
-
-
-def _tensor_to_pil(img_tensor):
-    arr = img_tensor.detach().cpu().numpy()
-    arr = np.clip(arr * 255.0, 0, 255).astype(np.uint8)
-    return Image.fromarray(arr)
-
-
-def _temp_dir():
-    d = folder_paths.get_temp_directory()
-    os.makedirs(d, exist_ok=True)
-    return d
-
-
-def _temp_path(filename: str) -> str:
-    return os.path.join(_temp_dir(), filename)
-
-
-def _save_temp_png(img_tensor, filename: str, meta: dict = None) -> None:
-    img = _tensor_to_pil(img_tensor)
-
-    pnginfo = None
-    if isinstance(meta, dict) and meta:
-        pnginfo = PngInfo()
-        for k, v in meta.items():
-            if v is None:
-                v = ""
-            pnginfo.add_text(str(k), str(v))
-
-    img.save(_temp_path(filename), compress_level=4, pnginfo=pnginfo)
-
-def _safe_remove(filename: str) -> None:
-    try:
-        p = _temp_path(filename)
-        if os.path.isfile(p):
-            os.remove(p)
-    except Exception:
-        pass
-
-
-def _clear_gallery_files() -> None:
-    d = _temp_dir()
-    for fn in os.listdir(d):
-        if fn.startswith(AKBASE_GALLERY_PREFIX) and fn.lower().endswith(".png"):
-            try:
-                os.remove(os.path.join(d, fn))
-            except Exception:
-                pass
-
-
-def _clear_compare_files() -> None:
-    _safe_remove(AKBASE_A_FILENAME)
-    _safe_remove(AKBASE_B_FILENAME)
-
-
-def _write_state(state: dict, filename: str = None) -> None:
-    try:
-        fn = filename if filename else AKBASE_STATE_FILENAME
-        with open(_temp_path(fn), "w", encoding="utf-8") as f:
-            json.dump(state, f, ensure_ascii=False)
-    except Exception:
-        pass
-
-
-class AKBase:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "a_image": ("IMAGE",),
-            },
-            "optional": {
-                "b_image": ("IMAGE",),
-            },
-            "hidden": {
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ()
-    FUNCTION = "run"
-    CATEGORY = "AK"
-    OUTPUT_NODE = True
-
-    def run(
-        self,
-        a_image,
-        b_image=None,
-        # ak_settings: str = None,
-        unique_id=None,
-    ):
-        a_n = int(a_image.shape[0]) if hasattr(a_image, "shape") else 1
-        b_n = int(b_image.shape[0]) if (b_image is not None and hasattr(b_image, "shape")) else 0
-
-        ak_base_config = "{}"
-
-        node_id = unique_id if unique_id is not None else getattr(self, "node_id", None)
-        node_id = str(node_id) if node_id is not None else None
-        suffix = f"_{node_id}" if node_id is not None else ""
-
-
-        xz_fname = f"ak_base_xz_config{suffix}.json" if suffix else AKBASE_XZ_CONFIG_FILENAME
-        try:
-
-            content = "{}"
-            cfg_list = []
-            try:
-                if (a_n > 1) or (b_n > 1):
-                    imgs = []
-                    if a_n > 1:
-                        imgs.extend([a_image[i] for i in range(min(a_n, AKBASE_GALLERY_MAX))])
-                    if b_n > 1 and b_image is not None:
-                        remaining = AKBASE_GALLERY_MAX - len(imgs)
-                        if remaining > 0:
-                            imgs.extend([b_image[i] for i in range(min(b_n, remaining))])
-                    if imgs:
-                        cfg_list = akxz_extract_image_cfg_list(_akxz_torch.stack(imgs, dim=0))
-                else:
-                    cfg_list = akxz_extract_image_cfg_list(a_image)
-            except Exception:
-                cfg_list = []
-
-            if cfg_list:
-                content = json.dumps({"image": cfg_list}, ensure_ascii=False)
-            with open(_temp_path(xz_fname), "w", encoding="utf-8") as f:
-                f.write(content)
-
-        except Exception:
-            pass
-
-        if a_n > 1 or b_n > 1:
-            _clear_compare_files()
-            if suffix:
-                _safe_remove(f"ak_base_image_a{suffix}.png")
-                _safe_remove(f"ak_base_image_b{suffix}.png")
-            _clear_gallery_files()
-
-            _save_temp_png(a_image[0], f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME)
-            if b_image is None:
-                _save_temp_png(a_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-            else:
-                _save_temp_png(b_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-
-            imgs = []
-            if a_n > 1:
-                imgs.extend([a_image[i] for i in range(min(a_n, AKBASE_GALLERY_MAX))])
-
-            if b_n > 1 and b_image is not None:
-                remaining = AKBASE_GALLERY_MAX - len(imgs)
-                if remaining > 0:
-                    imgs.extend([b_image[i] for i in range(min(b_n, remaining))])
-
-            gallery_prefix = f"{AKBASE_GALLERY_PREFIX}{node_id}_" if node_id is not None else AKBASE_GALLERY_PREFIX
-            for i, t in enumerate(imgs):
-                _save_temp_png(t, f"{gallery_prefix}{i}.png")
-
-            _write_state(
-                {
-                    "mode": "gallery",
-                    "count": len(imgs),
-                    "gallery_prefix": gallery_prefix,
-                },
-                filename=(f"ak_base_state{suffix}.json" if suffix else AKBASE_STATE_FILENAME),
-            )
-
-            return {"ui": {"ak_base_saved": [True]}, "result": (ak_base_config,)}
-
-        _clear_gallery_files()
-        if suffix:
-            _safe_remove(f"ak_base_image_a{suffix}.png")
-            _safe_remove(f"ak_base_image_b{suffix}.png")
-
-        _save_temp_png(a_image[0], f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME)
-
-        if b_image is None:
-            _save_temp_png(a_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-        else:
-            _save_temp_png(b_image[0], f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME)
-
-        _write_state(
-            {
-                "mode": "compare",
-                "a": {"filename": (f"ak_base_image_a{suffix}.png" if suffix else AKBASE_A_FILENAME), "type": "temp", "subfolder": ""},
-                "b": {"filename": (f"ak_base_image_b{suffix}.png" if suffix else AKBASE_B_FILENAME), "type": "temp", "subfolder": ""},
-                "preview_width": 512,
-                "preview_height": 512,
-            },
-            filename=(f"ak_base_state{suffix}.json" if suffix else AKBASE_STATE_FILENAME),
-        )
-
-        return {"ui": {"ak_base_saved": [True]}, "result": (ak_base_config,)}
-
-
-NODE_CLASS_MAPPINGS = {"AK Base": AKBase}
-NODE_DISPLAY_NAME_MAPPINGS = {"AK Base": "AK Base"}

custom_nodes/ComfyUI-AK-Pack/nodes/AKCLIPEncodeMultiple.py

@@ -1,243 +0,0 @@
-import zlib
-
-
-class AnyType(str):
-    def __ne__(self, __value: object) -> bool:
-        return False
-
-
-ANY_TYPE = AnyType("*")
-
-
-class AKCLIPEncodeMultiple:
-    empty_cache = {}
-    # text_cache = {}
-
-    last_items = None
-    idx_cache = {}
-    hash_cache = {}
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "str_list": (ANY_TYPE, {"forceInput": False}),
-                "clip": ("CLIP",),
-                "starting_index": ("INT", {"default": 0, "min": 0, "step": 1}),
-                "length": ("INT", {"default": 1, "min": 1, "max": 20, "step": 1}),
-            },
-            "optional": {
-                "mask_list": ("MASK",),
-            },
-        }
-
-    RETURN_TYPES = ("CONDITIONING",) + ("CONDITIONING",) * 20
-    RETURN_NAMES = ("combined_con",) + tuple(f"cond_{i}" for i in range(20))
-
-    FUNCTION = "execute"
-    CATEGORY = "AK/conditioning"
-    OUTPUT_NODE = False
-
-    INPUT_IS_LIST = True
-
-    @classmethod
-    def _get_empty_cond(cls, clip):
-        key = id(clip)
-        cached = cls.empty_cache.get(key)
-        if cached is not None:
-            return cached
-
-        tokens = clip.tokenize("")
-        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
-        empty = [[cond, {"pooled_output": pooled}]]
-        cls.empty_cache[key] = empty
-        return empty
-
-    @classmethod
-    def _encode_text(cls, clip, text):
-        tokens = clip.tokenize(text)
-        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
-        return [[cond, {"pooled_output": pooled}]]
-
-    @staticmethod
-    def _clip_key(clip):
-        inner = getattr(clip, "cond_stage_model", None)
-        if inner is not None:
-            return id(inner)
-        inner = getattr(clip, "clip", None) or getattr(clip, "model", None)
-        if inner is not None:
-            return id(inner)
-        return id(clip)
-
-    @staticmethod
-    def _apply_mask_to_cond(base_cond, mask):
-        if mask is None:
-            return base_cond
-        cond_with_mask = []
-        for t, data in base_cond:
-            data_copy = dict(data) if data is not None else {}
-            data_copy["mask"] = mask
-            data_copy["mask_strength"] = 1.0
-            cond_with_mask.append([t, data_copy])
-        return cond_with_mask
-
-    @classmethod
-    def _compute_hash(cls, items, masks, start, length):
-        max_bytes = 64 * 1024
-        buf = bytearray()
-
-        def add_bytes(b):
-            nonlocal buf
-            if not b:
-                return
-            remaining = max_bytes - len(buf)
-            if remaining <= 0:
-                return
-            if len(b) > remaining:
-                buf.extend(b[:remaining])
-            else:
-                buf.extend(b)
-
-        for v in items:
-            s = "" if v is None else v
-            add_bytes(s.encode("utf-8", errors="ignore") + b"\n")
-            if len(buf) >= max_bytes:
-                break
-
-        if len(buf) < max_bytes and masks:
-            for m in masks:
-                if m is None:
-                    add_bytes(b"MNONE\n")
-                else:
-                    try:
-                        t = m
-                        if isinstance(t, (list, tuple)):
-                            t = t[0]
-                        if hasattr(t, "detach"):
-                            t = t.detach()
-                        arr = t.cpu().contiguous().numpy()
-                        add_bytes(arr.tobytes())
-                    except Exception:
-                        add_bytes(repr(type(m)).encode("utf-8", errors="ignore"))
-                if len(buf) >= max_bytes:
-                    break
-
-        add_bytes(f"|start={start}|len={length}".encode("ascii"))
-
-        return zlib.adler32(bytes(buf)) & 0xFFFFFFFF
-
-    def execute(self, clip, str_list, starting_index, length, mask_list=None):
-        if isinstance(clip, (list, tuple)):
-            clip_obj = clip[0]
-        else:
-            clip_obj = clip
-
-        if isinstance(str_list, (list, tuple)):
-            if len(str_list) == 1 and isinstance(str_list[0], (list, tuple)):
-                items = list(str_list[0])
-            else:
-                items = list(str_list)
-        else:
-            items = [str_list]
-
-        if not isinstance(items, list) or not all(
-            (isinstance(v, str) or v is None) for v in items
-        ):
-            raise RuntimeError("Require array of strings")
-
-        masks = []
-        if mask_list is not None:
-            if isinstance(mask_list, (list, tuple)):
-                if len(mask_list) == 1 and isinstance(mask_list[0], (list, tuple)):
-                    masks = list(mask_list[0])
-                else:
-                    masks = list(mask_list)
-            else:
-                masks = [mask_list]
-
-        if isinstance(starting_index, (list, tuple)):
-            start_raw = starting_index[0] if starting_index else 0
-        else:
-            start_raw = starting_index
-
-        if isinstance(length, (list, tuple)):
-            length_raw = length[0] if length else 1
-        else:
-            length_raw = length
-
-        start = max(0, int(start_raw))
-        length_val = max(1, min(20, int(length_raw)))
-
-        if AKCLIPEncodeMultiple.last_items is None or len(AKCLIPEncodeMultiple.last_items) != len(items):
-            AKCLIPEncodeMultiple.last_items = [None] * len(items)
-            AKCLIPEncodeMultiple.idx_cache.clear()
-
-        clip_id = self._clip_key(clip_obj)
-        items_copy = list(items)
-        masks_copy = list(masks) if masks else []
-        hval = self._compute_hash(items_copy, masks_copy, start, length_val)
-        cache_key = (clip_id, hval)
-
-        cached_entry = AKCLIPEncodeMultiple.hash_cache.get(cache_key)
-        if cached_entry is not None:
-            combined_cached, per_idx_cached = cached_entry
-            per_idx_cached = list(per_idx_cached)
-            if len(per_idx_cached) < 20:
-                per_idx_cached.extend([None] * (20 - len(per_idx_cached)))
-            elif len(per_idx_cached) > 20:
-                per_idx_cached = per_idx_cached[:20]
-            return (combined_cached,) + tuple(per_idx_cached)
-
-        result = []
-        empty_cond = None
-        combined_cond = None
-
-        for i in range(length_val):
-            idx = start + i
-
-            cond = None
-            if 0 <= idx < len(items):
-                v = items[idx]
-
-                mask_for_idx = None
-                if 0 <= idx < len(masks):
-                    mask_for_idx = masks[idx]
-
-                if v is None:
-                    if empty_cond is None:
-                        empty_cond = self._get_empty_cond(clip_obj)
-                    base_cond = empty_cond
-                    AKCLIPEncodeMultiple.last_items[idx] = None
-                else:
-                    prev = AKCLIPEncodeMultiple.last_items[idx]
-                    if v == prev:
-                        cached = AKCLIPEncodeMultiple.idx_cache.get((clip_id, idx))
-                        if cached is not None:
-                            base_cond = cached
-                        else:
-                            base_cond = self._encode_text(clip_obj, v)
-                            AKCLIPEncodeMultiple.idx_cache[(clip_id, idx)] = base_cond
-                    else:
-                        base_cond = self._encode_text(clip_obj, v)
-                        AKCLIPEncodeMultiple.idx_cache[(clip_id, idx)] = base_cond
-                        AKCLIPEncodeMultiple.last_items[idx] = v
-                cond = self._apply_mask_to_cond(base_cond, mask_for_idx)
-                if v is not None and cond is not None:
-                    if combined_cond is None:
-                        combined_cond = []
-                    for t, data in cond:
-                        data_copy = dict(data) if data is not None else {}
-                        combined_cond.append([t, data_copy])
-
-            result.append(cond)
-
-        if length_val < 20:
-            result.extend([None] * (20 - length_val))
-
-        AKCLIPEncodeMultiple.hash_cache[cache_key] = (combined_cond, list(result))
-
-        return (combined_cond,) + tuple(result)
-
-
-NODE_CLASS_MAPPINGS = {"AKCLIPEncodeMultiple": AKCLIPEncodeMultiple}
-NODE_DISPLAY_NAME_MAPPINGS = {"AKCLIPEncodeMultiple": "AK CLIP Encode Multiple"}

custom_nodes/ComfyUI-AK-Pack/nodes/AKContrastAndSaturateImage.py

@@ -1,281 +0,0 @@
-import torch
-import numpy as np
-from PIL import Image
-
-# Hue band definitions (soft ranges in degrees)
-FEATHER_DEG = 15.0
-
-RED_RANGES_SOFT = [(315.0, 345.0), (15.0, 45.0)]
-YELLOW_RANGES_SOFT = [(15.0, 45.0), (75.0, 105.0)]
-GREEN_RANGES_SOFT = [(75.0, 105.0), (135.0, 165.0)]
-CYAN_RANGES_SOFT = [(135.0, 165.0), (195.0, 225.0)]
-BLUE_RANGES_SOFT = [(195.0, 225.0), (225.0, 285.0)]
-MAGENTA_RANGES_SOFT = [(255.0, 285.0), (315.0, 345.0)]
-
-
-def _compute_band_weight(h_deg: np.ndarray, ranges_soft):
-    """Compute per-pixel weight for a hue band with soft feathered edges."""
-    if h_deg.ndim != 2:
-        raise ValueError("Expected 2D hue array")
-
-    weight_total = np.zeros_like(h_deg, dtype=np.float32)
-
-    for start_soft, end_soft in ranges_soft:
-        width = end_soft - start_soft
-        if width <= 0.0:
-            continue
-
-        feather = min(FEATHER_DEG, width * 0.5)
-        start_hard = start_soft + feather
-        end_hard = end_soft - feather
-
-        seg_weight = np.zeros_like(h_deg, dtype=np.float32)
-
-        # Fully inside hard region
-        inside_hard = (h_deg >= start_hard) & (h_deg <= end_hard)
-        seg_weight[inside_hard] = 1.0
-
-        # Soft rising edge
-        if feather > 0.0:
-            rising = (h_deg >= start_soft) & (h_deg < start_hard)
-            seg_weight[rising] = (h_deg[rising] - start_soft) / feather
-
-            falling = (h_deg > end_hard) & (h_deg <= end_soft)
-            seg_weight[falling] = (end_soft - h_deg[falling]) / feather
-
-        weight_total = np.maximum(weight_total, seg_weight)
-
-    return weight_total
-
-
-def _slider_to_factor(value: int) -> float:
-    """Convert slider value in [-100, 100] to saturation multiplier."""
-    v = float(value)
-    return max(0.0, 1.0 + v / 100.0)
-
-def _apply_brightness_contrast_rgb01(frame: np.ndarray, brightness: int, contrast: int) -> np.ndarray:
-    """Apply brightness and contrast to an RGB image in [0,1] float32 format."""
-    out = frame.astype(np.float32, copy=False)
-
-    if brightness != 0:
-        out = out + (float(brightness) / 100.0)
-
-    if contrast != 0:
-        factor = 1.0 + (float(contrast) / 100.0)
-        out = (out - 0.5) * factor + 0.5
-
-    return np.clip(out, 0.0, 1.0)
-
-
-
-class AKContrastAndSaturateImage:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "brightness": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "contrast": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "master": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "reds": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "yellows": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "greens": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "cyans": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "blues": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-                "magentas": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": -100,
-                        "max": 100,
-                        "step": 1,
-                    },
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("image",)
-    FUNCTION = "apply"
-    CATEGORY = "AK/image"
-
-    def apply(
-        self,
-        image: torch.Tensor,
-        brightness: int,
-        contrast: int,
-        master: int,
-        reds: int,
-        yellows: int,
-        greens: int,
-        cyans: int,
-        blues: int,
-        magentas: int,
-    ):
-        if not isinstance(image, torch.Tensor):
-            raise TypeError("Expected image as torch.Tensor")
-
-        if image.ndim != 4 or image.shape[-1] != 3:
-            raise ValueError("Expected image with shape [B, H, W, 3]")
-
-        if (
-            brightness == 0
-            and contrast == 0
-            and master == 0
-            and reds == 0
-            and yellows == 0
-            and greens == 0
-            and cyans == 0
-            and blues == 0
-            and magentas == 0
-        ):
-            return (image,)
-
-        device = image.device
-        batch_size, h, w, c = image.shape
-
-        img_np = image.detach().cpu().numpy()
-        out_list = []
-
-        master_factor = _slider_to_factor(master)
-        reds_factor = _slider_to_factor(reds)
-        yellows_factor = _slider_to_factor(yellows)
-        greens_factor = _slider_to_factor(greens)
-        cyans_factor = _slider_to_factor(cyans)
-        blues_factor = _slider_to_factor(blues)
-        magentas_factor = _slider_to_factor(magentas)
-
-        for i in range(batch_size):
-            frame = img_np[i]
-
-            if brightness != 0 or contrast != 0:
-                frame = _apply_brightness_contrast_rgb01(frame, brightness, contrast)
-
-            frame_u8 = (frame * 255.0).clip(0, 255).astype(np.uint8)
-
-            pil_rgb = Image.fromarray(frame_u8, mode="RGB")
-            pil_hsv = pil_rgb.convert("HSV")
-            hsv = np.array(pil_hsv, dtype=np.uint8)
-
-            H = hsv[..., 0].astype(np.float32)
-            S = hsv[..., 1].astype(np.float32)
-            V = hsv[..., 2]
-
-            h_deg = H * (360.0 / 255.0)
-
-            # Base master factor
-            S = S * master_factor
-
-            # Per-band masks
-            reds_w = _compute_band_weight(h_deg, RED_RANGES_SOFT)
-            yellows_w = _compute_band_weight(h_deg, YELLOW_RANGES_SOFT)
-            greens_w = _compute_band_weight(h_deg, GREEN_RANGES_SOFT)
-            cyans_w = _compute_band_weight(h_deg, CYAN_RANGES_SOFT)
-            blues_w = _compute_band_weight(h_deg, BLUE_RANGES_SOFT)
-            magentas_w = _compute_band_weight(h_deg, MAGENTA_RANGES_SOFT)
-
-            # Sequential multiplicative adjustments
-            def apply_band(S_arr, weight, factor):
-                if factor == 1.0:
-                    return S_arr
-                band_scale = 1.0 + weight * (factor - 1.0)
-                return S_arr * band_scale
-
-            S = apply_band(S, reds_w, reds_factor)
-            S = apply_band(S, yellows_w, yellows_factor)
-            S = apply_band(S, greens_w, greens_factor)
-            S = apply_band(S, cyans_w, cyans_factor)
-            S = apply_band(S, blues_w, blues_factor)
-            S = apply_band(S, magentas_w, magentas_factor)
-
-            S = np.clip(S, 0.0, 255.0).astype(np.uint8)
-
-            hsv_new = np.stack(
-                [
-                    H.astype(np.uint8),
-                    S,
-                    V.astype(np.uint8),
-                ],
-                axis=-1,
-            )
-
-            pil_hsv_new = Image.fromarray(hsv_new, mode="HSV")
-            pil_rgb_new = pil_hsv_new.convert("RGB")
-            rgb_np = np.array(pil_rgb_new).astype(np.float32) / 255.0
-            out_list.append(rgb_np)
-
-        out_np = np.stack(out_list, axis=0)
-        out_tensor = torch.from_numpy(out_np).to(device)
-        return (out_tensor,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "AKContrastAndSaturateImage": AKContrastAndSaturateImage,
-}
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AKContrastAndSaturateImage": "AK Contrast & Saturate Image",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKControlMultipleKSamplers.py

@@ -1,46 +0,0 @@
-import comfy.samplers
-
-class AKControlMultipleKSamplers:
-    """
-    UI-only control node (no outputs). Frontend JS drives synchronization.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "choose_ksampler": (["<none>"], {"default": "<none>"}),
-
-                "seed ": ("INT", {"default": 0, "min": 0, "max": 0x7FFFFFFF, "step": 1}),
-                "steps": ("INT", {"default": 15, "min": 1, "max": 100, "step": 1}),
-                "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step": 0.1}),
-                "sampler_name": (
-                    comfy.samplers.SAMPLER_NAMES,
-                    {"default": comfy.samplers.SAMPLER_NAMES[0]}
-                ),
-                "scheduler": (
-                    comfy.samplers.SCHEDULER_NAMES,
-                    {"default": comfy.samplers.SCHEDULER_NAMES[0]}
-                ),
-                "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
-            },
-            "hidden": {
-                "_ak_state_json": ("STRING", {"default": "{}", "multiline": True}),
-            }
-        }
-
-    RETURN_TYPES = ()
-    FUNCTION = "noop"
-    CATEGORY = "AK/sampling"
-
-    def noop(self, **kwargs):
-        return ()
-
-
-NODE_CLASS_MAPPINGS = {
-    "AK Control Multiple KSamplers": AKControlMultipleKSamplers
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AK Control Multiple KSamplers": "AK Control Multiple KSamplers"
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKIndexMultiple.py

@@ -1,72 +0,0 @@
-# nodes/IndexMultiple.py
-
-class AnyType(str):
-    def __ne__(self, __value: object) -> bool:
-        return False
-
-ANY_TYPE = AnyType("*")
-
-class AKIndexMultiple:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "input_any": (ANY_TYPE, {"forceInput": False}),
-                "starting_index": ("INT", {"default": 0, "min": 0, "step": 1}),
-                "length": ("INT", {"default": 1, "min": 1, "max": 50, "step": 1}),
-            },
-            "optional": {
-                "if_none": (ANY_TYPE, {}),
-            }
-        }
-
-    RETURN_TYPES = (ANY_TYPE,) * 50
-    RETURN_NAMES = tuple(f"item_{i}" for i in range(50))
-
-    FUNCTION = "execute"
-    CATEGORY = "AK/utils"
-    OUTPUT_NODE = False
-
-    INPUT_IS_LIST = True
-
-    def execute(self, input_any, starting_index, length, if_none=None):
-        if isinstance(input_any, (list, tuple)):
-            if len(input_any) == 1 and isinstance(input_any[0], (list, tuple)):
-                items = list(input_any[0])
-            else:
-                items = list(input_any)
-        else:
-            items = [input_any]
-
-        start = max(0, int(starting_index[0] if isinstance(starting_index, (list, tuple)) else starting_index))
-        length_val = max(1, min(50, int(length[0] if isinstance(length, (list, tuple)) else length)))
-
-#        for i, v in enumerate(items[:10]):
-#            print(f"  [{i}] {v}")
-
-        if isinstance(if_none, (list, tuple)):
-            fallback = if_none[0] if len(if_none) > 0 else None
-        else:
-            fallback = if_none
-
-        # print(fallback)
-        result = []
-
-        for i in range(50):
-            idx = start + i
-
-            if i < length_val and 0 <= idx < len(items):
-                v = items[idx]
-                if v is None and fallback is not None:
-                    v = fallback
-            else:
-                v = fallback
-
-            result.append(v)
-
-
-        return tuple(result)
-
-
-NODE_CLASS_MAPPINGS = {"AKIndexMultiple": AKIndexMultiple}
-NODE_DISPLAY_NAME_MAPPINGS = {"AKIndexMultiple": "AK Index Multiple"}

custom_nodes/ComfyUI-AK-Pack/nodes/AKKSamplerSettings.py

@@ -1,152 +0,0 @@
-import json
-import zlib
-import comfy.samplers
-
-
-class AKKSamplerSettings:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                # Don't name this input exactly "seed" or ComfyUI may auto-randomize it
-                # depending on global seed behavior, causing this node to look "changed" every run.
-                "seed_value": ("INT", {"default": 0, "min": 0, "max": 2147483647, "step": 1}),
-                "steps": ("INT", {"default": 20, "min": 1, "max": 10000, "step": 1}),
-                "cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0, "step": 0.1}),
-                "sampler_name": (comfy.samplers.SAMPLER_NAMES, {"default": comfy.samplers.SAMPLER_NAMES[0]}),
-                "scheduler": (comfy.samplers.SCHEDULER_NAMES, {"default": comfy.samplers.SCHEDULER_NAMES[0]}),
-                "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
-                "xz_steps": ("INT", {"default": 1, "min": 1, "max": 9999, "step": 1}),
-            },
-            "hidden": {
-                "node_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("sampler_settings",)
-    FUNCTION = "run"
-    CATEGORY = "AK/sampling"
-
-    def run(
-        self,
-        seed_value: int,
-        steps: int,
-        cfg: float,
-        sampler_name: str,
-        scheduler: str,
-        denoise: float,
-        xz_steps: int,
-        node_id=None,
-    ):
-        from_id = str(node_id) if node_id is not None else ""
-        seed = int(seed_value)
-        if seed < 0:
-            seed = 0
-
-        data = {
-            "seed": seed,
-            "steps": int(steps),
-            "cfg": float(cfg),
-            "sampler_name": str(sampler_name),
-            "scheduler": str(scheduler),
-            "denoise": float(denoise),
-            "xz_steps": int(xz_steps),
-            "from_id": from_id,
-        }
-
-        payload = (
-            f"{data['seed']}|{data['steps']}|{data['cfg']}|{data['sampler_name']}|"
-            f"{data['scheduler']}|{data['denoise']}|{data['xz_steps']}|{from_id}"
-        )
-        h = zlib.adler32(payload.encode("utf-8")) & 0xFFFFFFFF
-        data["hash"] = int(h)
-
-        s = json.dumps(data, ensure_ascii=False)
-        return (s,)
-
-
-class AKKSamplerSettingsOut:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "sampler_settings": ("STRING", {"forceInput": True}),
-            }
-        }
-
-    RETURN_TYPES = (
-        "INT",
-        "INT",
-        "FLOAT",
-        comfy.samplers.SAMPLER_NAMES,
-        comfy.samplers.SCHEDULER_NAMES,
-        "FLOAT",
-        "INT",
-    )
-    RETURN_NAMES = (
-        "seed",
-        "steps",
-        "cfg",
-        "sampler_name",
-        "scheduler",
-        "denoise",
-        "xz_steps",
-    )
-    FUNCTION = "run"
-    CATEGORY = "AK/sampling"
-
-    def run(self, sampler_settings: str):
-        data = {}
-        if isinstance(sampler_settings, str) and sampler_settings.strip():
-            try:
-                data = json.loads(sampler_settings)
-                if not isinstance(data, dict):
-                    data = {}
-            except Exception:
-                data = {}
-
-        seed = int(data.get("seed", 0) or 0)
-        if seed < 0:
-            seed = 0
-
-        steps = int(data.get("steps", 20) or 20)
-
-        try:
-            cfg = float(data.get("cfg", 7.0))
-        except Exception:
-            cfg = 7.0
-
-        sampler_name = str(data.get("sampler_name", comfy.samplers.SAMPLER_NAMES[0]))
-        if sampler_name not in comfy.samplers.SAMPLER_NAMES:
-            sampler_name = comfy.samplers.SAMPLER_NAMES[0]
-
-        scheduler = str(data.get("scheduler", comfy.samplers.SCHEDULER_NAMES[0]))
-        if scheduler not in comfy.samplers.SCHEDULER_NAMES:
-            scheduler = comfy.samplers.SCHEDULER_NAMES[0]
-
-        try:
-            denoise = float(data.get("denoise", 1.0))
-        except Exception:
-            denoise = 1.0
-
-        xz_steps_raw = data.get("xz_steps", 1)
-        try:
-            xz_steps = int(xz_steps_raw)
-        except Exception:
-            xz_steps = 1
-        if xz_steps < 1:
-            xz_steps = 1
-
-        return (seed, steps, cfg, sampler_name, scheduler, denoise, xz_steps)
-
-
-NODE_CLASS_MAPPINGS = {
-    "AKKSamplerSettings": AKKSamplerSettings,
-    "AKKSamplerSettingsOut": AKKSamplerSettingsOut,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AKKSamplerSettings": "AK KSampler Settings",
-    "AKKSamplerSettingsOut": "AK KSampler Settings Out",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKPipeLoop.py

@@ -1,184 +0,0 @@
-# AKPipeLoop.py
-
-class AKPipeLoop:
-    IDX_HASH = 0
-    IDX_MODEL = 1
-    IDX_CLIP = 2
-    IDX_VAE = 3
-    IDX_POS = 4
-    IDX_NEG = 5
-    IDX_LATENT = 6
-    IDX_IMAGE = 7
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "pipe_in_1": ("AK_PIPE",),
-            },
-            "optional": {
-                "pipe_in_2": ("AK_PIPE",),
-                "pipe_in_3": ("AK_PIPE",),
-                "pipe_in_4": ("AK_PIPE",),
-                "pipe_in_5": ("AK_PIPE",),
-                "pipe_in_6": ("AK_PIPE",),
-                "pipe_in_7": ("AK_PIPE",),
-                "pipe_in_8": ("AK_PIPE",),
-                "pipe_in_9": ("AK_PIPE",),
-                "pipe_in_10": ("AK_PIPE",),
-            },
-        }
-
-    RETURN_TYPES = (
-        "AK_PIPE",
-        "MODEL",
-        "CLIP",
-        "VAE",
-        "CONDITIONING",
-        "CONDITIONING",
-        "LATENT",
-        "IMAGE",
-    )
-
-    RETURN_NAMES = (
-        "pipe_out",
-        "model",
-        "clip",
-        "vae",
-        "positive",
-        "negative",
-        "latent",
-        "image",
-    )
-
-    FUNCTION = "run"
-    CATEGORY = "AK/pipe"
-    OUTPUT_NODE = True
-
-    @classmethod
-    def IS_CHANGED(cls, **kwargs):
-        # Force this node to always re-run
-        return float("nan")
-
-    def __init__(self):
-        # Stored hashes per input index (0..9 for pipe_in_1..pipe_in_10).
-        self._stored_hashes = {}
-
-    def _normalize_pipe(self, pipe):
-        if pipe is None:
-            return None
-
-        if not isinstance(pipe, tuple):
-            pipe = tuple(pipe)
-
-        # Old format: 7-tuple without hash -> prepend None hash.
-        if len(pipe) == 7:
-            pipe = (None,) + pipe
-        elif len(pipe) < 7:
-            pipe = (None,) + pipe + (None,) * (7 - len(pipe))
-        elif len(pipe) > 8:
-            pipe = pipe[:8]
-
-        return pipe
-
-    def _get_hash_from_pipe(self, pipe):
-        if pipe is None:
-            return None
-        if not isinstance(pipe, tuple):
-            pipe = tuple(pipe)
-        if len(pipe) == 0:
-            return None
-        # If it is old 7-tuple without hash, treat hash as None.
-        if len(pipe) == 7:
-            return None
-        return pipe[self.IDX_HASH]
-
-    def _outputs_from_pipe(self, pipe):
-        # Assumes pipe is already normalized to at least 8 elements.
-        model = pipe[self.IDX_MODEL]
-        clip = pipe[self.IDX_CLIP]
-        vae = pipe[self.IDX_VAE]
-        positive = pipe[self.IDX_POS]
-        negative = pipe[self.IDX_NEG]
-        latent = pipe[self.IDX_LATENT]
-        image = pipe[self.IDX_IMAGE]
-        return (pipe, model, clip, vae, positive, negative, latent, image)
-
-    def run(
-        self,
-        pipe_in_1,
-        pipe_in_2=None,
-        pipe_in_3=None,
-        pipe_in_4=None,
-        pipe_in_5=None,
-        pipe_in_6=None,
-        pipe_in_7=None,
-        pipe_in_8=None,
-        pipe_in_9=None,
-        pipe_in_10=None,
-    ):
-        inputs = [
-            pipe_in_1,
-            pipe_in_2,
-            pipe_in_3,
-            pipe_in_4,
-            pipe_in_5,
-            pipe_in_6,
-            pipe_in_7,
-            pipe_in_8,
-            pipe_in_9,
-            pipe_in_10,
-        ]
-
-        current_hashes = {}
-        changed_indices = []
-        normalized_pipes = {}
-
-        # First pass: compute hashes for all valid inputs and detect changes
-        for idx, raw_pipe in enumerate(inputs):
-            if raw_pipe is None:
-                continue
-
-            pipe = self._normalize_pipe(raw_pipe)
-            if pipe is None:
-                continue
-
-            normalized_pipes[idx] = pipe
-            h = self._get_hash_from_pipe(pipe)
-            current_hashes[idx] = h
-
-            prev = self._stored_hashes.get(idx, None)
-            if idx not in self._stored_hashes or h != prev:
-                changed_indices.append(idx)
-
-        # Update stored hashes snapshot to current state
-        self._stored_hashes = current_hashes
-
-        # If there is at least one changed input, use the first one
-        if changed_indices:
-            first_idx = changed_indices[0]
-            pipe = normalized_pipes[first_idx]
-            return self._outputs_from_pipe(pipe)
-
-        # No hashes changed: choose the last non-None current input
-        last_pipe = None
-        for raw_pipe in inputs:
-            if raw_pipe is not None:
-                p = self._normalize_pipe(raw_pipe)
-                if p is not None:
-                    last_pipe = p
-
-        if last_pipe is not None:
-            return self._outputs_from_pipe(last_pipe)
-
-        # Degenerate empty outputs if nothing valid found
-        return (None, None, None, None, None, None, None, None)
-
-
-NODE_CLASS_MAPPINGS = {
-    "AK Pipe Loop": AKPipeLoop,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AK Pipe Loop": "AK Pipe Loop",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKProjectSettingsOut.py

@@ -1,178 +0,0 @@
-import json
-import io
-import base64
-import os
-
-from PIL import Image
-import numpy as np
-import torch
-import folder_paths
-
-
-_GARBAGE_SUBFOLDER = "garbage"
-
-
-def _is_under_dir(path: str, root: str) -> bool:
-    try:
-        path_abs = os.path.abspath(path)
-        root_abs = os.path.abspath(root)
-        return os.path.commonpath([path_abs, root_abs]) == root_abs
-    except Exception:
-        return False
-
-
-def _safe_join_under(root: str, *parts: str) -> str:
-    joined = os.path.abspath(os.path.join(root, *[str(p or "") for p in parts]))
-    if not _is_under_dir(joined, root):
-        return ""
-    return joined
-
-
-def _load_image_to_tensor(abs_path: str):
-    img = Image.open(abs_path).convert("RGB")
-    np_img = np.array(img).astype(np.float32) / 255.0
-    return torch.from_numpy(np_img)[None,]
-
-
-def _find_first_subfolder_abs_path_by_filename(filename: str) -> str:
-    if not filename:
-        return ""
-
-    input_dir_abs = os.path.abspath(folder_paths.get_input_directory())
-
-    target = os.path.basename(str(filename)).strip()
-    if not target:
-        return ""
-
-    target_l = target.lower()
-    garbage_root = os.path.join(input_dir_abs, _GARBAGE_SUBFOLDER)
-
-    for dirpath, dirnames, filenames in os.walk(input_dir_abs, topdown=False):
-        dirpath_abs = os.path.abspath(dirpath)
-
-        # ignore input root
-        if dirpath_abs == input_dir_abs:
-            continue
-
-        # ignore /input/garbage/ (and any nested subfolders)
-        if _is_under_dir(dirpath_abs, garbage_root):
-            continue
-
-        for fn in filenames:
-            if str(fn).lower() == target_l:
-                return os.path.join(dirpath_abs, "")
-
-    return ""
-
-
-class AKProjectSettingsOut:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "ak_project_settings_json": ("STRING", {"default": "", "multiline": False}),
-            }
-        }
-
-    RETURN_TYPES = (
-        "STRING",
-        "STRING",
-        "INT",
-        "INT",
-        "BOOLEAN",
-        "IMAGE",
-        "STRING",
-        "STRING",
-    )
-
-    RETURN_NAMES = (
-        "output_filename",
-        "output_subfolder",
-        "width",
-        "height",
-        "do_resize",
-        "image",
-        "image_filename",
-        "image_filepath",
-    )
-
-    FUNCTION = "run"
-    CATEGORY = "AK/settings"
-    DESCRIPTION = (
-        "Outputs the values of fields defined in the Project Settings panel. "
-        "Additionally, it can resolve and output the image file path for images "
-        "located in ComfyUI’s native input directory, including nested subfolders."
-    )
-
-    def run(self, ak_project_settings_json):
-        try:
-            vals = json.loads(ak_project_settings_json or "{}")
-        except Exception:
-            vals = {}
-
-        output_filename = str(vals.get("output_filename", ""))
-        output_subfolder = str(vals.get("output_subfolder", ""))
-        width = int(vals.get("width", 0) or 0)
-        height = int(vals.get("height", 0) or 0)
-
-        do_resize_raw = int(vals.get("do_resize", 0) or 0)
-        do_resize = bool(do_resize_raw == 1)
-
-        image = None
-
-        open_image_filename = str(vals.get("open_image_filename") or "").strip()
-        open_image_subfolder = str(vals.get("open_image_subfolder") or "").strip()
-        open_image_type = str(vals.get("open_image_type") or "input").strip() or "input"
-
-        image_filename = os.path.splitext(os.path.basename(open_image_filename))[0] if open_image_filename else ""
-
-        # image_filepath: folder path (abs) where the file is found in input subfolders; ignore /input/garbage/
-        image_filepath = ""
-        try:
-            if open_image_filename:
-                image_filepath = _find_first_subfolder_abs_path_by_filename(open_image_filename) or ""
-        except Exception:
-            image_filepath = ""
-
-        # Prefer loading by (filename, subfolder, type) from input directory
-        if open_image_filename and open_image_type == "input":
-            try:
-                input_dir_abs = os.path.abspath(folder_paths.get_input_directory())
-                abs_path = _safe_join_under(input_dir_abs, open_image_subfolder, open_image_filename)
-                if abs_path and os.path.isfile(abs_path):
-                    image = _load_image_to_tensor(abs_path)
-            except Exception:
-                image = None
-
-        # Backward compatibility: if JSON still contains a data URL, try loading from it
-        if image is None:
-            image_data = vals.get("open_image", "")
-            if isinstance(image_data, str) and image_data.startswith("data:image"):
-                try:
-                    _, b64 = image_data.split(",", 1)
-                    raw = base64.b64decode(b64)
-                    img = Image.open(io.BytesIO(raw)).convert("RGB")
-                    np_img = np.array(img).astype(np.float32) / 255.0
-                    image = torch.from_numpy(np_img)[None,]
-                except Exception:
-                    image = None
-
-        return (
-            output_filename,
-            output_subfolder,
-            width,
-            height,
-            do_resize,
-            image,
-            image_filename,
-            image_filepath,
-        )
-
-
-NODE_CLASS_MAPPINGS = {
-    "AKProjectSettingsOut": AKProjectSettingsOut
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AKProjectSettingsOut": "AK Project Settings Out"
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKReplaceAlphaWithColor.py

@@ -1,201 +0,0 @@
-import torch
-import torch.nn.functional as F
-import re
-
-class AKReplaceAlphaWithColor:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "color_pick_mode": (["user_color", "auto_color"], {"default": "user_color"}),
-                "threshold": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
-                "image": ("IMAGE",),
-                "color_rgb": ("STRING", {"default": "8, 39, 245", "multiline": False}),
-                "pad_size": ("INT", {"default": 0, "min": 0, "step": 1}),
-            },
-            "optional": {
-                "mask": ("MASK",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "replace_alpha"
-    CATEGORY = "AK/image"
-
-    @staticmethod
-    def _parse_rgb(s: str):
-        parts = [p for p in re.split(r"[,\s;]+", (s or "").strip()) if p != ""]
-        if len(parts) != 3:
-            return (8, 39, 245)
-        vals = []
-        for p in parts:
-            try:
-                v = int(float(p))
-            except Exception:
-                return (8, 39, 245)
-            vals.append(max(0, min(255, v)))
-        return tuple(vals)
-
-    @staticmethod
-    def _auto_pick_color(src_rgb_01: torch.Tensor, threshold_255: int):
-        if src_rgb_01.dim() != 4 or src_rgb_01.shape[-1] != 3:
-            return None
-
-        thr = int(threshold_255)
-        if thr < 0:
-            thr = 0
-        elif thr > 255:
-            thr = 255
-
-        pix = src_rgb_01.reshape(-1, 3).clamp(0.0, 1.0)
-        n = int(pix.shape[0])
-        if n <= 0:
-            return None
-
-        max_samples = 20000
-        if n > max_samples:
-            idx = torch.randperm(n, device=pix.device)[:max_samples]
-            pix = pix.index_select(0, idx)
-
-        pix255 = (pix * 255.0).round()
-
-        step = 16
-        vals = torch.arange(0, 256, step, device=pix.device, dtype=pix255.dtype)
-
-        try:
-            rr, gg, bb = torch.meshgrid(vals, vals, vals, indexing="ij")
-        except TypeError:
-            rr, gg, bb = torch.meshgrid(vals, vals, vals)
-
-        cand = torch.stack([rr.reshape(-1), gg.reshape(-1), bb.reshape(-1)], dim=1)
-        m = int(cand.shape[0])
-
-        best_min_d2 = None
-        best = None
-
-        pix255_t = pix255.t().contiguous()
-        p2 = (pix255 * pix255).sum(dim=1).view(1, -1)
-
-        chunk = 256
-        for s in range(0, m, chunk):
-            c = cand[s:s + chunk]
-            c2 = (c * c).sum(dim=1, keepdim=True)
-            cross = 2.0 * (c @ pix255_t)
-            d2 = (c2 + p2 - cross).clamp_min(0.0)
-            min_d2 = d2.min(dim=1).values
-
-            cur_best_val = min_d2.max()
-            if best_min_d2 is None or cur_best_val > best_min_d2:
-                best_min_d2 = cur_best_val
-                best_idx = int(min_d2.argmax().item())
-                best = c[best_idx]
-
-        if best is None or best_min_d2 is None:
-            return None
-
-        thr2 = float(thr * thr)
-        if float(best_min_d2.item()) <= thr2 + 1e-6:
-            return None
-
-        return (int(best[0].item()), int(best[1].item()), int(best[2].item()))
-
-    @staticmethod
-    def _compute_pad(h: int, w: int, pad_size: int):
-        p = int(pad_size)
-        if p <= 0:
-            return (0, 0, 0, 0)
-
-        if w >= h:
-            add_w = p
-            add_h = int(round(p * (h / max(1, w))))
-        else:
-            add_h = p
-            add_w = int(round(p * (w / max(1, h))))
-
-        left = add_w // 2
-        right = add_w - left
-        top = add_h // 2
-        bottom = add_h - top
-        return (left, right, top, bottom)
-
-    def replace_alpha(self, color_pick_mode, threshold, image, color_rgb, pad_size=0, mask=None):
-        if image.dim() != 4:
-            return (image,)
-
-        c = image.shape[-1]
-        if c < 3:
-            return (image,)
-
-        src_rgb = image[..., :3].clamp(0.0, 1.0)
-
-        # If a mask is provided but the input image has no alpha channel, do nothing.
-        if mask is not None and c < 4:
-            return (image,)
-
-        mode = str(color_pick_mode or "user_color")
-        thr = int(threshold) if threshold is not None else 0
-
-        if mode == "auto_color":
-            picked = self._auto_pick_color(src_rgb, thr)
-            if picked is None:
-                picked = self._parse_rgb(color_rgb)
-        else:
-            picked = self._parse_rgb(color_rgb)
-
-        color = torch.tensor([picked[0], picked[1], picked[2]], device=image.device, dtype=image.dtype) / 255.0
-        color_view = color.view(1, 1, 1, 3).expand_as(src_rgb)
-
-        if mask is not None:
-            # Mask must match image spatial resolution.
-            try:
-                ih = int(image.shape[1])
-                iw = int(image.shape[2])
-                if mask.dim() == 3:
-                    mh, mw = int(mask.shape[1]), int(mask.shape[2])
-                elif mask.dim() == 4:
-                    mh, mw = int(mask.shape[1]), int(mask.shape[2])
-                else:
-                    return (image,)
-                if mh != ih or mw != iw:
-                    return (image,)
-            except Exception:
-                return (image,)
-            m = mask
-            if m.dim() == 3:
-                m = m.unsqueeze(-1)
-            elif m.dim() == 4 and m.shape[-1] != 1:
-                m = m[..., :1]
-            m = m.to(device=image.device, dtype=image.dtype).clamp(0.0, 1.0)
-            out = src_rgb * (1.0 - m) + color_view * m
-        else:
-            if c < 4:
-                out = image
-            else:
-                alpha = image[..., 3:4].clamp(0.0, 1.0)
-                out = src_rgb * alpha + color_view * (1.0 - alpha)
-
-        p = int(pad_size) if pad_size is not None else 0
-        if p > 0 and out.dim() == 4 and out.shape[-1] >= 3:
-            b, h, w, ch = out.shape
-            left, right, top, bottom = self._compute_pad(h, w, p)
-            if left or right or top or bottom:
-                out_nchw = out[..., :3].permute(0, 3, 1, 2).contiguous()
-                padded = []
-                for ci in range(3):
-                    v = float(color[ci].item())
-                    ch_t = out_nchw[:, ci:ci+1, :, :]
-                    ch_p = F.pad(ch_t, (left, right, top, bottom), mode="constant", value=v)
-                    padded.append(ch_p)
-                out_nchw = torch.cat(padded, dim=1)
-                out = out_nchw.permute(0, 2, 3, 1).contiguous()
-
-        return (out,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "AK Replace Alpha with Color": AKReplaceAlphaWithColor,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AK Replace Alpha with Color": "AK Replace Alpha with Color",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/AKReplaceColorWithAlpha.py

@@ -1,153 +0,0 @@
-import torch
-import re
-
-class AKReplaceColorWithAlpha:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "crop_size": ("INT", {"default": 0, "min": 0, "step": 1}),
-                "color_pick_mode": (["user_color", "left_top_pixel", "right_top_pixel", "left_bottom_pixel", "right_bottom_pixel"], {"default": "user_color"}),
-                "color_rgb": ("STRING", {"default": "8, 39, 245", "multiline": False}),
-                "threshold": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
-                "softness": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "replace_color"
-    CATEGORY = "AK/image"
-
-    @staticmethod
-    def _parse_rgb(s: str):
-        parts = [p for p in re.split(r"[,\s;]+", (s or "").strip()) if p != ""]
-        if len(parts) != 3:
-            return (8, 39, 245)
-        vals = []
-        for p in parts:
-            try:
-                v = int(float(p))
-            except Exception:
-                return (8, 39, 245)
-            vals.append(max(0, min(255, v)))
-        return tuple(vals)
-
-    @staticmethod
-    def _pick_corner_color(src_rgb: torch.Tensor, mode: str):
-        # src_rgb: [B, H, W, 3] in 0..1
-        _, h, w, _ = src_rgb.shape
-        if mode == "left_top_pixel":
-            y, x = 0, 0
-        elif mode == "right_top_pixel":
-            y, x = 0, max(0, w - 1)
-        elif mode == "left_bottom_pixel":
-            y, x = max(0, h - 1), 0
-        elif mode == "right_bottom_pixel":
-            y, x = max(0, h - 1), max(0, w - 1)
-        else:
-            y, x = 0, 0
-        return src_rgb[0, y, x, :].clamp(0.0, 1.0)
-
-    @staticmethod
-    def _compute_crop(h: int, w: int, crop_size: int):
-        p = int(crop_size)
-        if p <= 0:
-            return (0, 0, 0, 0)
-
-        # Preserve aspect: shrink the larger dimension by p, shrink the other proportionally.
-        if w >= h:
-            sub_w = min(p, max(0, w - 1))
-            sub_h = int(round(sub_w * (h / max(1, w))))
-        else:
-            sub_h = min(p, max(0, h - 1))
-            sub_w = int(round(sub_h * (w / max(1, h))))
-
-        left = sub_w // 2
-        right = sub_w - left
-        top = sub_h // 2
-        bottom = sub_h - top
-        return (left, right, top, bottom)
-
-    @staticmethod
-    def _center_crop(img: torch.Tensor, crop_size: int):
-        # img: [B,H,W,C]
-        if img is None or img.dim() != 4:
-            return img
-        b, h, w, c = img.shape
-        left, right, top, bottom = AKReplaceColorWithAlpha._compute_crop(h, w, crop_size)
-        if left == 0 and right == 0 and top == 0 and bottom == 0:
-            return img
-        y0 = top
-        y1 = h - bottom
-        x0 = left
-        x1 = w - right
-        if y1 <= y0 or x1 <= x0:
-            return img
-        return img[:, y0:y1, x0:x1, :]
-
-    def replace_color(self, image, crop_size, color_pick_mode, color_rgb, threshold, softness):
-        if image.dim() != 4:
-            return (image,)
-
-        cs = int(crop_size) if crop_size is not None else 0
-        if cs > 0:
-            image = self._center_crop(image, cs)
-
-        c = image.shape[-1]
-        if c < 3:
-            return (image,)
-
-        src_rgb = image[..., :3].clamp(0.0, 1.0)
-
-        if c >= 4:
-            src_a = image[..., 3:4].clamp(0.0, 1.0)
-        else:
-            src_a = torch.ones_like(image[..., :1])
-
-        mode = str(color_pick_mode or "user_color")
-
-        if mode == "user_color":
-            rgb = self._parse_rgb(color_rgb)
-            target = torch.tensor([rgb[0], rgb[1], rgb[2]], device=image.device, dtype=image.dtype) / 255.0
-        else:
-            target = self._pick_corner_color(src_rgb, mode).to(device=image.device, dtype=image.dtype)
-
-        thr = int(threshold) if threshold is not None else 0
-        soft = int(softness) if softness is not None else 0
-        if thr < 0:
-            thr = 0
-        elif thr > 255:
-            thr = 255
-        if soft < 0:
-            soft = 0
-        elif soft > 255:
-            soft = 255
-
-        t0 = float(thr) / 255.0
-        t1 = float(min(255, thr + soft)) / 255.0
-
-        d2 = (src_rgb - target.view(1, 1, 1, 3)).pow(2).sum(dim=-1, keepdim=True)
-
-        if soft <= 0:
-            sel = d2 <= (t0 * t0 + 1e-12)
-            out_a = torch.where(sel, torch.zeros_like(src_a), src_a)
-        else:
-            d = torch.sqrt(d2 + 1e-12)
-            denom = t1 - t0
-            if denom <= 1e-8:
-                denom = 1e-8
-            alpha_factor = ((d - t0) / denom).clamp(0.0, 1.0)
-            out_a = (src_a * alpha_factor).clamp(0.0, 1.0)
-
-        out = torch.cat([src_rgb, out_a], dim=-1)
-        return (out,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "AK Replace Color with Alpha": AKReplaceColorWithAlpha,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AK Replace Color with Alpha": "AK Replace Color with Alpha",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/CLIPTextEncodeAndCombineCached.py

@@ -1,68 +0,0 @@
-class CLIPTextEncodeAndCombineCached:
-    _last_text = None
-    _last_encoded = None
-    _last_clip_id = None
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "clip": ("CLIP",),
-                "text": ("STRING", {"multiline": True, "default": ""}),
-            },
-            "optional": {
-                "conditioning": ("CONDITIONING",),
-            },
-        }
-
-    RETURN_TYPES = ("CONDITIONING",)
-    RETURN_NAMES = ("conditioning",)
-    FUNCTION = "execute"
-    CATEGORY = "AK/conditioning"
-    OUTPUT_NODE = False
-
-    @classmethod
-    def _normalize_text(cls, text):
-        if text is None:
-            return ""
-        return str(text).replace("\r\n", "\n").replace("\r", "\n")
-
-    @classmethod
-    def _has_meaningful_text(cls, text):
-        return bool(text and text.strip())
-
-    @classmethod
-    def _encode_cached(cls, clip, text):
-        clip_id = id(clip)
-        if cls._last_clip_id == clip_id and cls._last_text == text and cls._last_encoded is not None:
-            return cls._last_encoded
-
-        tokens = clip.tokenize(text)
-        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
-        conditioning = [[cond, {"pooled_output": pooled}]]
-
-        cls._last_clip_id = clip_id
-        cls._last_text = text
-        cls._last_encoded = conditioning
-
-        return conditioning
-
-    @classmethod
-    def execute(cls, clip, text, conditioning=None):
-        text = cls._normalize_text(text)
-
-        if not cls._has_meaningful_text(text):
-            if conditioning is not None:
-                return (conditioning,)
-            return ([],)
-
-        new_cond = cls._encode_cached(clip, text)
-
-        if conditioning is None:
-            return (new_cond,)
-
-        return (conditioning + new_cond,)
-
-
-NODE_CLASS_MAPPINGS = {"CLIPTextEncodeAndCombineCached": CLIPTextEncodeAndCombineCached}
-NODE_DISPLAY_NAME_MAPPINGS = {"CLIPTextEncodeAndCombineCached": "CLIP Text Encode & Combine (Cached)"}

custom_nodes/ComfyUI-AK-Pack/nodes/CLIPTextEncodeCached.py

@@ -1,50 +0,0 @@
-class CLIPTextEncodeCached:
-    # Runtime cache: text_hash -> conditioning
-    _last_text = None
-    _last_cond = None
-    _last_clip_id = None
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "clip": ("CLIP",),
-                "text": (
-                    "STRING",
-                    {"multiline": True, "default": "", "forceInput": True},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("CONDITIONING",)
-    RETURN_NAMES = ("conditioning",)
-    FUNCTION = "execute"
-    CATEGORY = "AK/conditioning"
-    OUTPUT_NODE = False
-
-    @classmethod
-    def execute(cls, clip, text):
-        if text is None:
-            text = ""
-
-        text = text.replace("\r\n", "\n").replace("\r", "\n")
-
-        clip_id = id(clip)
-
-        if cls._last_clip_id == clip_id and cls._last_text == text and cls._last_cond is not None:
-            return (cls._last_cond,)
-
-        tokens = clip.tokenize(text)
-        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
-        conditioning = [[cond, {"pooled_output": pooled}]]
-
-        cls._last_clip_id = clip_id
-        cls._last_text = text
-        cls._last_cond = conditioning
-
-        return (conditioning,)
-
-
-NODE_CLASS_MAPPINGS = {"CLIPTextEncodeCached": CLIPTextEncodeCached}
-
-NODE_DISPLAY_NAME_MAPPINGS = {"CLIPTextEncodeCached": "CLIP Text Encode (Cached)"}

custom_nodes/ComfyUI-AK-Pack/nodes/Getter.py

@@ -1,38 +0,0 @@
-class AnyType(str):
-    def __ne__(self, __value: object) -> bool:
-        return False
-
-ANY_TYPE = AnyType("*")
-
-
-class Getter:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {},
-            "optional": {
-                "inp": (ANY_TYPE,),
-            },
-            "hidden": {
-                "var_name": "STRING",
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = (ANY_TYPE,)
-    RETURN_NAMES = ("OBJ",)
-    FUNCTION = "get"
-    CATEGORY = "AK/pipe"
-
-    def get(self, inp=None, var_name="", unique_id=None):
-        if inp is None:
-            raise Exception(f"[Getter {unique_id} {var_name}] inp is not connected")
-        return (inp,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "Getter": Getter,
-}
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "Getter": "Getter",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/IsOneOfGroupsActive.py

@@ -1,43 +0,0 @@
-import math
-
-class IsOneOfGroupsActive:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "group_name_contains": (
-                    "STRING",
-                    {
-                        "default": "",
-                        "multiline": False,
-                    },
-                ),
-                "active_state": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                    },
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("BOOLEAN",)
-    RETURN_NAMES = ("boolean",)
-    FUNCTION = "pass_state"
-    CATEGORY = "AK/logic"
-
-    @classmethod
-    def IS_CHANGED(cls, group_name_contains, active_state):
-        return float("nan")
-
-    def pass_state(self, group_name_contains, active_state):
-        return (active_state,)
-
-
-NODE_CLASS_MAPPINGS = {
-    "IsOneOfGroupsActive": IsOneOfGroupsActive,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "IsOneOfGroupsActive": "IsOneOfGroupsActive",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/PreviewRawText.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class PreviewRawText:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {},
-            "optional": {
-                "text": ("STRING", {"forceInput": True}),
-                "list_values": (
-                    "LIST",
-                    {
-                        "element_type": "STRING",
-                        "forceInput": True,
-                    },
-                ),
-            },
-            "hidden": {
-                "unique_id": "UNIQUE_ID",
-            },
-        }
-
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "notify"
-    OUTPUT_NODE = True
-
-    CATEGORY = "AK/utils"
-
-    @staticmethod
-    def _pretty_json_if_possible(value: str) -> str:
-        if value is None:
-            return ""
-        s = value.strip()
-        if not s:
-            return value
-        if s[0] not in "{[":
-            return value
-        try:
-            obj = json.loads(s)
-        except Exception:
-            return value
-        try:
-            return json.dumps(obj, ensure_ascii=False, indent=2)
-        except Exception:
-            return value
-
-    def notify(self, text=None, list_values=None, unique_id=None):
-        base_text = "" if text is None else str(text)
-        base_text = self._pretty_json_if_possible(base_text)
-
-        def normalize_list_values(value):
-            if value is None:
-                return ""
-            if not isinstance(value, list):
-                v = "NONE" if value is None else str(value)
-                return self._pretty_json_if_possible(v)
-
-            lines = []
-
-            for v in value:
-                if isinstance(v, list):
-                    for inner in v:
-                        if inner is None:
-                            lines.append("NONE")
-                        else:
-                            lines.append(self._pretty_json_if_possible(str(inner)))
-                else:
-                    if v is None:
-                        lines.append("NONE")
-                    else:
-                        lines.append(self._pretty_json_if_possible(str(v)))
-
-            return "\n\n".join(lines)
-
-        list_text = normalize_list_values(list_values)
-
-        if base_text and list_text:
-            final_text = base_text + "\n\n" + list_text
-        elif list_text:
-            final_text = list_text
-        else:
-            final_text = base_text
-
-        return {"ui": {"text": final_text}, "result": (final_text,)}
-
-
-NODE_CLASS_MAPPINGS = {
-    "PreviewRawText": PreviewRawText,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "PreviewRawText": "Preview Raw Text",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/RepeatGroupState.py

@@ -1,35 +0,0 @@
-class RepeatGroupState:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "group_name_contains": (
-                    "STRING",
-                    {
-                        "default": "",
-                        "multiline": False,
-                    },
-                ),
-            }
-        }
-
-    RETURN_TYPES = ()
-    RETURN_NAMES = ()
-    FUNCTION = "do_nothing"
-    CATEGORY = "AK/logic"
-
-    @classmethod
-    def IS_CHANGED(cls, group_name_contains):
-        return float("nan")
-
-    def do_nothing(self, group_name_contains):
-        return ()
-
-
-NODE_CLASS_MAPPINGS = {
-    "RepeatGroupState": RepeatGroupState,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "RepeatGroupState": "Repeat Group State",
-}

custom_nodes/ComfyUI-AK-Pack/nodes/Setter.py

@@ -1,136 +0,0 @@
-import sys, types, bisect
-
-_STORE_KEY = "ak_var_nodes_store"
-
-class AnyType(str):
-    def __ne__(self, __value: object) -> bool:
-        return False
-
-ANY_TYPE = AnyType("*")
-
-def _get_store():
-    st = sys.modules.get(_STORE_KEY)
-    if st is None:
-        st = types.SimpleNamespace(
-            last_prompt_obj_id=None,
-            allowed_ids_by_name={},
-            values_by_name={},
-            names_sorted=[],
-            last_name_by_setter_id={}
-        )
-        sys.modules[_STORE_KEY] = st
-    if not hasattr(st, "last_name_by_setter_id"):
-        st.last_name_by_setter_id = {}
-    return st
-
-def _rebuild_from_prompt(st, prompt):
-    st.allowed_ids_by_name.clear()
-    st.names_sorted.clear()
-    valid_names = set()
-
-    try:
-        if isinstance(prompt, dict):
-            for node_id, node in prompt.items():
-                if not isinstance(node, dict):
-                    continue
-                if node.get("class_type") != "Setter":
-                    continue
-                inputs = node.get("inputs") or {}
-                name = inputs.get("var_name", "")
-                if name is None:
-                    name = ""
-                if not isinstance(name, str):
-                    name = str(name)
-                name = name.strip()
-                if not name:
-                    continue
-
-                sid = str(node_id)
-                old_name = st.last_name_by_setter_id.get(sid)
-
-                if old_name and old_name != name:
-                    if name not in st.values_by_name:
-                        v = st.values_by_name.get(old_name, None)
-                        if v is not None:
-                            st.values_by_name[name] = v
-                    if old_name in st.values_by_name and old_name != name:
-                        del st.values_by_name[old_name]
-
-                st.last_name_by_setter_id[sid] = name
-
-                valid_names.add(name)
-                if name not in st.allowed_ids_by_name:
-                    st.allowed_ids_by_name[name] = sid
-                    if name not in st.values_by_name:
-                        st.values_by_name[name] = None
-                    bisect.insort(st.names_sorted, name)
-
-        for k in list(st.values_by_name.keys()):
-            if k not in valid_names:
-                del st.values_by_name[k]
-
-        for sid, nm in list(st.last_name_by_setter_id.items()):
-            if nm not in valid_names:
-                del st.last_name_by_setter_id[sid]
-    except Exception:
-        st.allowed_ids_by_name.clear()
-        st.names_sorted.clear()
-
-class Setter:
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "obj": (ANY_TYPE,),
-                "var_name": ("STRING", {"default": ""}),
-            },
-            "hidden": {
-                "prompt": "PROMPT",
-                "unique_id": "UNIQUE_ID",
-            }
-        }
-
-    RETURN_TYPES = (ANY_TYPE,)
-    RETURN_NAMES = ("OUT",)
-    FUNCTION = "set"
-    OUTPUT_NODE = True
-    CATEGORY = "AK/pipe"
-
-    def set(self, obj, var_name, prompt=None, unique_id=None):
-        st = _get_store()
-
-        pid = None
-        try:
-            pid = id(prompt)
-        except Exception:
-            pid = None
-
-        if pid is not None and pid != st.last_prompt_obj_id:
-            st.last_prompt_obj_id = pid
-            _rebuild_from_prompt(st, prompt)
-
-        if var_name is None:
-            var_name = ""
-        if not isinstance(var_name, str):
-            var_name = str(var_name)
-        name = var_name.strip()
-        if not name:
-            raise Exception(f"[Setter {unique_id}] var_name is empty")
-
-        if name not in st.allowed_ids_by_name:
-            st.allowed_ids_by_name[name] = str(unique_id)
-            st.values_by_name[name] = None
-            bisect.insort(st.names_sorted, name)
-
-        # value = obj[0] if isinstance(obj, (list, tuple)) else obj
-        value = obj
-        st.values_by_name[name] = value
-        return (value,)
-
-NODE_CLASS_MAPPINGS = {
-    "Setter": Setter,
-}
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "Setter": "Setter",
-}

custom_nodes/ComfyUI-AK-Pack/pyproject.toml

@@ -1,28 +0,0 @@
-[project]
-name = "comfyui-ak-pack"
-publisher = "akawana2"
-version = "3.01"
-frontend_version = "3.01"
-description = "Utility tools. Index Multiple, CLIP Multiple, Pipe, Getter, Setter."
-readme = "README.md"
-requires-python = ">=3.10"
-
-
-packages = ["nodes"]
-
-[project.urls]
-Repository = "https://github.com/akawana/ComfyUI-AK-Pack"
-Documentation = "https://github.com/akawana/ComfyUI-AK-Pack/wiki"
-"Bug Tracker" = "https://github.com/akawana/ComfyUI-AK-Pack/issues"
-
-[tool.comfy_node]
-package = "nodes"
-publisher = "akawana2"
-display_name = "AK Pack"
-summary = "Index Multiple, CLIP Multiple, Pipe, Getter, Setter."
-tags = ["utility", "list", "group", "clip"]
-
-[tool.comfy]
-PublisherId = "akawana2" # TODO (fill in Publisher ID from Comfy Registry Website).
-DisplayName = "AK Pack" # Display name for the Custom Node. Can be changed later.
-Icon = "https://raw.githubusercontent.com/akawana/ComfyUI-Utils-extra/refs/heads/main/icon.jpg"

custom_nodes/ComfyUI-Addoor/classes/AD_AnyFileList.py

@@ -1,88 +0,0 @@
-import os
-import torch
-import numpy as np
-from PIL import Image
-import csv
-
-class AD_AnyFileList:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Directory": ("STRING", {"default": ""}),
-                "Load_Cap": ("INT", {"default": 100, "min": 1, "max": 1000}),
-                "Skip_Frame": ("INT", {"default": 0, "min": 0, "max": 100}),
-                "Filter_By": (["*", "images", "text"],),
-                "Extension": ("STRING", {"default": "*"}),
-                "Deep_Search": ("BOOLEAN", {"default": False}),
-                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})
-            }
-        }
-
-    RETURN_TYPES = ("STRING", "IMAGE", "STRING", "STRING", "STRING", "STRING", "INT", "STRING")
-    RETURN_NAMES = ("Directory_Output", "Image_List", "Text_List", "File_Path_List", "File_Name_List", "File_Name_With_Extension_List", "Total_Files", "Merged_Text")
-    FUNCTION = "process_files"
-    OUTPUT_NODE = True
-    OUTPUT_IS_LIST = (False, True, True, True, True, True, False, False)
-    CATEGORY = "🌻 Addoor/Batch"
-
-    def process_files(self, Directory, Load_Cap, Skip_Frame, Filter_By, Extension, Deep_Search, seed):
-        file_extensions = {
-            "images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"],
-            "text": [".txt", ".csv", ".md", ".json"],
-        }
-        
-        file_paths = []
-        if Deep_Search:
-            for root, _, files in os.walk(Directory):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    file_extension = os.path.splitext(file)[1].lower()
-                    if (Filter_By == "*" or file_extension in file_extensions.get(Filter_By, [])) and \
-                       (Extension == "*" or file.lower().endswith(Extension.lower())):
-                        file_paths.append(file_path)
-        else:
-            for file in os.listdir(Directory):
-                file_path = os.path.join(Directory, file)
-                if os.path.isfile(file_path):
-                    file_extension = os.path.splitext(file)[1].lower()
-                    if (Filter_By == "*" or file_extension in file_extensions.get(Filter_By, [])) and \
-                       (Extension == "*" or file.lower().endswith(Extension.lower())):
-                        file_paths.append(file_path)
-        
-        file_paths = sorted(file_paths)[Skip_Frame:Skip_Frame + Load_Cap]
-        
-        image_list = []
-        text_list = []
-        file_name_list = []
-        file_name_with_extension_list = []
-        merged_text = ""
-        
-        for file_path in file_paths:
-            file_extension = os.path.splitext(file_path)[1].lower()
-            if file_extension in file_extensions["images"]:
-                try:
-                    img = Image.open(file_path).convert("RGB")
-                    image = torch.from_numpy(np.array(img).astype(np.float32) / 255.0).unsqueeze(0)
-                    image_list.append(image)
-                except Exception as e:
-                    print(f"Error loading image '{file_path}': {e}")
-            elif file_extension in file_extensions["text"]:
-                try:
-                    if file_extension == '.csv':
-                        with open(file_path, 'r', newline='', encoding='utf-8') as csvfile:
-                            content = '\n'.join([','.join(row) for row in csv.reader(csvfile)])
-                    else:
-                        with open(file_path, 'r', encoding='utf-8') as txtfile:
-                            content = txtfile.read()
-                    text_list.append(content)
-                    merged_text += content + "\n\n"
-                except Exception as e:
-                    print(f"Error reading file '{file_path}': {e}")
-            
-            file_name_list.append(os.path.splitext(os.path.basename(file_path))[0])
-            file_name_with_extension_list.append(os.path.basename(file_path))
-        
-        total_files = len(file_paths)
-        return (Directory, image_list, text_list, file_paths, file_name_list, file_name_with_extension_list, total_files, merged_text.strip())
-

custom_nodes/ComfyUI-Addoor/classes/AD_BatchImageLoadFromDir.py

@@ -1,52 +0,0 @@
-import os
-import torch
-import numpy as np
-from PIL import Image
-
-class AD_BatchImageLoadFromDir:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "Directory": ("STRING", {"default": ""}),
-                "Load_Cap": ("INT", {"default": 100, "min": 1, "max": 1000}),
-                "Skip_Frame": ("INT", {"default": 0, "min": 0, "max": 100}),
-                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE", "STRING", "STRING", "STRING", "INT")
-    RETURN_NAMES = ("Images", "Image_Paths", "Image_Names_suffix", "Image_Names", "Count")
-    FUNCTION = "load_images"
-    OUTPUT_NODE = True
-    OUTPUT_IS_LIST = (True, True, True, True, False)
-    CATEGORY = "🌻 Addoor/Batch"
-
-    def load_images(self, Directory, Load_Cap, Skip_Frame, seed):
-        image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']
-        file_paths = []
-        for root, dirs, files in os.walk(Directory):
-            for file in files:
-                if any(file.lower().endswith(ext) for ext in image_extensions):
-                    file_paths.append(os.path.join(root, file))
-        file_paths = sorted(file_paths)[Skip_Frame:Skip_Frame + Load_Cap]
-        
-        images = []
-        image_paths = []
-        image_names_suffix = []
-        image_names = []
-        
-        for file_path in file_paths:
-            try:
-                img = Image.open(file_path).convert("RGB")
-                image = torch.from_numpy(np.array(img).astype(np.float32) / 255.0).unsqueeze(0)
-                images.append(image)
-                image_paths.append(file_path)
-                image_names_suffix.append(os.path.basename(file_path))
-                image_names.append(os.path.splitext(os.path.basename(file_path))[0])
-            except Exception as e:
-                print(f"Error loading image '{file_path}': {e}")
-        
-        count = len(images)
-        return (images, image_paths, image_names_suffix, image_names, count)
-

custom_nodes/ComfyUI-Addoor/classes/AD_LoadImageAdvanced.py

@@ -1,87 +0,0 @@
-import os
-import hashlib
-from PIL import Image, ImageSequence, ImageOps
-import numpy as np
-import torch
-import folder_paths
-
-class AD_LoadImageAdvanced:
-    @classmethod
-    def INPUT_TYPES(s):
-        input_dir = folder_paths.get_input_directory()
-
-        files = []
-        for root, dirs, filenames in os.walk(input_dir):
-            for filename in filenames:
-                full_path = os.path.join(root, filename)
-                relative_path = os.path.relpath(full_path, input_dir)
-                relative_path = relative_path.replace("\\", "/")
-                files.append(relative_path)
-
-        return {"required":
-                {"image": (sorted(files), {"image_upload": True}),
-                 "strip_extension": ("BOOLEAN", {"default": True}),
-                 "rgba": ("BOOLEAN", {"default": False})}
-                }
-
-    CATEGORY = "🌻 Addoor/Image"
-
-    RETURN_TYPES = ("IMAGE", "MASK", "STRING")
-    RETURN_NAMES = ("IMAGE", "MASK", "FILENAME")
-
-    FUNCTION = "load_image"
-
-    def load_image(self, image, strip_extension, rgba):
-        image_path = folder_paths.get_annotated_filepath(image)
-        img = Image.open(image_path)
-        output_images = []
-        output_masks = []
-        for i in ImageSequence.Iterator(img):
-            i = ImageOps.exif_transpose(i)
-            if i.mode == 'I':
-                i = i.point(lambda i: i * (1 / 255))
-            if rgba:
-                image = i.convert("RGBA")
-                image = np.array(image).astype(np.float32) / 255.0
-                image = torch.from_numpy(image)[None,]
-            else:
-                image = i.convert("RGB")
-                image = np.array(image).astype(np.float32) / 255.0
-                image = torch.from_numpy(image)[None,]
-            if 'A' in i.getbands():
-                mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
-                mask = 1. - torch.from_numpy(mask)
-            else:
-                mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
-            output_images.append(image)
-            output_masks.append(mask.unsqueeze(0))
-
-        if len(output_images) > 1:
-            output_image = torch.cat(output_images, dim=0)
-            output_mask = torch.cat(output_masks, dim=0)
-        else:
-            output_image = output_images[0]
-            output_mask = output_masks[0]
-
-        if strip_extension:
-            filename = os.path.splitext(image_path)[0]
-        else:
-            filename = os.path.basename(image_path)
-
-        return (output_image, output_mask, filename,)
-
-    @classmethod
-    def IS_CHANGED(s, image, strip_extension, rgba):
-        image_path = folder_paths.get_annotated_filepath(image)
-        m = hashlib.sha256()
-        with open(image_path, 'rb') as f:
-            m.update(f.read())
-        return m.digest().hex()
-
-    @classmethod
-    def VALIDATE_INPUTS(s, image, strip_extension, rgba):
-        if not folder_paths.exists_annotated_filepath(image):
-            return "Invalid image file: {}".format(image)
-
-        return True
-

custom_nodes/ComfyUI-Addoor/classes/AD_PromptReplace.py

@@ -1,59 +0,0 @@
-import random
-
-class AD_PromptReplace:
-    def __init__(self):
-        self.current_index = None
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "Content": ("STRING", {"default": "", "multiline": True}),
-                "Match": ("STRING", {"default": ""}),
-                "Replace": ("STRING", {"default": "", "multiline": True}),
-                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
-                "Increment": ("INT", {"default": 1, "min": 0, "max": 1000}),
-            }
-        }
-
-    RETURN_TYPES = ("STRING", "INT")
-    RETURN_NAMES = ("Replaced_Text", "new_seed")
-    FUNCTION = "replace_prompt"
-    CATEGORY = "🌻 Addoor/Utilities"
-
-    def replace_prompt(self, Content: str, Match: str, Replace: str, seed: int, Increment: int):
-        content_lines = Content.split('\n')
-        replace_lines = Replace.split('\n') if Replace else []
-
-        if not content_lines:
-            content_lines = [""]
-        if not replace_lines:
-            replace_lines = [""]
-
-        # Initialize current_index if it's None
-        if self.current_index is None:
-            if Increment == 0:
-                # Random starting point
-                random.seed(seed)
-                self.current_index = random.randint(0, len(replace_lines) - 1)
-            else:
-                # Start from the beginning
-                self.current_index = 0
-
-        # Select a line based on increment
-        if Increment == 0:
-            # Random selection using seed
-            random.seed(seed)
-            selected_index = random.randint(0, len(replace_lines) - 1)
-        else:
-            # Sequential selection based on increment
-            selected_index = self.current_index
-            self.current_index = (self.current_index + Increment) % len(replace_lines)
-
-        selected_replace = replace_lines[selected_index]
-
-        # Perform text replacement
-        replaced_content = Content.replace(Match, selected_replace) if Match else Content
-
-        return (replaced_content, seed)
-

custom_nodes/ComfyUI-Addoor/example_workflow/RunningHub API.json

@@ -1,500 +0,0 @@
-{
-  "last_node_id": 11,
-  "last_link_id": 8,
-  "nodes": [
-    {
-      "id": 3,
-      "type": "RunningHubWorkflowExecutor",
-      "pos": [
-        1814.84912109375,
-        670.4561157226562
-      ],
-      "size": [
-        352.79998779296875,
-        318
-      ],
-      "flags": {},
-      "order": 6,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "node_info_list",
-          "type": "NODEINFOLIST",
-          "link": 2,
-          "label": "node_info_list"
-        },
-        {
-          "name": "api_key",
-          "type": "STRING",
-          "link": 1,
-          "widget": {
-            "name": "api_key"
-          },
-          "label": "api_key"
-        },
-        {
-          "name": "workflow_id",
-          "type": "STRING",
-          "link": 4,
-          "widget": {
-            "name": "workflow_id"
-          },
-          "label": "workflow_id"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "file_urls",
-          "type": "FILEURL_LIST",
-          "links": [
-            5
-          ],
-          "label": "file_urls",
-          "slot_index": 0
-        },
-        {
-          "name": "task_id",
-          "type": "STRING",
-          "links": null,
-          "label": "task_id"
-        },
-        {
-          "name": "msg",
-          "type": "STRING",
-          "links": null,
-          "label": "msg"
-        },
-        {
-          "name": "promptTips",
-          "type": "STRING",
-          "links": null,
-          "label": "promptTips"
-        },
-        {
-          "name": "taskStatus",
-          "type": "STRING",
-          "links": null,
-          "label": "taskStatus"
-        },
-        {
-          "name": "fileType",
-          "type": "STRING",
-          "links": null,
-          "label": "fileType"
-        },
-        {
-          "name": "code",
-          "type": "STRING",
-          "links": null,
-          "label": "code"
-        },
-        {
-          "name": "json",
-          "type": "STRING",
-          "links": null,
-          "label": "json"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubWorkflowExecutor"
-      },
-      "widgets_values": [
-        "",
-        "",
-        34390019738778,
-        "randomize",
-        60,
-        5
-      ]
-    },
-    {
-      "id": 9,
-      "type": "RunningHubImageUploader",
-      "pos": [
-        621.948974609375,
-        753.6560668945312
-      ],
-      "size": [
-        315,
-        58
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": null,
-          "label": "image"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "filename",
-          "type": "STRING",
-          "links": null,
-          "label": "filename"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubImageUploader"
-      },
-      "widgets_values": [
-        ""
-      ]
-    },
-    {
-      "id": 6,
-      "type": "RunningHubWorkflowID",
-      "pos": [
-        1438.5477294921875,
-        882.5560913085938
-      ],
-      "size": [
-        315,
-        58
-      ],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "STRING",
-          "type": "STRING",
-          "links": [
-            4
-          ],
-          "slot_index": 0,
-          "label": "STRING"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubWorkflowID"
-      },
-      "widgets_values": [
-        "1867408429454426113"
-      ]
-    },
-    {
-      "id": 4,
-      "type": "RunningHubAccountStatus",
-      "pos": [
-        1819.9490966796875,
-        1044.7562255859375
-      ],
-      "size": [
-        341,
-        54
-      ],
-      "flags": {},
-      "order": 5,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "api_key",
-          "type": "STRING",
-          "link": 3,
-          "widget": {
-            "name": "api_key"
-          },
-          "label": "api_key"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "remain_coins",
-          "type": "INT",
-          "links": null,
-          "label": "remain_coins",
-          "slot_index": 0
-        },
-        {
-          "name": "current_task_counts",
-          "type": "INT",
-          "links": null,
-          "label": "current_task_counts"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubAccountStatus"
-      },
-      "widgets_values": [
-        ""
-      ]
-    },
-    {
-      "id": 8,
-      "type": "RunningHubNodeInfoReplace",
-      "pos": [
-        1024.0535888671875,
-        956.73486328125
-      ],
-      "size": [
-        400,
-        338
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "node_info",
-          "type": "NODEINFO",
-          "links": null,
-          "label": "node_info"
-        },
-        {
-          "name": "new_seed",
-          "type": "INT",
-          "links": null,
-          "label": "new_seed"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubNodeInfoReplace"
-      },
-      "widgets_values": [
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        842958099223905,
-        "randomize",
-        1,
-        "normal"
-      ]
-    },
-    {
-      "id": 11,
-      "type": "PreviewImage",
-      "pos": [
-        2522.2890625,
-        673.9710693359375
-      ],
-      "size": [
-        355.91650390625,
-        358.8138427734375
-      ],
-      "flags": {},
-      "order": 8,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 8,
-          "label": "图像"
-        }
-      ],
-      "outputs": [],
-      "properties": {
-        "Node name for S&R": "PreviewImage"
-      }
-    },
-    {
-      "id": 5,
-      "type": "RunningHubFileSaver",
-      "pos": [
-        2187.75634765625,
-        669.653564453125
-      ],
-      "size": [
-        315,
-        218
-      ],
-      "flags": {},
-      "order": 7,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "file_urls",
-          "type": "FILEURL_LIST",
-          "link": 5,
-          "label": "file_urls"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "output_paths",
-          "type": "STRING",
-          "links": [],
-          "label": "output_paths",
-          "slot_index": 0
-        },
-        {
-          "name": "previews",
-          "type": "IMAGE",
-          "links": [
-            8
-          ],
-          "label": "previews",
-          "slot_index": 1
-        },
-        {
-          "name": "file_types",
-          "type": "STRING",
-          "links": null,
-          "label": "file_types"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubFileSaver"
-      },
-      "widgets_values": [
-        "outputs",
-        "RH_Output",
-        "_",
-        4,
-        "auto",
-        false
-      ]
-    },
-    {
-      "id": 1,
-      "type": "RunningHubInit",
-      "pos": [
-        1439.84912109375,
-        768.4561157226562
-      ],
-      "size": [
-        315,
-        58
-      ],
-      "flags": {
-        "collapsed": false
-      },
-      "order": 3,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "STRING",
-          "type": "STRING",
-          "links": [
-            1,
-            3
-          ],
-          "slot_index": 0,
-          "label": "STRING"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubInit"
-      },
-      "widgets_values": [
-        ""
-      ]
-    },
-    {
-      "id": 2,
-      "type": "RunningHubNodeInfo",
-      "pos": [
-        1021.8431396484375,
-        672.1781005859375
-      ],
-      "size": [
-        400,
-        200
-      ],
-      "flags": {},
-      "order": 4,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "previous_node_info",
-          "type": "NODEINFOLIST",
-          "link": null,
-          "shape": 7,
-          "label": "previous_node_info"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "NODEINFOLIST",
-          "type": "NODEINFOLIST",
-          "links": [
-            2
-          ],
-          "slot_index": 0,
-          "label": "NODEINFOLIST"
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "RunningHubNodeInfo"
-      },
-      "widgets_values": [
-        "6",
-        "text",
-        "3D Snake,Wearing light gray clothes,with a gold necklace,glasses,smiling face,light background,high-definitiona,gold necklace sign on its neck that reads \"2025.\" The picture is in the middle. Fireworks in the sky,red background,3D,C4D,",
-        ""
-      ]
-    }
-  ],
-  "links": [
-    [
-      1,
-      1,
-      0,
-      3,
-      1,
-      "STRING"
-    ],
-    [
-      2,
-      2,
-      0,
-      3,
-      0,
-      "NODEINFOLIST"
-    ],
-    [
-      3,
-      1,
-      0,
-      4,
-      0,
-      "STRING"
-    ],
-    [
-      4,
-      6,
-      0,
-      3,
-      2,
-      "STRING"
-    ],
-    [
-      5,
-      3,
-      0,
-      5,
-      0,
-      "FILEURL_LIST"
-    ],
-    [
-      8,
-      5,
-      1,
-      11,
-      0,
-      "IMAGE"
-    ]
-  ],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "scale": 0.8264462809917354,
-      "offset": [
-        -509.6418520759915,
-        -255.05204017404154
-      ]
-    }
-  },
-  "version": 0.4
-}

custom_nodes/ComfyUI-Addoor/nodes/AddPaddingAdvanced.py

@@ -1,435 +0,0 @@
-"""
-@author: ComfyNodePRs
-@title: ComfyUI Advanced Padding
-@description: Advanced padding node with scaling capabilities
-@version: 1.0.0
-@project: https://github.com/ComfyNodePRs/advanced-padding
-@author: https://github.com/ComfyNodePRs
-"""
-
-import PIL.Image as Image
-import PIL.ImageDraw as ImageDraw
-import numpy as np
-import torch
-import torchvision.transforms as t
-
-
-class AD_PaddingAdvanced:
-    def __init__(self):
-        pass
-     
-    FUNCTION = "process_image"
-    CATEGORY = "🌻 Addoor/image"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "scale_by": ("FLOAT", {
-                    "default": 1.0,
-                    "min": 0.1,
-                    "max": 8.0,
-                    "step": 0.05,
-                    "display": "number"
-                }),
-                "upscale_method": (["nearest-exact", "bilinear", "bicubic", "lanczos"], {"default": "lanczos"}),
-                "left": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "top": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "right": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "bottom": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "color": ("STRING", {"default": "#ffffff"}),
-                "transparent": ("BOOLEAN", {"default": False}),
-            },
-            "optional": {
-                "background": ("IMAGE",),
-            }
-        }
-    
-    RETURN_TYPES = ("IMAGE", "MASK")
-    RETURN_NAMES = ("image", "mask")
-
-    def add_padding(self, image, left, top, right, bottom, color="#ffffff", transparent=False):
-        padded_images = []
-        image = [self.tensor2pil(img) for img in image]
-        for img in image:
-            padded_image = Image.new("RGBA" if transparent else "RGB", 
-                 (img.width + left + right, img.height + top + bottom), 
-                 (0, 0, 0, 0) if transparent else self.hex_to_tuple(color))
-            padded_image.paste(img, (left, top))
-            padded_images.append(self.pil2tensor(padded_image))
-        return torch.cat(padded_images, dim=0)
-     
-    def create_mask(self, image, left, top, right, bottom):
-        masks = []
-        image = [self.tensor2pil(img) for img in image]
-        for img in image:
-            shape = (left, top, img.width + left, img.height + top)
-            mask_image = Image.new("L", (img.width + left + right, img.height + top + bottom), 255)
-            draw = ImageDraw.Draw(mask_image)
-            draw.rectangle(shape, fill=0)
-            masks.append(self.pil2tensor(mask_image))
-        return torch.cat(masks, dim=0)
-
-    def scale_image(self, image, scale_by, method):
-        scaled_images = []
-        image = [self.tensor2pil(img) for img in image]
-        
-        resampling_methods = {
-            "nearest-exact": Image.Resampling.NEAREST,
-            "bilinear": Image.Resampling.BILINEAR,
-            "bicubic": Image.Resampling.BICUBIC,
-            "lanczos": Image.Resampling.LANCZOS,
-        }
-        
-        for img in image:
-            # 计算新尺寸
-            new_width = int(img.width * scale_by)
-            new_height = int(img.height * scale_by)
-            
-            # 使用选定的方法进行缩放
-            scaled_img = img.resize(
-                (new_width, new_height),
-                resampling_methods.get(method, Image.Resampling.LANCZOS)
-            )
-            scaled_images.append(self.pil2tensor(scaled_img))
-            
-        return torch.cat(scaled_images, dim=0)
-     
-    def hex_to_tuple(self, color):
-        if not isinstance(color, str):
-            raise ValueError("Color must be a hex string")
-        color = color.strip("#")
-        return tuple([int(color[i:i + 2], 16) for i in range(0, len(color), 2)])
-     
-    def tensor2pil(self, image):
-        return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
-    
-    def pil2tensor(self, image):
-        return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
-
-    def composite_with_background(self, image, background):
-        """将图片居中合成到背景上"""
-        image_pil = self.tensor2pil(image[0])  # 获取第一帧
-        bg_pil = self.tensor2pil(background[0])
-        
-        # 创建新的景图像
-        result = bg_pil.copy()
-        
-        # 计算居中位置
-        x = (bg_pil.width - image_pil.width) // 2
-        y = (bg_pil.height - image_pil.height) // 2
-        
-        # 如果前景图比背景大，需要裁剪
-        if image_pil.width > bg_pil.width or image_pil.height > bg_pil.height:
-            # 计算裁剪区域
-            crop_left = max(0, (image_pil.width - bg_pil.width) // 2)
-            crop_top = max(0, (image_pil.height - bg_pil.height) // 2)
-            crop_right = min(image_pil.width, crop_left + bg_pil.width)
-            crop_bottom = min(image_pil.height, crop_top + bg_pil.height)
-            
-            # 裁剪图片
-            image_pil = image_pil.crop((crop_left, crop_top, crop_right, crop_bottom))
-            
-            # 更新粘贴位置
-            x = max(0, (bg_pil.width - image_pil.width) // 2)
-            y = max(0, (bg_pil.height - image_pil.height) // 2)
-        
-        # 如果前景图有透明通道，使用alpha通道合成
-        if image_pil.mode == 'RGBA':
-            result.paste(image_pil, (x, y), image_pil)
-        else:
-            result.paste(image_pil, (x, y))
-        
-        return self.pil2tensor(result)
-
-    def process_image(self, image, scale_by, upscale_method, left, top, right, bottom, color, transparent, background=None):
-        # 首先进行缩放
-        if scale_by != 1.0:
-            image = self.scale_image(image, scale_by, upscale_method)
-        
-        # 添加padding
-        padded_image = self.add_padding(image, left, top, right, bottom, color, transparent)
-        
-        # 如果有背景图，进行合成
-        if background is not None:
-            result = []
-            for i in range(len(padded_image)):
-                # 处理每一帧
-                frame = padded_image[i:i+1]
-                composited = self.composite_with_background(frame, background)
-                result.append(composited)
-            padded_image = torch.cat(result, dim=0)
-        
-        # 创建mask
-        mask = self.create_mask(image, left, top, right, bottom)
-        
-        return (padded_image, mask)
-
-
-class AD_ImageConcat:
-    def __init__(self):
-        pass
-    
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image1": ("IMAGE",),
-                "image2": ("IMAGE",),
-                "direction": (["horizontal", "vertical"], {"default": "horizontal"}),
-                "match_size": ("BOOLEAN", {"default": True}),
-                "method": (["lanczos", "bicubic", "bilinear", "nearest"], {"default": "lanczos"}),
-            }
-        }
-    
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "concat_images"
-    CATEGORY = "🌻 Addoor/image"
-
-    def concat_images(self, image1, image2, direction="horizontal", match_size=False, method="lanczos"):
-        try:
-            # 转换为 PIL 图像
-            img1 = tensor_to_image(image1[0])
-            img2 = tensor_to_image(image2[0])
-            
-            # 确保两张图片的模式相同
-            if img1.mode != img2.mode:
-                if 'A' in img1.mode or 'A' in img2.mode:
-                    img1 = img1.convert('RGBA')
-                    img2 = img2.convert('RGBA')
-                else:
-                    img1 = img1.convert('RGB')
-                    img2 = img2.convert('RGB')
-
-            # 如果需要匹配尺寸
-            if match_size:
-                if direction == "horizontal":
-                    # 横向拼接，匹配高度
-                    if img1.height != img2.height:
-                        new_height = img2.height
-                        new_width = int(img1.width * (new_height / img1.height))
-                        img1 = img1.resize(
-                            (new_width, new_height),
-                            get_sampler_by_name(method)
-                        )
-                else:  # vertical
-                    # 纵向拼接，匹配宽度
-                    if img1.width != img2.width:
-                        new_width = img2.width
-                        new_height = int(img1.height * (new_width / img1.width))
-                        img1 = img1.resize(
-                            (new_width, new_height),
-                            get_sampler_by_name(method)
-                        )
-
-            # 创建新图像
-            if direction == "horizontal":
-                new_width = img1.width + img2.width
-                new_height = max(img1.height, img2.height)
-            else:  # vertical
-                new_width = max(img1.width, img2.width)
-                new_height = img1.height + img2.height
-
-            # 创建新的画布
-            mode = img1.mode
-            new_image = Image.new(mode, (new_width, new_height))
-
-            # 计算粘贴位置（居中对齐）
-            if direction == "horizontal":
-                y1 = (new_height - img1.height) // 2
-                y2 = (new_height - img2.height) // 2
-                new_image.paste(img1, (0, y1))
-                new_image.paste(img2, (img1.width, y2))
-            else:  # vertical
-                x1 = (new_width - img1.width) // 2
-                x2 = (new_width - img2.width) // 2
-                new_image.paste(img1, (x1, 0))
-                new_image.paste(img2, (x2, img1.height))
-
-            # 转换回 tensor
-            tensor = image_to_tensor(new_image)
-            tensor = tensor.unsqueeze(0)
-            tensor = tensor.permute(0, 2, 3, 1)
-            
-            return (tensor,)
-            
-        except Exception as e:
-            print(f"Error concatenating images: {str(e)}")
-            return (image1,)
-
-
-# 添加颜色常量
-COLORS = [
-    "white", "black", "red", "green", "blue", "yellow", "purple", "orange",
-    "gray", "brown", "pink", "cyan", "custom"
-]
-
-# 颜色映射
-color_mapping = {
-    "white": "#FFFFFF",
-    "black": "#000000",
-    "red": "#FF0000",
-    "green": "#00FF00",
-    "blue": "#0000FF",
-    "yellow": "#FFFF00",
-    "purple": "#800080",
-    "orange": "#FFA500",
-    "gray": "#808080",
-    "brown": "#A52A2A",
-    "pink": "#FFC0CB",
-    "cyan": "#00FFFF"
-}
-
-def get_color_values(color_name, color_hex, mapping):
-    """获取颜色值"""
-    if color_name == "custom":
-        return color_hex
-    return mapping.get(color_name, "#000000")
-
-# 添加图像处理工具函数
-def get_sampler_by_name(method: str) -> int:
-    """Get PIL resampling method by name."""
-    samplers = {
-        "lanczos": Image.LANCZOS,
-        "bicubic": Image.BICUBIC,
-        "hamming": Image.HAMMING,
-        "bilinear": Image.BILINEAR,
-        "box": Image.BOX,
-        "nearest": Image.NEAREST
-    }
-    return samplers.get(method, Image.LANCZOS)
-
-class AD_ColorImage:
-    """Create a solid color image with advanced options."""
-    
-    def __init__(self):
-        pass
-
-    # 预定义颜色映射
-    COLOR_PRESETS = {
-        "white": "#FFFFFF",
-        "black": "#000000",
-        "red": "#FF0000",
-        "green": "#00FF00",
-        "blue": "#0000FF",
-        "yellow": "#FFFF00",
-        "purple": "#800080",
-        "orange": "#FFA500",
-        "gray": "#808080",
-        "custom": "custom"
-    }
-     
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "width": ("INT", {
-                    "default": 512,
-                    "min": 1,
-                    "max": 8192,
-                    "step": 1
-                }),
-                "height": ("INT", {
-                    "default": 512,
-                    "min": 1,
-                    "max": 8192,
-                    "step": 1
-                }),
-                "color": (list(cls.COLOR_PRESETS.keys()), {
-                    "default": "white"
-                }),
-                "hex_color": ("STRING", {
-                    "default": "#FFFFFF",
-                    "multiline": False
-                }),
-                "alpha": ("FLOAT", {
-                    "default": 1.0,
-                    "min": 0.0,
-                    "max": 1.0,
-                    "step": 0.01
-                }),
-            },
-            "optional": {
-                "reference_image": ("IMAGE",),
-            }
-        }
-    
-    RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("image",)
-    FUNCTION = "create_color_image"
-    CATEGORY = "🌻 Addoor/image"
-
-    def hex_to_rgb(self, hex_color: str) -> tuple:
-        """Convert hex color to RGB tuple."""
-        hex_color = hex_color.lstrip('#')
-        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-
-    def create_color_image(
-        self,
-        width: int,
-        height: int,
-        color: str,
-        hex_color: str,
-        alpha: float,
-        reference_image = None
-    ):
-        try:
-            # 如果有参考图片，使用其尺寸
-            if reference_image is not None:
-                _, height, width, _ = reference_image.shape
-            
-            # 获取颜色值
-            if color == "custom":
-                rgb_color = self.hex_to_rgb(hex_color)
-            else:
-                rgb_color = self.hex_to_rgb(self.COLOR_PRESETS[color])
-            
-            # 创建图像
-            canvas = Image.new(
-                "RGBA",
-                (width, height),
-                (*rgb_color, int(alpha * 255))
-            )
-            
-            # 转换为 tensor
-            tensor = image_to_tensor(canvas)
-            tensor = tensor.unsqueeze(0)
-            tensor = tensor.permute(0, 2, 3, 1)
-            
-            return (tensor,)
-            
-        except Exception as e:
-            print(f"Error creating color image: {str(e)}")
-            canvas = Image.new(
-                "RGB",
-                (width, height),
-                (0, 0, 0)
-            )
-            tensor = image_to_tensor(canvas)
-            tensor = tensor.unsqueeze(0)
-            tensor = tensor.permute(0, 2, 3, 1)
-            return (tensor,)
-
-def tensor_to_image(tensor):
-    """Convert tensor to PIL Image."""
-    if len(tensor.shape) == 4:
-        tensor = tensor.squeeze(0)  # 移除 batch 维度
-    return t.ToPILImage()(tensor.permute(2, 0, 1))
-
-def image_to_tensor(image):
-    """Convert PIL Image to tensor."""
-    tensor = t.ToTensor()(image)
-    return tensor
-
-NODE_CLASS_MAPPINGS = {
-    "AD_advanced-padding": AD_PaddingAdvanced,
-    "AD_image-concat": AD_ImageConcat,
-    "AD_color-image": AD_ColorImage,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "AD_advanced-padding": "AD Advanced Padding",
-    "AD_image-concat": "AD Image Concatenation",
-    "AD_color-image": "AD Color Image",
-} 

custom_nodes/ComfyUI-Addoor/nodes/AddPaddingBase.py

@@ -1,99 +0,0 @@
-"""
-@author: ealkanat
-@title: ComfyUI Easy Padding
-@description: A simple custom node for creates padding for given image
-@version: 1.0.2
-@project: https://github.com/erkana/comfyui_easy_padding
-@author: https://github.com/erkana
-"""
-
-import PIL.Image as Image
-import PIL.ImageDraw as ImageDraw
-import numpy as np
-import torch
-
-
-class AddPaddingBase:
-     def __init__(self):
-        pass
-     
-     FUNCTION = "resize"
-     CATEGORY = "🌻 Addoor/image"
-
-     def add_padding(self, image, left, top, right, bottom, color="#ffffff", transparent=False):
-            padded_images = []
-            image = [self.tensor2pil(img) for img in image]
-            for img in image:
-                padded_image = Image.new("RGBA" if transparent else "RGB", 
-                     (img.width + left + right, img.height + top + bottom), 
-                     (0, 0, 0, 0) if transparent else self.hex_to_tuple(color))
-                padded_image.paste(img, (left, top))
-                padded_images.append(self.pil2tensor(padded_image))
-            return torch.cat(padded_images, dim=0)
-     
-     def create_mask(self, image, left, top, right, bottom):
-            masks = []
-            image = [self.tensor2pil(img) for img in image]
-            for img in image:
-                shape = (left, top, img.width + left, img.height + top)
-                mask_image = Image.new("L", (img.width + left + right, img.height + top + bottom), 255)
-                draw = ImageDraw.Draw(mask_image)
-                draw.rectangle(shape, fill=0)
-                masks.append(self.pil2tensor(mask_image))
-            return torch.cat(masks, dim=0)
-     
-     def hex_to_float(self, color):
-        if not isinstance(color, str):
-            raise ValueError("Color must be a hex string")
-        color = color.strip("#")
-        return int(color, 16) / 255.0
-     
-     def hex_to_tuple(self, color):
-        if not isinstance(color, str):
-            raise ValueError("Color must be a hex string")
-        color = color.strip("#")
-        return tuple([int(color[i:i + 2], 16) for i in range(0, len(color), 2)])
-     
-     # Tensor to PIL
-     def tensor2pil(self, image):
-        return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
-    
-     # PIL to Tensor
-     def pil2tensor(self, image):
-        return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
-
-
-
-class AddPadding(AddPaddingBase):
-
-    def __init__(self):
-        pass
-    
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "left": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "top": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "right": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "bottom": ("INT", {"default": 0, "step": 1, "min": 0, "max": 4096}),
-                "color": ("STRING", {"default": "#ffffff"}),
-                "transparent": ("BOOLEAN", {"default": False}),
-            },
-        }
-    
-    RETURN_TYPES = ("IMAGE", "MASK")
-
-    def resize(self, image, left, top, right, bottom, color, transparent):
-        return (self.add_padding(image, left, top, right, bottom, color, transparent),
-                self.create_mask(image, left, top, right, bottom),)
-
-
-NODE_CLASS_MAPPINGS = {
-    "comfyui-easy-padding": AddPadding,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "comfyui-easy-padding": "ComfyUI Easy Padding",
-}

custom_nodes/ComfyUI-Addoor/nodes/ComfyUI-FofrToolkit.py

@@ -1,126 +0,0 @@
-"""
-@name: "ComfyUI FofrToolkit",
-@version: (1,0,0),
-@author: "fofr",
-@description: "Experimental toolkit for comfyui.",
-@project: "https://github.com/fofr/comfyui-fofr-toolkit",
-@url: "https://github.com/fofr",
-"""
-
-
-class ToolkitIncrementer:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "current_index": (
-                    "INT",
-                    {
-                        "default": 0,
-                        "min": 0,
-                        "max": 0xFFFFFFFFFFFFFFFF,
-                        "control_after_generate": True,
-                    },
-                ),
-            },
-            "optional": {
-                "max": (
-                    "INT",
-                    {"default": 10, "min": 0, "max": 0xFFFFFFFFFFFFFFFF},
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("INT", "STRING")
-    RETURN_NAMES = ("INT", "STRING")
-    FUNCTION = "increment"
-    CATEGORY = "🌻 Addoor/Utilities"
-
-    def increment(self, current_index, max=0):
-        if max == 0:
-            result = current_index
-        else:
-            result = current_index % (max + 1)
-            
-        return (result, str(result))
-
-
-class ToolkitWidthAndHeightFromAspectRatio:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "aspect_ratio": (
-                    [
-                        "1:1",
-                        "1:2",
-                        "2:1",
-                        "2:3",
-                        "3:2",
-                        "3:4",
-                        "4:3",
-                        "4:5",
-                        "5:4",
-                        "9:16",
-                        "16:9",
-                        "9:21",
-                        "21:9",
-                    ],
-                    {"default": "1:1"},
-                ),
-                "target_size": ("INT", {"default": 1024, "min": 64, "max": 8192}),
-            },
-            "optional": {
-                "multiple_of": ("INT", {"default": 8, "min": 1, "max": 1024}),
-            },
-        }
-
-    RETURN_TYPES = ("INT", "INT")
-    RETURN_NAMES = ("width", "height")
-    FUNCTION = "width_and_height_from_aspect_ratio"
-    CATEGORY = "🌻 Addoor/Utilities"
-
-    def width_and_height_from_aspect_ratio(
-        self, aspect_ratio, target_size, multiple_of=8
-    ):
-        w, h = map(int, aspect_ratio.split(":"))
-        scale = (target_size**2 / (w * h)) ** 0.5
-        width = round(w * scale / multiple_of) * multiple_of
-        height = round(h * scale / multiple_of) * multiple_of
-        return (width, height)
-
-
-class ToolkitWidthAndHeightForImageScaling:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "target_size": (
-                    "INT",
-                    {"default": 1024, "min": 64, "max": 8192},
-                ),
-            },
-            "optional": {
-                "multiple_of": ("INT", {"default": 8, "min": 1, "max": 1024}),
-            },
-        }
-
-    RETURN_TYPES = ("INT", "INT")
-    RETURN_NAMES = ("width", "height")
-    FUNCTION = "scale_image_to_target"
-    CATEGORY = "🌻 Addoor/Utilities"
-
-    def scale_image_to_target(self, image, target_size, multiple_of=8):
-        h, w = image.shape[1:3]
-        scale = (target_size**2 / (w * h)) ** 0.5
-        width = round(w * scale / multiple_of) * multiple_of
-        height = round(h * scale / multiple_of) * multiple_of
-        return (width, height)
-
-
-NODE_CLASS_MAPPINGS = {
-    "Incrementer 🪴": ToolkitIncrementer,
-    "Width and height from aspect ratio 🪴": ToolkitWidthAndHeightFromAspectRatio,
-    "Width and height for scaling image to ideal resolution 🪴": ToolkitWidthAndHeightForImageScaling,
-}

custom_nodes/ComfyUI-Addoor/nodes/ComfyUI-imageResize.py

@@ -1,172 +0,0 @@
-"""
-@author: palant
-@title: ComfyUI-imageResize
-@description: Custom node for image resizing.
-@version: 1.0.0
-@project: https://github.com/palant/image-resize-comfyui
-@author: https://github.com/palant
-"""
-
-import torch
-
-class ImageResize:
-    def __init__(self):
-        pass
-
-
-    ACTION_TYPE_RESIZE = "resize only"
-    ACTION_TYPE_CROP = "crop to ratio"
-    ACTION_TYPE_PAD = "pad to ratio"
-    RESIZE_MODE_DOWNSCALE = "reduce size only"
-    RESIZE_MODE_UPSCALE = "increase size only"
-    RESIZE_MODE_ANY = "any"
-    RETURN_TYPES = ("IMAGE", "MASK",)
-    FUNCTION = "resize"
-    CATEGORY = "🌻 Addoor/image"
-
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "pixels": ("IMAGE",),
-                "action": ([s.ACTION_TYPE_RESIZE, s.ACTION_TYPE_CROP, s.ACTION_TYPE_PAD],),
-                "smaller_side": ("INT", {"default": 0, "min": 0, "max": 8192, "step": 8}),
-                "larger_side": ("INT", {"default": 0, "min": 0, "max": 8192, "step": 8}),
-                "scale_factor": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.1}),
-                "resize_mode": ([s.RESIZE_MODE_DOWNSCALE, s.RESIZE_MODE_UPSCALE, s.RESIZE_MODE_ANY],),
-                "side_ratio": ("STRING", {"default": "4:3"}),
-                "crop_pad_position": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
-                "pad_feathering": ("INT", {"default": 20, "min": 0, "max": 8192, "step": 1}),
-            },
-            "optional": {
-                "mask_optional": ("MASK",),
-            },
-        }
-
-
-    @classmethod
-    def VALIDATE_INPUTS(s, action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio, **_):
-        if side_ratio is not None:
-            if action != s.ACTION_TYPE_RESIZE and s.parse_side_ratio(side_ratio) is None:
-                return f"Invalid side ratio: {side_ratio}"
-
-        if smaller_side is not None and larger_side is not None and scale_factor is not None:
-            if int(smaller_side > 0) + int(larger_side > 0) + int(scale_factor > 0) > 1:
-                return f"At most one scaling rule (smaller_side, larger_side, scale_factor) should be enabled by setting a non-zero value"
-
-        if scale_factor is not None:
-            if resize_mode == s.RESIZE_MODE_DOWNSCALE and scale_factor > 1.0:
-                return f"For resize_mode {s.RESIZE_MODE_DOWNSCALE}, scale_factor should be less than one but got {scale_factor}"
-            if resize_mode == s.RESIZE_MODE_UPSCALE and scale_factor > 0.0 and scale_factor < 1.0:
-                return f"For resize_mode {s.RESIZE_MODE_UPSCALE}, scale_factor should be larger than one but got {scale_factor}"
-
-        return True
-
-
-    @classmethod
-    def parse_side_ratio(s, side_ratio):
-        try:
-            x, y = map(int, side_ratio.split(":", 1))
-            if x < 1 or y < 1:
-                raise Exception("Ratio factors have to be positive numbers")
-            return float(x) / float(y)
-        except:
-            return None
-
-
-    def resize(self, pixels, action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio, crop_pad_position, pad_feathering, mask_optional=None):
-        validity = self.VALIDATE_INPUTS(action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio)
-        if validity is not True:
-            raise Exception(validity)
-
-        height, width = pixels.shape[1:3]
-        if mask_optional is None:
-            mask = torch.zeros(1, height, width, dtype=torch.float32)
-        else:
-            mask = mask_optional
-            if mask.shape[1] != height or mask.shape[2] != width:
-                mask = torch.nn.functional.interpolate(mask.unsqueeze(0), size=(height, width), mode="bicubic").squeeze(0).clamp(0.0, 1.0)
-
-        crop_x, crop_y, pad_x, pad_y = (0.0, 0.0, 0.0, 0.0)
-        if action == self.ACTION_TYPE_CROP:
-            target_ratio = self.parse_side_ratio(side_ratio)
-            if height * target_ratio < width:
-                crop_x = width - height * target_ratio
-            else:
-                crop_y = height - width / target_ratio
-        elif action == self.ACTION_TYPE_PAD:
-            target_ratio = self.parse_side_ratio(side_ratio)
-            if height * target_ratio > width:
-                pad_x = height * target_ratio - width
-            else:
-                pad_y = width / target_ratio - height
-
-        if smaller_side > 0:
-            if width + pad_x - crop_x > height + pad_y - crop_y:
-                scale_factor = float(smaller_side) / (height + pad_y - crop_y)
-            else:
-                scale_factor = float(smaller_side) / (width + pad_x - crop_x)
-        if larger_side > 0:
-            if width + pad_x - crop_x > height + pad_y - crop_y:
-                scale_factor = float(larger_side) / (width + pad_x - crop_x)
-            else:
-                scale_factor = float(larger_side) / (height + pad_y - crop_y)
-
-        if (resize_mode == self.RESIZE_MODE_DOWNSCALE and scale_factor >= 1.0) or (resize_mode == self.RESIZE_MODE_UPSCALE and scale_factor <= 1.0):
-            scale_factor = 0.0
-
-        if scale_factor > 0.0:
-            pixels = torch.nn.functional.interpolate(pixels.movedim(-1, 1), scale_factor=scale_factor, mode="bicubic", antialias=True).movedim(1, -1).clamp(0.0, 1.0)
-            mask = torch.nn.functional.interpolate(mask.unsqueeze(0), scale_factor=scale_factor, mode="bicubic", antialias=True).squeeze(0).clamp(0.0, 1.0)
-            height, width = pixels.shape[1:3]
-
-            crop_x *= scale_factor
-            crop_y *= scale_factor
-            pad_x *= scale_factor
-            pad_y *= scale_factor
-
-        if crop_x > 0.0 or crop_y > 0.0:
-            remove_x = (round(crop_x * crop_pad_position), round(crop_x * (1 - crop_pad_position))) if crop_x > 0.0 else (0, 0)
-            remove_y = (round(crop_y * crop_pad_position), round(crop_y * (1 - crop_pad_position))) if crop_y > 0.0 else (0, 0)
-            pixels = pixels[:, remove_y[0]:height - remove_y[1], remove_x[0]:width - remove_x[1], :]
-            mask = mask[:, remove_y[0]:height - remove_y[1], remove_x[0]:width - remove_x[1]]
-        elif pad_x > 0.0 or pad_y > 0.0:
-            add_x = (round(pad_x * crop_pad_position), round(pad_x * (1 - crop_pad_position))) if pad_x > 0.0 else (0, 0)
-            add_y = (round(pad_y * crop_pad_position), round(pad_y * (1 - crop_pad_position))) if pad_y > 0.0 else (0, 0)
-
-            new_pixels = torch.zeros(pixels.shape[0], height + add_y[0] + add_y[1], width + add_x[0] + add_x[1], pixels.shape[3], dtype=torch.float32)
-            new_pixels[:, add_y[0]:height + add_y[0], add_x[0]:width + add_x[0], :] = pixels
-            pixels = new_pixels
-
-            new_mask = torch.ones(mask.shape[0], height + add_y[0] + add_y[1], width + add_x[0] + add_x[1], dtype=torch.float32)
-            new_mask[:, add_y[0]:height + add_y[0], add_x[0]:width + add_x[0]] = mask
-            mask = new_mask
-
-            if pad_feathering > 0:
-                for i in range(mask.shape[0]):
-                    for j in range(pad_feathering):
-                        feather_strength = (1 - j / pad_feathering) * (1 - j / pad_feathering)
-                        if add_x[0] > 0 and j < width:
-                            for k in range(height):
-                                mask[i, k, add_x[0] + j] = max(mask[i, k, add_x[0] + j], feather_strength)
-                        if add_x[1] > 0 and j < width:
-                            for k in range(height):
-                                mask[i, k, width + add_x[0] - j - 1] = max(mask[i, k, width + add_x[0] - j - 1], feather_strength)
-                        if add_y[0] > 0 and j < height:
-                            for k in range(width):
-                                mask[i, add_y[0] + j, k] = max(mask[i, add_y[0] + j, k], feather_strength)
-                        if add_y[1] > 0 and j < height:
-                            for k in range(width):
-                                mask[i, height + add_y[0] - j - 1, k] = max(mask[i, height + add_y[0] - j - 1, k], feather_strength)
-
-        return (pixels, mask)
-
-
-NODE_CLASS_MAPPINGS = {
-    "ImageResize": ImageResize
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "ImageResize": "Image Resize"
-}

custom_nodes/ComfyUI-Addoor/nodes/ComfyUI-textAppend.py

@@ -1,48 +0,0 @@
-# text_append_node.py
-
-class TextAppendNode:
-    def __init__(self):
-        pass
-    
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "current_text": ("STRING", {"multiline": True}),
-                "new_text": ("STRING", {"multiline": True}),
-                "mode": (["append", "prepend"],),
-            },
-        }
-
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "process_text"
-    CATEGORY = "🌻 Addoor/text"
-
-    def process_text(self, current_text, new_text, mode):
-        current_lines = [line.strip() for line in current_text.split('\n') if line.strip()]
-        new_lines = [line.strip() for line in new_text.split('\n') if line.strip()]
-        
-        result = []
-        
-        # If current_text is empty, return new_text
-        if not current_lines:
-            return (new_text,)
-        
-        if mode == "append":
-            for current_line in current_lines:
-                for new_line in new_lines:
-                    result.append(f"{current_line} {new_line}")
-        elif mode == "prepend":
-            for current_line in current_lines:
-                for new_line in new_lines:
-                    result.append(f"{new_line} {current_line}")
-        
-        return ('\n'.join(result),)
-
-NODE_CLASS_MAPPINGS = {
-    "TextAppendNode": TextAppendNode
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "TextAppendNode": "Text Append/Prepend"
-}

custom_nodes/ComfyUI-Addoor/nodes/__init__.py

@@ -1,62 +0,0 @@
-"""
-Addoor Nodes for ComfyUI
-Provides nodes for image processing and other utilities
-"""
-
-import os
-import glob
-import logging
-import importlib
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# 首先定义映射字典
-NODE_CLASS_MAPPINGS = {}
-NODE_DISPLAY_NAME_MAPPINGS = {}
-
-# 获取当前目录下所有的 .py 文件
-current_dir = os.path.dirname(os.path.abspath(__file__))
-py_files = glob.glob(os.path.join(current_dir, "*.py"))
-
-# 直接注册所有节点
-for file_path in py_files:
-    # 跳过 __init__.py
-    if "__init__.py" in file_path:
-        continue
-        
-    try:
-        # 获取模块名（不含.py）
-        module_name = os.path.basename(file_path)[:-3]
-        # 使用相对导入
-        module = importlib.import_module(f".{module_name}", package=__package__)
-        
-        # 如果模块有节点映射，则更新
-        if hasattr(module, 'NODE_CLASS_MAPPINGS'):
-            NODE_CLASS_MAPPINGS.update(module.NODE_CLASS_MAPPINGS)
-        if hasattr(module, 'NODE_DISPLAY_NAME_MAPPINGS'):
-            NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS)
-            
-        logger.info(f"Imported {module_name} successfully")
-    except ImportError as e:
-        logger.error(f"Error importing {module_name}: {str(e)}")
-    except Exception as e:
-        logger.error(f"Error processing {module_name}: {str(e)}")
-
-# 如果允许测试节点，导入测试节点
-allow_test_nodes = True
-if allow_test_nodes:
-    try:
-        from .excluded.experimental_nodes import *
-        # 更新映射
-        if 'NODE_CLASS_MAPPINGS' in locals():
-            NODE_CLASS_MAPPINGS.update(locals().get('NODE_CLASS_MAPPINGS', {}))
-        if 'NODE_DISPLAY_NAME_MAPPINGS' in locals():
-            NODE_DISPLAY_NAME_MAPPINGS.update(locals().get('NODE_DISPLAY_NAME_MAPPINGS', {}))
-    except ModuleNotFoundError:
-        pass
-
-logger.debug(f"Registered nodes: {list(NODE_CLASS_MAPPINGS.keys())}")
-
-WEB_DIRECTORY = "./web"
-__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS'] 

custom_nodes/ComfyUI-Addoor/nodes/imagecreatemask.py

@@ -1,109 +0,0 @@
-from PIL import Image
-import numpy as np
-import torch
-import torchvision.transforms.functional as TF
-
-def tensor2pil(image):
-    return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
-
-def pil2tensor(image):
-    return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
-
-def tensor2mask(t: torch.Tensor) -> torch.Tensor:
-    size = t.size()
-    if (len(size) < 4):
-        return t
-    if size[3] == 1:
-        return t[:,:,:,0]
-    elif size[3] == 4:
-        # Use alpha if available
-        if torch.min(t[:, :, :, 3]).item() != 1.:
-            return t[:,:,:,3]
-    # Convert RGB to grayscale
-    return TF.rgb_to_grayscale(t.permute(0,3,1,2), num_output_channels=1)[:,0,:,:]
-
-class image_concat_mask:
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image1": ("IMAGE",),
-            },
-            "optional": {
-                "image2": ("IMAGE",),
-                "mask": ("MASK",),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE", "MASK",)
-    RETURN_NAMES = ("image", "mask")
-    FUNCTION = "image_concat_mask"
-    CATEGORY = "🌻 Addoor/image"
-
-    def image_concat_mask(self, image1, image2=None, mask=None):
-        processed_images = []
-        masks = []
-        
-        for idx, img1 in enumerate(image1):
-            # Convert tensor to PIL
-            pil_image1 = tensor2pil(img1)
-            
-            # Get first image dimensions
-            width1, height1 = pil_image1.size
-            
-            if image2 is not None and idx < len(image2):
-                # Use provided second image
-                pil_image2 = tensor2pil(image2[idx])
-                width2, height2 = pil_image2.size
-                
-                # Resize image2 to match height of image1
-                new_width2 = int(width2 * (height1 / height2))
-                pil_image2 = pil_image2.resize((new_width2, height1), Image.Resampling.LANCZOS)
-            else:
-                # Create white image with same dimensions as image1
-                pil_image2 = Image.new('RGB', (width1, height1), 'white')
-                new_width2 = width1
-            
-            # Create new image to hold both images side by side
-            combined_image = Image.new('RGB', (width1 + new_width2, height1))
-            
-            # Paste both images
-            combined_image.paste(pil_image1, (0, 0))
-            combined_image.paste(pil_image2, (width1, 0))
-            
-            # Convert combined image to tensor
-            combined_tensor = pil2tensor(combined_image)
-            processed_images.append(combined_tensor)
-            
-            # Create mask (0 for left image area, 1 for right image area)
-            final_mask = torch.zeros((1, height1, width1 + new_width2))
-            final_mask[:, :, width1:] = 1.0  # Set right half to 1
-            
-            # If mask is provided, subtract it from the right side
-            if mask is not None and idx < len(mask):
-                input_mask = mask[idx]
-                # Resize input mask to match height1
-                pil_input_mask = tensor2pil(input_mask)
-                pil_input_mask = pil_input_mask.resize((new_width2, height1), Image.Resampling.LANCZOS)
-                resized_input_mask = pil2tensor(pil_input_mask)
-                
-                # Subtract input mask from the right side
-                final_mask[:, :, width1:] *= (1.0 - resized_input_mask)
-            
-            masks.append(final_mask)
-            
-        processed_images = torch.cat(processed_images, dim=0)
-        masks = torch.cat(masks, dim=0)
-        
-        return (processed_images, masks)
-
-NODE_CLASS_MAPPINGS = {
-    "image concat mask": image_concat_mask
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "image concat mask": "Image Concat with Mask"
-}

custom_nodes/ComfyUI-Addoor/nodes/multiline_string.py

@@ -1,42 +0,0 @@
-"""
-This node provides a multiline input field for a string.
-Input:
-    string
-Output:
-    STRING: A copy of 'string'.
-"""
-class MultilineString:
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "string": ("STRING", {
-                    "multiline": True,
-                    "default": "",
-                }),
-            },
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("STRING",)
-    FUNCTION = "get_string"
-    OUTPUT_NODE = True
-    CATEGORY = "🌻 Addoor/text"
-
-    def get_string(self, string):
-        return (string,)
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "YANC.MultilineString": MultilineString,
-}
-
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "YANC.MultilineString": "Multiline String",
-}

custom_nodes/ComfyUI-Addoor/rp/RunningHubFileSaver.py

@@ -1,183 +0,0 @@
-import os
-import requests
-import json
-import numpy as np
-from PIL import Image
-from PIL.PngImagePlugin import PngInfo
-import subprocess
-import mimetypes
-import torch
-import logging
-import io
-import re
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-class RunningHubFileSaverNode:
-    def __init__(self):
-        self.compression = 4
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "file_urls": ("FILEURL_LIST",),
-                "directory": ("STRING", {"default": "outputs"}),
-                "filename_prefix": ("STRING", {"default": "RH_Output"}),
-                "filename_delimiter": ("STRING", {"default": "_"}),
-                "filename_number_padding": ("INT", {"default": 4, "min": 0, "max": 9, "step": 1}),
-                "file_extension": (["auto", "png", "jpg", "jpeg", "txt", "json", "mp4"], {"default": "auto"}),
-                "open_output_directory": ("BOOLEAN", {"default": False}),
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "IMAGE", "STRING")
-    RETURN_NAMES = ("output_paths", "previews", "file_types")
-    FUNCTION = "save_files"
-    CATEGORY = "🌻 Addoor/RHAPI"
-
-    def save_files(self, file_urls, directory, filename_prefix, filename_delimiter, filename_number_padding, file_extension, open_output_directory):
-        output_paths = []
-        previews = []
-        file_types = []
-        
-        try:
-            if not os.path.exists(directory):
-                os.makedirs(directory)
-                
-            for url in file_urls:
-                if not url:
-                    continue
-                    
-                result = self.save_single_file(
-                    url, 
-                    directory, 
-                    filename_prefix, 
-                    filename_delimiter, 
-                    filename_number_padding, 
-                    file_extension
-                )
-                
-                if result:
-                    path, preview, ftype = result
-                    output_paths.append(path)
-                    previews.append(preview)
-                    file_types.append(ftype)
-            
-            if open_output_directory and output_paths:
-                self.open_directory(directory)
-            
-            if not output_paths:
-                return ("", torch.zeros((1, 1, 1, 3)), "")
-                
-            if len(previews) > 1:
-                combined_preview = torch.cat(previews, dim=0)
-            else:
-                combined_preview = previews[0] if previews else torch.zeros((1, 1, 1, 3))
-                
-            return (
-                json.dumps(output_paths), 
-                combined_preview,
-                json.dumps(file_types)
-            )
-            
-        except Exception as e:
-            logger.error(f"Error saving files: {str(e)}")
-            return ("", torch.zeros((1, 1, 1, 3)), "")
-
-    def save_single_file(self, file_url, directory, filename_prefix, filename_delimiter, filename_number_padding, file_extension):
-        try:
-            logger.info(f"Attempting to save file from URL: {file_url}")
-            
-            if not file_url:
-                raise ValueError("File URL is empty")
-
-            if not os.path.exists(directory):
-                logger.info(f"Creating directory: {directory}")
-                os.makedirs(directory)
-
-            response = requests.get(file_url, timeout=30)
-            response.raise_for_status()
-
-            content_type = response.headers.get('content-type')
-            logger.info(f"Content-Type: {content_type}")
-
-            if file_extension == "auto":
-                file_extension = mimetypes.guess_extension(content_type)
-                if file_extension:
-                    file_extension = file_extension[1:]  # Remove the leading dot
-                    if file_extension == "jpeg":
-                        file_extension = "jpg"
-                else:
-                    file_extension = "bin"  # Default to binary if can't guess
-                logger.info(f"Auto-detected file extension: {file_extension}")
-
-            file_path = os.path.join(directory, self.generate_filename(directory, filename_prefix, filename_delimiter, filename_number_padding, file_extension))
-            logger.info(f"Saving file to: {file_path}")
-
-            preview = None
-            if file_extension in ['png', 'jpg', 'jpeg']:
-                try:
-                    img_data = io.BytesIO(response.content)
-                    img = Image.open(img_data)  # Reopen the image after verifying
-                    metadata = PngInfo()
-                    metadata.add_text("source_url", file_url)
-                    img.save(file_path, pnginfo=metadata, compress_level=self.compression)
-                    preview = torch.from_numpy(np.array(img).astype(np.float32) / 255.0).unsqueeze(0)
-                except Exception as e:
-                    logger.error(f"Error processing image: {str(e)}")
-                    # If image processing fails, save as binary
-                    with open(file_path, 'wb') as f:
-                        f.write(response.content)
-                    preview = torch.zeros((1, 1, 1, 3))  # Placeholder for failed image
-            elif file_extension in ['txt', 'json']:
-                with open(file_path, 'w', encoding='utf-8') as f:
-                    f.write(response.text)
-                preview = torch.zeros((1, 1, 1, 3))  # Placeholder for non-image files
-            else:
-                with open(file_path, 'wb') as f:
-                    f.write(response.content)
-                preview = torch.zeros((1, 1, 1, 3))  # Placeholder for other file types
-
-            logger.info(f"File saved successfully to {file_path}")
-
-            return (file_path, preview, file_extension)
-
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error downloading file: {str(e)}")
-        except IOError as e:
-            logger.error(f"Error saving file: {str(e)}")
-        except Exception as e:
-            logger.error(f"Unexpected error: {str(e)}")
-
-        return ("", torch.zeros((1, 1, 1, 3)), "")
-
-    def generate_filename(self, directory, prefix, delimiter, number_padding, extension):
-        if number_padding == 0:
-            return f"{prefix}.{extension}"
-
-        pattern = f"{re.escape(prefix)}{re.escape(delimiter)}(\\d{{{number_padding}}})"
-        existing_files = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))]
-        existing_counters = [
-            int(re.search(pattern, filename).group(1))
-            for filename in existing_files
-            if re.match(pattern, filename)
-        ]
-
-        counter = max(existing_counters, default=0) + 1
-        return f"{prefix}{delimiter}{counter:0{number_padding}}.{extension}"
-
-    @staticmethod
-    def open_directory(path):
-        if os.name == 'nt':  # Windows
-            os.startfile(path)
-        elif os.name == 'posix':  # macOS and Linux
-            try:
-                subprocess.call(['open', path])  # macOS
-            except:
-                try:
-                    subprocess.call(['xdg-open', path])  # Linux
-                except:
-                    logger.error(f"Could not open directory: {path}")
-

custom_nodes/ComfyUI-Addoor/rp/RunningHubInit.py

@@ -1,22 +0,0 @@
-from . import validate_api_key
-
-class RunningHubInitNode:
-    """Node for initializing RunningHub API connection"""
-    
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "api_key": ("STRING", {"default": "", "multiline": False}),
-            }
-        }
-    
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "initialize"
-    CATEGORY = "🌻 Addoor/RHAPI"
-    
-    def initialize(self, api_key: str):
-        if not validate_api_key(api_key):
-            raise ValueError("Invalid API key format")
-        return (api_key,)
-

custom_nodes/ComfyUI-Addoor/rp/RunningHubNodeInfo.py

@@ -1,45 +0,0 @@
-class RunningHubNodeInfoNode:
-    """Node for creating and chaining nodeInfo entries"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "node_id": ("STRING", {"default": ""}),
-                "field_name": ("STRING", {"default": ""}),
-                "field_value": ("STRING", {"default": "", "multiline": True}),
-                "comment": ("STRING", {"default": ""}),
-            },
-            "optional": {
-                "previous_node_info": ("NODEINFOLIST",),  # 用于串联
-            }
-        }
-
-    RETURN_TYPES = ("NODEINFOLIST",)  # 改为返回列表类型
-    FUNCTION = "create_node_info"
-    CATEGORY = "🌻 Addoor/RHAPI"
-
-    def create_node_info(self, node_id: str, field_name: str, field_value: str, comment: str, previous_node_info=None):
-        # 创建当前节点信息
-        current_node_info = {
-            "nodeId": node_id,
-            "fieldName": field_name,
-            "fieldValue": field_value,
-            "comment": comment
-        }
-        
-        # 初始化节点信息列表
-        node_info_list = []
-        
-        # 如果有前置节点信息，添加到列表
-        if previous_node_info is not None:
-            if isinstance(previous_node_info, list):
-                node_info_list.extend(previous_node_info)
-            else:
-                node_info_list.append(previous_node_info)
-        
-        # 添加当前节点信息
-        node_info_list.append(current_node_info)
-        
-        return (node_info_list,)
-

custom_nodes/ComfyUI-Addoor/rp/RunningHubWorkflowExecutor.py

@@ -1,151 +0,0 @@
-import requests
-import json
-import time
-import logging
-from . import validate_api_key, BASE_URL
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class RunningHubWorkflowExecutorNode:
-    """Node for executing RunningHub workflows and monitoring task status"""
-    
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "api_key": ("STRING", {"default": ""}),
-                "workflow_id": ("STRING", {"default": ""}),
-                "node_info_list": ("NODEINFOLIST",),
-                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
-                "max_attempts": ("INT", {"default": 60, "min": 1, "max": 1000}),
-                "interval_seconds": ("FLOAT", {"default": 5.0, "min": 1.0, "max": 60.0}),
-            }
-        }
-    
-    RETURN_TYPES = ("FILEURL_LIST", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING")
-    RETURN_NAMES = ("file_urls", "task_id", "msg", "promptTips", "taskStatus", "fileType", "code", "json")
-    FUNCTION = "execute_workflow_and_monitor"
-    CATEGORY = "🌻 Addoor/RHAPI"
-    
-    def execute_workflow_and_monitor(self, api_key: str, workflow_id: str, node_info_list: list, seed: int, max_attempts: int, interval_seconds: float):
-        if not validate_api_key(api_key):
-            raise ValueError("Invalid API key")
-            
-        # 确保 node_info_list 是列表类型
-        if not isinstance(node_info_list, list):
-            node_info_list = [node_info_list]
-        
-        # 移除可能的重复项
-        unique_node_info = {
-            (info.get('nodeId'), info.get('fieldName')): info 
-            for info in node_info_list
-        }.values()
-        
-        workflow_data = {
-            "workflowId": int(workflow_id),
-            "apiKey": api_key,
-            "nodeInfoList": list(unique_node_info),
-            "seed": seed
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": "Apifox/1.0.0 (https://apifox.com)",
-            "Accept": "*/*",
-            "Host": "www.runninghub.cn",
-            "Connection": "keep-alive"
-        }
-        
-        workflow_endpoint = f"{BASE_URL}/task/openapi/create"
-        
-        try:
-            logger.info(f"Executing workflow with ID: {workflow_id}")
-            workflow_response = requests.post(
-                workflow_endpoint,
-                headers=headers,
-                json=workflow_data
-            )
-            workflow_response.raise_for_status()
-            workflow_result = workflow_response.json()
-            
-            if not workflow_result or 'data' not in workflow_result:
-                raise ValueError("Invalid response from workflow execution")
-            
-            task_id = workflow_result.get('data', {}).get('taskId')
-            if not task_id:
-                raise ValueError("No task ID returned from workflow execution")
-            
-            logger.info(f"Workflow executed. Task ID: {task_id}")
-            
-            # Monitor task status
-            task_data = {
-                "taskId": task_id,
-                "apiKey": api_key
-            }
-            
-            task_endpoint = f"{BASE_URL}/task/openapi/outputs"
-            
-            for attempt in range(max_attempts):
-                try:
-                    logger.info(f"Checking task status. Attempt {attempt + 1}/{max_attempts}")
-                    task_response = requests.post(
-                        task_endpoint,
-                        headers=headers,
-                        json=task_data
-                    )
-                    task_response.raise_for_status()
-                    task_result = task_response.json()
-                    
-                    if not task_result or 'data' not in task_result or not task_result['data']:
-                        logger.warning("Invalid or empty response from task status check")
-                        time.sleep(interval_seconds)
-                        continue
-                    
-                    task_status = task_result['data'][0].get('taskStatus', '')
-                    
-                    if task_status in ['SUCCEDD', 'FAILED']:
-                        logger.info(f"Task completed with status: {task_status}")
-                        break
-                    elif task_status in ['QUEUED', 'RUNNING']:
-                        logger.info(f"Task status: {task_status}. Waiting...")
-                        time.sleep(interval_seconds)
-                    else:
-                        logger.warning(f"Unknown task status: {task_status}")
-                        break
-                
-                except requests.exceptions.RequestException as e:
-                    logger.error(f"Error checking task status: {str(e)}")
-                    time.sleep(interval_seconds)
-            
-            # Prepare return values
-            msg = workflow_result.get('msg', '')
-            prompt_tips = json.dumps(workflow_result.get('data', {}).get('promptTips', ''))
-            
-            # 处理多个文件URL
-            file_urls = []
-            if task_result and 'data' in task_result and task_result['data']:
-                for item in task_result['data']:
-                    if 'fileUrl' in item:
-                        file_urls.append(item['fileUrl'])
-            
-            # 如果没有文件URL，添加空字符串
-            if not file_urls:
-                file_urls = [""]
-                
-            file_type = task_result['data'][0].get('fileType', '') if task_result and 'data' in task_result and task_result['data'] else ''
-            code = str(task_result.get('code', '')) if task_result else ''
-            
-            return (file_urls, task_id, msg, prompt_tips, task_status, file_type, code, json.dumps(task_result))
-        
-        except requests.exceptions.RequestException as e:
-            logger.error(f"API request failed: {str(e)}")
-            return ([""], "", f"Error: {str(e)}", "{}", "ERROR", "", "error", "")
-        except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse JSON response: {str(e)}")
-            return ([""], "", f"Error: Invalid JSON response", "{}", "ERROR", "", "error", "")
-        except Exception as e:
-            logger.error(f"Unexpected error: {str(e)}")
-            return ([""], "", f"Error: {str(e)}", "{}", "ERROR", "", "error", "")
-

custom_nodes/ComfyUI-Addoor/rp/config.ini

@@ -1,6 +0,0 @@
-; 密匙请联系微信：8617774（备注密匙）免费开通
-
-[License]
-COMFYUI_RHAPI_LICENSE_KEY = 1_Is-dRDrw1lbNVdN4vc2k7x4Qkg8hs2
-COMFYUI_RHAPI_USER_ID = user123
-COMFYUI_RHAPI_PHONE = 1234567890

custom_nodes/ComfyUI-Copilot/backend/agent_factory.py

@@ -1,98 +0,0 @@
-'''
-Author: ai-business-hql qingli.hql@alibaba-inc.com
-Date: 2025-07-31 19:38:08
-LastEditors: ai-business-hql ai.bussiness.hql@gmail.com
-LastEditTime: 2025-11-20 17:51:33
-FilePath: /comfyui_copilot/backend/agent_factory.py
-Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
-'''
-
-try:
-    from agents import Agent, OpenAIChatCompletionsModel, ModelSettings, Runner, set_trace_processors, set_tracing_disabled, set_default_openai_api
-    if not hasattr(__import__('agents'), 'Agent'):
-        raise ImportError
-except Exception:
-    # Give actionable guidance without crashing obscurely
-    raise ImportError(
-        "Detected incorrect or missing 'agents' package. "
-        "Please uninstall legacy RL 'agents' (and tensorflow/gym if pulled transitively) and install openai-agents. "
-        "Commands:\n"
-        "  python -m pip uninstall -y agents gym tensorflow\n"
-        "  python -m pip install -U openai-agents\n\n"
-        "Alternatively, keep both by setting COMFYUI_COPILOT_PREFER_OPENAI_AGENTS=1 so this plugin prefers openai-agents."
-    )
-from dotenv import dotenv_values
-from .utils.globals import LLM_DEFAULT_BASE_URL, LMSTUDIO_DEFAULT_BASE_URL, get_comfyui_copilot_api_key, is_lmstudio_url
-from openai import AsyncOpenAI
-
-
-from agents._config import set_default_openai_api
-from agents.tracing import set_tracing_disabled
-import asyncio
-# from .utils.logger import log
-
-# def load_env_config():
-#     """Load environment variables from .env.llm file"""
-#     from dotenv import load_dotenv
-
-#     env_file_path = os.path.join(os.path.dirname(__file__), '.env.llm')
-#     if os.path.exists(env_file_path):
-#         load_dotenv(env_file_path)
-#         log.info(f"Loaded environment variables from {env_file_path}")
-#     else:
-#         log.warning(f"Warning: .env.llm not found at {env_file_path}")
-
-
-# # Load environment configuration
-# load_env_config()
-
-set_default_openai_api("chat_completions")
-set_tracing_disabled(False)
-
-
-def create_agent(**kwargs) -> Agent:
-    # 通过用户配置拿/环境变量
-    config = kwargs.pop("config") if "config" in kwargs else {}
-    # 避免将 None 写入 headers
-    session_id = (config or {}).get("session_id")
-    default_headers = {}
-    if session_id:
-        default_headers["X-Session-ID"] = session_id
-
-    # Determine base URL and API key
-    base_url = LLM_DEFAULT_BASE_URL
-    api_key = get_comfyui_copilot_api_key() or ""
-
-    if config:
-        if config.get("openai_base_url") and config.get("openai_base_url") != "":
-            base_url = config.get("openai_base_url")
-        if config.get("openai_api_key") and config.get("openai_api_key") != "":
-            api_key = config.get("openai_api_key")
-
-    # Check if this is LMStudio and adjust API key handling
-    is_lmstudio = is_lmstudio_url(base_url)
-    if is_lmstudio and not api_key:
-        # LMStudio typically doesn't require an API key, use a placeholder
-        api_key = "lmstudio-local"
-
-    client = AsyncOpenAI(
-        api_key=api_key,
-        base_url=base_url,
-        default_headers=default_headers,
-    )
-
-    # Determine model with proper precedence:
-    # 1) Explicit selection from config (model_select from frontend)
-    # 2) Explicit kwarg 'model' (call-site override)
-    model_from_config = (config or {}).get("model_select")
-    model_from_kwargs = kwargs.pop("model", None)
-
-    model_name = model_from_kwargs or model_from_config or "gemini-2.5-flash"
-    model = OpenAIChatCompletionsModel(model_name, openai_client=client)
-
-    # Safety: ensure no stray 'model' remains in kwargs to avoid duplicate kwarg errors
-    kwargs.pop("model", None)
-
-    if config.get("max_tokens"):
-        return Agent(model=model, model_settings=ModelSettings(max_tokens=config.get("max_tokens") or 8192), **kwargs)
-    return Agent(model=model, **kwargs)

custom_nodes/ComfyUI-Copilot/backend/controller/conversation_api.py

@@ -1,1083 +0,0 @@
-# Copyright (C) 2025 AIDC-AI
-# Licensed under the MIT License.
-
-import json
-import asyncio
-import time
-from typing import Optional, TypedDict, List, Union
-import threading
-from collections import defaultdict
-
-from sqlalchemy.orm import identity
-
-from ..utils.globals import set_language, apply_llm_env_defaults
-from ..utils.auth_utils import extract_and_store_api_key
-import server
-from aiohttp import web
-import base64
-
-# Import the MCP client function
-import os
-import shutil
-
-from ..service.debug_agent import debug_workflow_errors
-from ..dao.workflow_table import save_workflow_data, get_workflow_data_by_id, update_workflow_ui_by_id
-from ..service.mcp_client import comfyui_agent_invoke
-from ..utils.request_context import set_request_context, get_session_id
-from ..utils.logger import log
-from ..utils.modelscope_gateway import ModelScopeGateway
-import folder_paths
-
-
-def get_llm_config_from_headers(request):
-    """Extract LLM-related configuration from request headers."""
-    return {
-        "openai_api_key": request.headers.get('Openai-Api-Key'),
-        "openai_base_url": request.headers.get('Openai-Base-Url'),
-        # Workflow LLM settings (optional, used by tools/agents that need a different LLM)
-        "workflow_llm_api_key": request.headers.get('Workflow-LLM-Api-Key'),
-        "workflow_llm_base_url": request.headers.get('Workflow-LLM-Base-Url'),
-        "workflow_llm_model": request.headers.get('Workflow-LLM-Model'),
-    }
-
-
-# 全局下载进度存储
-download_progress = {}
-download_lock = threading.Lock()
-
-# 不再使用内存存储会话消息，改为从前端传递历史消息
-
-# 在文件开头添加
-STATIC_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "public")
-
-# Define types using TypedDict
-class Node(TypedDict):
-    name: str  # 节点名称
-    description: str  # 节点描述
-    image: str  # 节点图片url，可为空
-    github_url: str  # 节点github地址
-    from_index: int  # 节点在列表中的位置
-    to_index: int  # 节点在列表中的位置
-
-class NodeInfo(TypedDict):
-    existing_nodes: List[Node]  # 已安装的节点
-    missing_nodes: List[Node]  # 未安装的节点
-
-class Workflow(TypedDict, total=False):
-    id: Optional[int]  # 工作流id
-    name: Optional[str]  # 工作流名称
-    description: Optional[str]  # 工作流描述
-    image: Optional[str]  # 工作流图片
-    workflow: Optional[str]  # 工作流
-
-class ExtItem(TypedDict):
-    type: str  # 扩展类型
-    data: Union[dict, list]  # 扩展数据
-
-class ChatResponse(TypedDict):
-    session_id: str  # 会话id
-    text: Optional[str]  # 返回文本
-    finished: bool  # 是否结束
-    type: str  # 返回的类型
-    format: str  # 返回的格式
-    ext: Optional[List[ExtItem]]  # 扩展信息
-
-# 下载进度回调类
-class DownloadProgressCallback:
-    def __init__(self, id: str, filename: str, file_size: int, download_id: str):
-        self.id = id
-        self.filename = filename
-        self.file_size = file_size
-        self.download_id = download_id
-        self.progress = 0
-        self.status = "downloading"  # downloading, completed, failed
-        self.error_message = None
-        self.start_time = time.time()
-        
-        # 初始化进度记录
-        with download_lock:
-            download_progress[download_id] = {
-                "id": id,
-                "filename": filename,
-                "file_size": file_size,
-                "progress": 0,
-                "percentage": 0.0,
-                "status": "downloading",
-                "start_time": self.start_time,
-                "estimated_time": None,
-                "speed": 0.0,
-                "error_message": None
-            }
-
-    def update(self, size: int):
-        """更新下载进度"""
-        self.progress += size
-        current_time = time.time()
-        elapsed_time = current_time - self.start_time
-        
-        # 计算下载速度和预估时间
-        if elapsed_time > 0:
-            speed = self.progress / elapsed_time  # bytes per second
-            if speed > 0 and self.progress < self.file_size:
-                remaining_bytes = self.file_size - self.progress
-                estimated_time = remaining_bytes / speed
-            else:
-                estimated_time = None
-        else:
-            speed = 0.0
-            estimated_time = None
-        
-        percentage = (self.progress / self.file_size) * 100 if self.file_size > 0 else 0
-        
-        # 更新全局进度
-        with download_lock:
-            if self.download_id in download_progress:
-                # 直接更新字典的值，而不是调用update方法
-                progress_dict = download_progress[self.download_id]
-                progress_dict["progress"] = self.progress
-                progress_dict["percentage"] = round(percentage, 2)
-                progress_dict["speed"] = round(speed, 2)
-                progress_dict["estimated_time"] = round(estimated_time, 2) if estimated_time else None
-
-    def end(self, success: bool = True, error_message: str = None):
-        """下载结束回调"""
-        current_time = time.time()
-        total_time = current_time - self.start_time
-        
-        if success:
-            self.status = "completed"
-            # 验证下载完整性
-            assert self.progress == self.file_size, f"Download incomplete: {self.progress}/{self.file_size}"
-        else:
-            self.status = "failed"
-            self.error_message = error_message
-        
-        # 更新最终状态
-        with download_lock:
-            if self.download_id in download_progress:
-                # 直接更新字典的值，而不是调用update方法
-                progress_dict = download_progress[self.download_id]
-                progress_dict["status"] = self.status
-                progress_dict["progress"] = self.file_size if success else self.progress
-                if self.file_size > 0:
-                    progress_dict["percentage"] = 100.0 if success else (self.progress / self.file_size) * 100
-                else:
-                    progress_dict["percentage"] = 0.0
-                progress_dict["total_time"] = round(total_time, 2)
-                progress_dict["error_message"] = self.error_message
-
-    def fail(self, error_message: str):
-        """下载失败回调"""
-        self.end(success=False, error_message=error_message)
-
-# 生成唯一下载ID
-def generate_download_id() -> str:
-    import uuid
-    return str(uuid.uuid4())
-
-async def upload_to_oss(file_data: bytes, filename: str) -> str:
-    # TODO: Implement your OSS upload logic here
-    # For now, save locally and return a placeholder URL
-    
-    try:
-        # Create uploads directory if it doesn't exist
-        uploads_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'uploads')
-        os.makedirs(uploads_dir, exist_ok=True)
-        
-        # Generate unique filename to avoid conflicts
-        import uuid
-        unique_filename = f"{uuid.uuid4().hex}_{filename}"
-        file_path = os.path.join(uploads_dir, unique_filename)
-        
-        # Save file locally
-        with open(file_path, 'wb') as f:
-            f.write(file_data)
-        
-        # Return a local URL or base64 data URL for now
-        # In production, replace this with actual OSS URL
-        base64_data = base64.b64encode(file_data).decode('utf-8')
-        # Determine MIME type based on file extension
-        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
-            mime_type = f"image/{filename.split('.')[-1].lower()}"
-            if mime_type == "image/jpg":
-                mime_type = "image/jpeg"
-        else:
-            mime_type = "image/jpeg"  # Default
-            
-        return f"data:{mime_type};base64,{base64_data}"
-        
-    except Exception as e:
-        log.error(f"Error uploading file {filename}: {str(e)}")
-        # Return original base64 data if upload fails
-        base64_data = base64.b64encode(file_data).decode('utf-8')
-        return f"data:image/jpeg;base64,{base64_data}"
-
-# 关联用户消息和AI响应的checkpoint信息
-def processMessagesWithCheckpoints(messages):
-    # ... existing code ...
-    pass
-
-@server.PromptServer.instance.routes.post("/api/chat/invoke")
-async def invoke_chat(request):
-    log.info("Received invoke_chat request")
-    
-    # Extract and store API key from Authorization header
-    extract_and_store_api_key(request)
-    
-    req_json = await request.json()
-    log.info("Request JSON:", req_json)
-
-    response = web.StreamResponse(
-        status=200,
-        reason='OK',
-        headers={
-            'Content-Type': 'application/json',
-            'X-Content-Type-Options': 'nosniff'
-        }
-    )
-    await response.prepare(request)
-
-    session_id = req_json.get('session_id')
-    prompt = req_json.get('prompt')
-    images = req_json.get('images', [])
-    intent = req_json.get('intent')
-    ext = req_json.get('ext')
-    historical_messages = req_json.get('messages', [])
-    workflow_checkpoint_id = req_json.get('workflow_checkpoint_id')
-    
-    # 获取当前语言
-    language = request.headers.get('Accept-Language', 'en')
-    set_language(language)
-    
-    # 构建配置信息
-    config = {
-        "session_id": session_id,
-        "workflow_checkpoint_id": workflow_checkpoint_id,
-        **get_llm_config_from_headers(request),
-        "model_select": next((x['data'][0] for x in ext if x['type'] == 'model_select' and x.get('data')), None)
-    }
-    # Apply .env-based defaults for LLM-related fields (config > .env > code defaults)
-    config = apply_llm_env_defaults(config)
-    
-    # 设置请求上下文 - 这里建立context隔离
-    set_request_context(session_id, workflow_checkpoint_id, config)
-
-    # 图片处理已移至前端，图片信息现在包含在历史消息的OpenAI格式中
-    # 保留空的处理逻辑以向后兼容，但实际不再使用
-    processed_images = []
-    if images and len(images) > 0:
-        log.info(f"Note: Received {len(images)} images in legacy format, but using OpenAI message format instead")
-
-    # 历史消息已经从前端传递过来，格式为OpenAI格式，直接使用
-    log.info(f"-- Received {len(historical_messages)} historical messages")
-    
-    # Log workflow checkpoint ID if provided (workflow is now pre-saved before invoke)
-    if workflow_checkpoint_id:
-        log.info(f"Using workflow checkpoint ID: {workflow_checkpoint_id} for session {session_id}")
-    else:
-        log.info(f"No workflow checkpoint ID provided for session {session_id}")
-
-    # 历史消息已经从前端传递过来，包含了正确格式的OpenAI消息（包括图片）
-    # 直接使用前端传递的历史消息，无需重新构建当前消息
-    openai_messages = historical_messages
-    
-    # 不再需要创建用户消息存储到后端，前端负责消息存储
-
-    try:
-        # Call the MCP client to get streaming response with historical messages and image support
-        # Pass OpenAI-formatted messages and processed images to comfyui_agent_invoke
-        accumulated_text = ""
-        ext_data = None
-        finished = True  # Default to True
-        has_sent_response = False
-        previous_text_length = 0
-        
-        log.info(f"config: {config}")
-        
-        # Pass messages in OpenAI format (images are now included in messages)
-        # Config is now available through request context
-        async for result in comfyui_agent_invoke(openai_messages, None):
-            # The MCP client now returns tuples (text, ext_with_finished) where ext_with_finished includes finished status
-            if isinstance(result, tuple) and len(result) == 2:
-                text, ext_with_finished = result
-                if text:
-                    accumulated_text = text  # text from MCP is already accumulated
-                    
-                if ext_with_finished:
-                    # Extract ext data and finished status from the structured response
-                    ext_data = ext_with_finished.get("data")
-                    finished = ext_with_finished.get("finished", True)
-                    log.info(f"-- Received ext data: {ext_data}, finished: {finished}")
-            else:
-                # Handle single text chunk (backward compatibility)
-                text_chunk = result
-                if text_chunk:
-                    accumulated_text += text_chunk
-                    log.info(f"-- Received text chunk: '{text_chunk}', total length: {len(accumulated_text)}")
-            
-            # Send streaming response if we have new text content
-            # Only send intermediate responses during streaming (not the final one)
-            if accumulated_text and len(accumulated_text) > previous_text_length:
-                chat_response = ChatResponse(
-                    session_id=session_id,
-                    text=accumulated_text,
-                    finished=False,  # Always false during streaming
-                    type="message",
-                    format="markdown",
-                    ext=None  # ext is only sent in final response
-                )
-                
-                await response.write(json.dumps(chat_response).encode() + b"\n")
-                previous_text_length = len(accumulated_text)
-                await asyncio.sleep(0.01)  # Small delay for streaming effect
-
-        # Send final response with proper finished logic from MCP client
-        log.info(f"-- Sending final response: {len(accumulated_text)} chars, ext: {bool(ext_data)}, finished: {finished}")
-        
-        final_response = ChatResponse(
-            session_id=session_id,
-            text=accumulated_text,
-            finished=finished,  # Use finished status from MCP client
-            type="message",
-            format="markdown",
-            ext=ext_data
-        )
-        
-        await response.write(json.dumps(final_response).encode() + b"\n")
-
-        # AI响应不再存储到后端，前端负责消息存储
-
-    except Exception as e:
-        log.error(f"Error in invoke_chat: {str(e)}")
-        error_response = ChatResponse(
-            session_id=session_id,
-            text=f"I apologize, but an error occurred: {str(e)}",
-            finished=True,  # Always finish on error
-            type="message",
-            format="text",
-            ext=None
-        )
-        await response.write(json.dumps(error_response).encode() + b"\n")
-
-    await response.write_eof()
-    return response
-
-
-@server.PromptServer.instance.routes.post("/api/save-workflow-checkpoint")
-async def save_workflow_checkpoint(request):
-    """
-    Save workflow checkpoint for restore functionality
-    """
-    log.info("Received save-workflow-checkpoint request")
-    req_json = await request.json()
-    
-    try:
-        session_id = req_json.get('session_id')
-        workflow_api = req_json.get('workflow_api')  # API format workflow
-        workflow_ui = req_json.get('workflow_ui')    # UI format workflow  
-        checkpoint_type = req_json.get('checkpoint_type', 'debug_start')  # debug_start, debug_complete, user_message_checkpoint
-        message_id = req_json.get('message_id')      # User message ID for linking (optional)
-        
-        if not session_id or not workflow_api:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameters: session_id and workflow_api"
-            })
-        
-        # Save workflow with checkpoint type in attributes
-        attributes = {
-            "checkpoint_type": checkpoint_type,
-            "timestamp": time.time()
-        }
-        
-        # Set description and additional attributes based on checkpoint type
-        if checkpoint_type == "user_message_checkpoint" and message_id:
-            attributes.update({
-                "description": f"Workflow checkpoint before user message {message_id}",
-                "message_id": message_id,
-                "source": "user_message_pre_invoke"
-            })
-        else:
-            attributes["description"] = f"Workflow checkpoint: {checkpoint_type}"
-        
-        version_id = save_workflow_data(
-            session_id=session_id,
-            workflow_data=workflow_api,
-            workflow_data_ui=workflow_ui,
-            attributes=attributes
-        )
-        
-        log.info(f"Workflow checkpoint saved with version ID: {version_id}")
-        
-        # Return response format based on checkpoint type
-        response_data = {
-            "version_id": version_id,
-            "checkpoint_type": checkpoint_type
-        }
-        
-        if checkpoint_type == "user_message_checkpoint" and message_id:
-            response_data.update({
-                "checkpoint_id": version_id,  # Add checkpoint_id alias for user message checkpoints
-                "message_id": message_id
-            })
-        
-        return web.json_response({
-            "success": True,
-            "data": response_data,
-            "message": f"Workflow checkpoint saved successfully"
-        })
-        
-    except Exception as e:
-        log.error(f"Error saving workflow checkpoint: {str(e)}")
-        return web.json_response({
-            "success": False,
-            "message": f"Failed to save workflow checkpoint: {str(e)}"
-        })
-
-
-
-@server.PromptServer.instance.routes.get("/api/restore-workflow-checkpoint")
-async def restore_workflow_checkpoint(request):
-    """
-    Restore workflow checkpoint by version ID
-    """
-    log.info("Received restore-workflow-checkpoint request")
-    
-    try:
-        version_id = request.query.get('version_id')
-        
-        if not version_id:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameter: version_id"
-            })
-        
-        try:
-            version_id = int(version_id)
-        except ValueError:
-            return web.json_response({
-                "success": False,
-                "message": "Invalid version_id format"
-            })
-        
-        # Get workflow data by version ID
-        workflow_version = get_workflow_data_by_id(version_id)
-        
-        if not workflow_version:
-            return web.json_response({
-                "success": False,
-                "message": f"Workflow version {version_id} not found"
-            })
-        
-        log.info(f"Restored workflow checkpoint version ID: {version_id}")
-        
-        return web.json_response({
-            "success": True,
-            "data": {
-                "version_id": version_id,
-                "workflow_data": workflow_version.get('workflow_data'),
-                "workflow_data_ui": workflow_version.get('workflow_data_ui'),
-                "attributes": workflow_version.get('attributes'),
-                "created_at": workflow_version.get('created_at')
-            },
-            "message": f"Workflow checkpoint restored successfully"
-        })
-        
-    except Exception as e:
-        log.error(f"Error restoring workflow checkpoint: {str(e)}")
-        return web.json_response({
-            "success": False,
-            "message": f"Failed to restore workflow checkpoint: {str(e)}"
-        })
-
-
-@server.PromptServer.instance.routes.post("/api/debug-agent")
-async def invoke_debug(request):
-    """
-    Debug agent endpoint for analyzing ComfyUI workflow errors
-    """
-    log.info("Received debug-agent request")
-    
-    # Extract and store API key from Authorization header
-    extract_and_store_api_key(request)
-    
-    req_json = await request.json()
-    
-    response = web.StreamResponse(
-        status=200,
-        reason='OK',
-        headers={
-            'Content-Type': 'application/json',
-            'X-Content-Type-Options': 'nosniff'
-        }
-    )
-    await response.prepare(request)
-
-    session_id = req_json.get('session_id')
-    workflow_data = req_json.get('workflow_data')
-    
-    # Get configuration from headers (OpenAI settings)
-    config = {
-        "session_id": session_id,
-        "model": "gemini-2.5-flash",  # Default model for debug agents
-        **get_llm_config_from_headers(request),
-    }
-    # Apply .env-based defaults for LLM-related fields (config > .env > code defaults)
-    config = apply_llm_env_defaults(config)
-
-    # 获取当前语言
-    language = request.headers.get('Accept-Language', 'en')
-    set_language(language)
-    
-    # 设置请求上下文 - 为debug请求建立context隔离
-    set_request_context(session_id, None, config)
-    
-    log.info(f"Debug agent config: {config}")
-    log.info(f"Session ID: {session_id}")
-    log.info(f"Workflow nodes: {list(workflow_data.keys()) if workflow_data else 'None'}")
-
-    try:
-        # Call the debug agent with streaming response
-        accumulated_text = ""
-        final_ext_data = None
-        finished = False
-        
-        async for result in debug_workflow_errors(workflow_data):
-            # Stream the response
-            if isinstance(result, tuple) and len(result) == 2:
-                text, ext = result
-                if text:
-                    accumulated_text = text  # text is already accumulated from debug agent
-                
-                # Handle new ext format from debug_agent matching mcp-client
-                if ext:
-                    if isinstance(ext, dict) and "data" in ext and "finished" in ext:
-                        # New format: {"data": ext, "finished": finished}
-                        final_ext_data = ext["data"]
-                        finished = ext["finished"]
-                        
-                        # 检查是否包含需要实时发送的workflow_update或param_update
-                        has_realtime_ext = False
-                        if final_ext_data:
-                            for ext_item in final_ext_data:
-                                if ext_item.get("type") in ["workflow_update", "param_update"]:
-                                    has_realtime_ext = True
-                                    break
-                        
-                        # 如果包含实时ext数据或者已完成，则发送响应
-                        if has_realtime_ext or finished:
-                            chat_response = ChatResponse(
-                                session_id=session_id,
-                                text=accumulated_text,
-                                finished=finished,
-                                type="message",
-                                format="markdown",
-                                ext=final_ext_data  # 发送ext数据
-                            )
-                            await response.write(json.dumps(chat_response).encode() + b"\n")
-                        elif not finished:
-                            # 只有文本更新，不发送ext数据
-                            chat_response = ChatResponse(
-                                session_id=session_id,
-                                text=accumulated_text,
-                                finished=False,
-                                type="message",
-                                format="markdown",
-                                ext=None
-                            )
-                            await response.write(json.dumps(chat_response).encode() + b"\n")
-                    else:
-                        # Legacy format: direct ext data (for backward compatibility)
-                        final_ext_data = ext
-                        finished = False
-                        
-                        # Create streaming response
-                        chat_response = ChatResponse(
-                            session_id=session_id,
-                            text=accumulated_text,
-                            finished=False,
-                            type="message",
-                            format="markdown",
-                            ext=ext
-                        )
-                        await response.write(json.dumps(chat_response).encode() + b"\n")
-                else:
-                    # No ext data, just text streaming
-                    chat_response = ChatResponse(
-                        session_id=session_id,
-                        text=accumulated_text,
-                        finished=False,
-                        type="message",
-                        format="markdown",
-                        ext=None
-                    )
-                    await response.write(json.dumps(chat_response).encode() + b"\n")
-                
-                await asyncio.sleep(0.01)  # Small delay for streaming effect
-
-        # Send final response
-        final_response = ChatResponse(
-            session_id=session_id,
-            text=accumulated_text,
-            finished=True,
-            type="message",
-            format="markdown",
-            ext=final_ext_data if final_ext_data else [{"type": "debug_complete", "data": {"status": "completed"}}]
-        )
-        
-        # Save workflow checkpoint after debug completion if we have workflow_data
-        if workflow_data and accumulated_text:
-            try:
-                current_session_id = get_session_id()
-                checkpoint_id = save_workflow_data(
-                    session_id=current_session_id,
-                    workflow_data=workflow_data,
-                    workflow_data_ui=None,  # UI format not available in debug agent
-                    attributes={
-                        "checkpoint_type": "debug_complete",
-                        "description": "Workflow state after debug completion",
-                        "timestamp": time.time()
-                    }
-                )
-                
-                # Add checkpoint info to ext data
-                if final_response["ext"]:
-                    final_response["ext"].append({
-                        "type": "debug_checkpoint",
-                        "data": {
-                            "checkpoint_id": checkpoint_id,
-                            "checkpoint_type": "debug_complete"
-                        }
-                    })
-                else:
-                    final_response["ext"] = [{
-                        "type": "debug_checkpoint",
-                        "data": {
-                            "checkpoint_id": checkpoint_id,
-                            "checkpoint_type": "debug_complete"
-                        }
-                    }]
-                
-                log.info(f"Debug completion checkpoint saved with ID: {checkpoint_id}")
-            except Exception as checkpoint_error:
-                log.error(f"Failed to save debug completion checkpoint: {checkpoint_error}")
-        
-        await response.write(json.dumps(final_response).encode() + b"\n")
-        log.info("Debug agent processing complete")
-
-    except Exception as e:
-        log.error(f"Error in debug agent: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        
-        error_response = ChatResponse(
-            session_id=session_id,
-            text=f"❌ Debug agent error: {str(e)}",
-            finished=True,
-            type="message",
-            format="text",
-            ext=[{"type": "error", "data": {"error": str(e)}}]
-        )
-        await response.write(json.dumps(error_response).encode() + b"\n")
-
-    await response.write_eof()
-    return response
-
-
-@server.PromptServer.instance.routes.post("/api/update-workflow-ui")
-async def update_workflow_ui(request):
-    """
-    Update workflow_data_ui field for a specific checkpoint without affecting other fields
-    """
-    log.info("Received update-workflow-ui request")
-    req_json = await request.json()
-    
-    try:
-        checkpoint_id = req_json.get('checkpoint_id')
-        workflow_data_ui = req_json.get('workflow_data_ui')
-        
-        if not checkpoint_id or not workflow_data_ui:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameters: checkpoint_id and workflow_data_ui"
-            })
-        
-        try:
-            checkpoint_id = int(checkpoint_id)
-        except ValueError:
-            return web.json_response({
-                "success": False,
-                "message": "Invalid checkpoint_id format"
-            })
-        
-        # Update only the workflow_data_ui field
-        success = update_workflow_ui_by_id(checkpoint_id, workflow_data_ui)
-        
-        if success:
-            log.info(f"Successfully updated workflow_data_ui for checkpoint ID: {checkpoint_id}")
-            return web.json_response({
-                "success": True,
-                "message": f"Workflow UI data updated successfully for checkpoint {checkpoint_id}"
-            })
-        else:
-            return web.json_response({
-                "success": False,
-                "message": f"Checkpoint {checkpoint_id} not found"
-            })
-        
-    except Exception as e:
-        log.error(f"Error updating workflow UI data: {str(e)}")
-        return web.json_response({
-            "success": False,
-            "message": f"Failed to update workflow UI data: {str(e)}"
-        })
-
-@server.PromptServer.instance.routes.post("/api/download-model")
-async def download_model(request):
-    """
-    Download model from ModelScope using SDK
-    """
-    log.info("Received download-model request")
-    req_json = await request.json()
-    
-    try:
-        id = req_json.get('id')
-        model_id = req_json.get('model_id')
-        model_type = req_json.get('model_type')
-        dest_dir = req_json.get('dest_dir')
-        
-        # 验证必需参数
-        if not id:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameter: id"
-            })
-
-        if not model_id:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameter: model_id"
-            })
-            
-        if not model_type:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameter: model_type"
-            })
-        
-        log.info(f"Downloading model: {model_id} (type: {model_type})")
-        
-        # 生成下载ID
-        download_id = generate_download_id()
-        
-        # 计算目标目录：优先使用传入的dest_dir，否则使用ComfyUI的models目录下对应类型
-        resolved_dest_dir = None
-        if dest_dir:
-            resolved_dest_dir = os.path.abspath(os.path.expanduser(f"models/{dest_dir}"))
-        else:
-            try:
-                model_type_paths = folder_paths.get_folder_paths(model_type)
-                resolved_dest_dir = model_type_paths[0] if model_type_paths else os.path.join(folder_paths.models_dir, model_type)
-            except Exception:
-                resolved_dest_dir = os.path.join(folder_paths.models_dir, model_type)
-
-        # 创建进度回调
-        progress_callback = DownloadProgressCallback(
-            id=id,
-            filename=f"{model_id}.{model_type}",
-            file_size=0,  # 实际大小会在下载过程中获取
-            download_id=download_id
-        )
-
-        # 启动下载任务（异步执行）
-        async def download_task():
-            try:
-                # 调用下载方法 - 使用snapshot_download
-                from modelscope import snapshot_download
-                
-                # 创建进度回调包装器 - 实现ModelScope期望的接口
-                class ProgressWrapper:
-                    """Factory that returns a per-file progress object with update/end."""
-                    def __init__(self, download_id: str):
-                        self.download_id = download_id
-
-                    def __call__(self, file_name: str, file_size: int):
-                        # Create a per-file progress tracker expected by ModelScope
-                        download_id = self.download_id
-
-                        class _PerFileProgress:
-                            def __init__(self, fname: str, fsize: int):
-                                self.file_name = fname
-                                self.file_size = max(int(fsize or 0), 0)
-                                self.progress = 0
-                                self.last_update_time = time.time()
-                                self.last_downloaded = 0
-                                with download_lock:
-                                    if download_id in download_progress:
-                                        # If unknown size, keep 0 to avoid div-by-zero
-                                        download_progress[download_id]["file_size"] = self.file_size
-
-                            def update(self, size: int):
-                                try:
-                                    self.progress += int(size or 0)
-                                    now = time.time()
-                                    # Update global progress
-                                    with download_lock:
-                                        if download_id in download_progress:
-                                            dp = download_progress[download_id]
-                                            dp["progress"] = self.progress
-                                            if self.file_size > 0:
-                                                dp["percentage"] = round(self.progress * 100.0 / self.file_size, 2)
-                                            # speed
-                                            elapsed = max(now - self.last_update_time, 1e-6)
-                                            speed = (self.progress - self.last_downloaded) / elapsed
-                                            dp["speed"] = round(speed, 2)
-                                    self.last_update_time = now
-                                    self.last_downloaded = self.progress
-                                except Exception as e:
-                                    log.error(f"Error in progress update: {e}")
-
-                            def end(self):
-                                # Called by modelscope when a file finishes
-                                with download_lock:
-                                    if download_id in download_progress:
-                                        dp = download_progress[download_id]
-                                        if self.file_size > 0:
-                                            dp["progress"] = self.file_size
-                                            dp["percentage"] = 100.0
-                        
-                        return _PerFileProgress(file_name, file_size)
- 
-                progress_wrapper = ProgressWrapper(download_id)
-                
-                # 添加调试日志
-                log.info(f"Starting download with progress wrapper: {download_id}")
-                
-                # 在线程中执行阻塞的下载，避免阻塞事件循环
-                from functools import partial
-                local_dir = await asyncio.to_thread(
-                    partial(
-                        snapshot_download,
-                        model_id=model_id,
-                        cache_dir=resolved_dest_dir,
-                        progress_callbacks=[progress_wrapper]
-                    )
-                )
-                
-                # 下载完成
-                progress_callback.end(success=True)
-                log.info(f"Model downloaded successfully to: {local_dir}")
-
-                # 下载后遍历目录，将所有重要权重/资源文件移动到最外层（与目录同级，即 resolved_dest_dir）
-                try:
-                    moved_count = 0
-                    allowed_exts = {
-                        ".safetensors", ".ckpt", ".pt", ".pth", ".bin"
-                        # ".msgpack", ".json", ".yaml", ".yml", ".toml", ".png", ".onnx"
-                    }
-                    for root, dirs, files in os.walk(local_dir):
-                        for name in files:
-                            ext = os.path.splitext(name)[1].lower()
-                            if ext in allowed_exts:
-                                src_path = os.path.join(root, name)
-                                target_dir = resolved_dest_dir
-                                os.makedirs(target_dir, exist_ok=True)
-                                target_path = os.path.join(target_dir, name)
-                                # 如果已经在目标目录则跳过
-                                if os.path.abspath(os.path.dirname(src_path)) == os.path.abspath(target_dir):
-                                    continue
-                                # 处理重名情况：自动追加 _1, _2 ...
-                                if os.path.exists(target_path):
-                                    base, ext_real = os.path.splitext(name)
-                                    idx = 1
-                                    while True:
-                                        candidate = f"{base}_{idx}{ext_real}"
-                                        candidate_path = os.path.join(target_dir, candidate)
-                                        if not os.path.exists(candidate_path):
-                                            target_path = candidate_path
-                                            break
-                                        idx += 1
-                                shutil.move(src_path, target_path)
-                                moved_count += 1
-                    log.info(f"Moved {moved_count} files with extensions {sorted(list(allowed_exts))} to: {resolved_dest_dir}")
-                except Exception as move_err:
-                    log.error(f"Post-download move failed: {move_err}")
-                
-            except Exception as e:
-                progress_callback.fail(str(e))
-                log.error(f"Download failed: {str(e)}")
-
-        # 启动异步下载任务
-        asyncio.create_task(download_task())
-        
-        return web.json_response({
-            "success": True,
-            "data": {
-                "download_id": download_id,
-                "id": id,
-                "model_id": model_id,
-                "model_type": model_type,
-                "dest_dir": resolved_dest_dir,
-                "status": "started"
-            },
-            "message": f"Download started for model '{model_id}'"
-        })
-        
-    except ImportError as e:
-        log.error(f"ModelScope SDK not installed: {str(e)}")
-        return web.json_response({
-            "success": False,
-            "message": "ModelScope SDK not installed. Please install with: pip install modelscope"
-        })
-        
-    except Exception as e:
-        log.error(f"Error starting download: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return web.json_response({
-            "success": False,
-            "message": f"Failed to start download: {str(e)}"
-        })
-
-@server.PromptServer.instance.routes.get("/api/download-progress/{download_id}")
-async def get_download_progress(request):
-    """
-    Get download progress by download ID
-    """
-    download_id = request.match_info.get('download_id')
-    
-    if not download_id:
-        return web.json_response({
-            "success": False,
-            "message": "Missing download_id parameter"
-        })
-    
-    with download_lock:
-        progress_info = download_progress.get(download_id)
-    
-    if not progress_info:
-        return web.json_response({
-            "success": False,
-            "message": f"Download ID {download_id} not found"
-        })
-    
-    return web.json_response({
-        "success": True,
-        "data": progress_info,
-        "message": "Download progress retrieved successfully"
-    })
-
-@server.PromptServer.instance.routes.get("/api/download-progress")
-async def list_downloads(request):
-    """
-    List all active downloads
-    """
-    with download_lock:
-        downloads = list(download_progress.keys())
-    
-    return web.json_response({
-        "success": True,
-        "data": {
-            "downloads": downloads,
-            "count": len(downloads)
-        },
-        "message": "Download list retrieved successfully"
-    })
-
-@server.PromptServer.instance.routes.delete("/api/download-progress/{download_id}")
-async def clear_download_progress(request):
-    """
-    Clear download progress record (for cleanup)
-    """
-    download_id = request.match_info.get('download_id')
-    
-    if not download_id:
-        return web.json_response({
-            "success": False,
-            "message": "Missing download_id parameter"
-        })
-    
-    with download_lock:
-        if download_id in download_progress:
-            del download_progress[download_id]
-            return web.json_response({
-                "success": True,
-                "message": f"Download progress {download_id} cleared successfully"
-            })
-        else:
-            return web.json_response({
-                "success": False,
-                "message": f"Download ID {download_id} not found"
-            })
-
-@server.PromptServer.instance.routes.get("/api/model-searchs")
-async def model_suggests(request):
-    """
-    Get model search list by keyword
-    """
-    log.info("Received model-search request")
-    try:
-        keyword = request.query.get('keyword')
-
-        if not keyword:
-            return web.json_response({
-                "success": False,
-                "message": "Missing required parameter: keyword"
-            })
-
-        # 创建ModelScope网关实例
-        gateway = ModelScopeGateway()
-
-        suggests = gateway.search(name=keyword)
-
-        list = suggests["data"] if suggests.get("data") else []
-
-        return web.json_response({
-            "success": True,
-            "data": {
-                "searchs": list,
-                "total": len(list)
-            },
-            "message": f"Get searchs successfully"
-        })
-        
-    except ImportError as e:
-        log.error(f"ModelScope SDK not installed: {str(e)}")
-        return web.json_response({
-            "success": False,
-            "message": "ModelScope SDK not installed. Please install with: pip install modelscope"
-        })  
-
-    except Exception as e:
-        log.error(f"Error get model searchs: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return web.json_response({
-            "success": False,
-            "message": f"Get model searchs failed: {str(e)}"
-        })
-        
-@server.PromptServer.instance.routes.get("/api/model-paths")
-async def model_paths(request):
-    """
-    Get model paths by type
-    """
-    log.info("Received model-paths request")
-    try:
-        model_paths = list(folder_paths.folder_names_and_paths.keys())
-        return web.json_response({
-            "success": True,
-            "data": {
-                "paths": model_paths,
-            },
-            "message": f"Get paths successfully"
-        })
-        
-    except Exception as e:
-        log.error(f"Error get model path: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return web.json_response({
-            "success": False,
-            "message": f"Get model failed: {str(e)}"
-        })

custom_nodes/ComfyUI-Copilot/backend/controller/expert_api.py

@@ -1,192 +0,0 @@
-from server import PromptServer
-from aiohttp import web
-from typing import Dict, Any
-import logging
-from ..dao.expert_table import (
-    create_rewrite_expert,
-    get_rewrite_expert,
-    list_rewrite_experts,
-    update_rewrite_expert_by_id,
-    delete_rewrite_expert_by_id
-)
-
-# 配置日志
-logger = logging.getLogger(__name__)
-
-def validate_expert_data(data: Dict[str, Any]) -> tuple[bool, str, Dict[str, Any]]:
-    """验证专家数据"""
-    if not data:
-        return False, "请求数据不能为空", {}
-    
-    # 验证必填字段
-    if 'name' not in data or not data['name']:
-        return False, "名称不能为空", {}
-    
-    # 验证字段类型和长度
-    if not isinstance(data['name'], str) or len(data['name']) > 255:
-        return False, "名称必须是字符串且长度不超过255个字符", {}
-    
-    # 验证可选字段
-    validated_data = {
-        'name': data['name'].strip(),
-        'description': data.get('description'),
-        'content': data.get('content')
-    }
-    
-    return True, "", validated_data
-
-@PromptServer.instance.routes.post("/api/expert/experts")
-async def create_expert(request):
-    """创建新的专家记录"""
-    try:
-        data = await request.json()
-        if not data:
-            return web.json_response({"success": False, "message": "请求数据格式错误", "data": None}, status=400)
-        
-        # 验证数据
-        is_valid, error_msg, validated_data = validate_expert_data(data)
-        if not is_valid:
-            return web.json_response({"success": False, "message": error_msg, "data": None}, status=400)
-        
-        # 创建专家记录
-        expert_id = create_rewrite_expert(
-            name=validated_data['name'],
-            description=validated_data['description'],
-            content=validated_data['content']
-        )
-        
-        logger.info(f"成功创建专家记录，ID: {expert_id}")
-        
-        return web.json_response({"success": True, "message": "创建成功", "data": {"id": expert_id}}, status=200)
-        
-    except Exception as e:
-        logger.error(f"创建专家记录失败: {str(e)}")
-        return web.json_response({"success": False, "message": f"创建失败: {str(e)}", "data": None}, status=500)
-
-@PromptServer.instance.routes.get("/api/expert/experts")
-async def get_experts(request):
-    """获取所有专家记录列表"""
-    try:
-        experts = list_rewrite_experts()
-        
-        logger.info(f"成功获取专家记录列表，共 {len(experts)} 条")
-        
-        return web.json_response({"success": True, "message": "获取列表成功", "data": {"total": len(experts), "experts": experts}}, status=200)
-        
-    except Exception as e:
-        logger.error(f"获取专家记录列表失败: {str(e)}")
-        return web.json_response({"success": False, "message": f"获取列表失败: {str(e)}", "data": None}, status=500)
-
-@PromptServer.instance.routes.get("/api/expert/experts/{expert_id}")
-async def get_expert_by_id(request):
-    """根据ID获取专家记录"""
-    try:
-        expert_id = int(request.match_info['expert_id'])
-        expert = get_rewrite_expert(expert_id)
-        
-        if not expert:
-            return web.json_response({"success": False, "message": "ID不存在", "data": None}, status=404)
-        
-        logger.info(f"成功获取专家记录，ID: {expert_id}")
-        
-        return web.json_response({"success": True, "message": "获取记录成功", "data": expert}, status=200)
-        
-    except Exception as e:
-        logger.error(f"获取专家记录失败，ID: {expert_id}, 错误: {str(e)}")
-        return web.json_response({"success": False, "message": f"获取记录失败: {str(e)}", "data": None}, status=500)
-
-@PromptServer.instance.routes.put("/api/expert/experts/{expert_id}")
-async def update_expert(request):
-    """更新专家记录"""
-    try:
-        expert_id = int(request.match_info['expert_id'])
-        data = await request.json()
-        if not data:
-            return web.json_response({"success": False, "message": "请求数据格式错误", "data": None}, status=400)
-        
-        # 验证数据
-        is_valid, error_msg, validated_data = validate_expert_data(data)
-        if not is_valid:
-            return web.json_response({"success": False, "message": error_msg, "data": None}, status=400)
-        
-        # 更新专家记录
-        success = update_rewrite_expert_by_id(
-            expert_id=expert_id,
-            name=validated_data.get('name'),
-            description=validated_data.get('description'),
-            content=validated_data.get('content')
-        )
-        
-        if not success:
-            return web.json_response({"success": False, "message": "ID不存在", "data": None}, status=404)
-        
-        logger.info(f"成功更新专家记录，ID: {expert_id}")
-        
-        return web.json_response({"success": True, "message": "更新成功", "data": {"id": expert_id}}, status=200)
-        
-    except Exception as e:
-        logger.error(f"更新专家记录失败，ID: {expert_id}, 错误: {str(e)}")
-        return web.json_response({"success": False, "message": f"更新失败: {str(e)}", "data": None}, status=500)
-
-@PromptServer.instance.routes.delete("/api/expert/experts/{expert_id}")
-async def delete_expert(request):
-    """删除专家记录"""
-    try:
-        expert_id = int(request.match_info['expert_id'])
-        success = delete_rewrite_expert_by_id(expert_id)
-        
-        if not success:
-            return web.json_response({"success": False, "message": "ID不存在", "data": None}, status=404)
-        
-        logger.info(f"成功删除专家记录，ID: {expert_id}")
-        
-        return web.json_response({"success": True, "message": "删除成功", "data": {"id": expert_id}}, status=200)
-        
-    except Exception as e:
-        logger.error(f"删除专家记录失败，ID: {expert_id}, 错误: {str(e)}")
-        return web.json_response({"success": False, "message": f"删除失败: {str(e)}", "data": None}, status=500)
-
-@PromptServer.instance.routes.patch("/api/expert/experts/{expert_id}")
-async def partial_update_expert(request):
-    """部分更新专家记录"""
-    try:
-        expert_id = int(request.match_info['expert_id'])
-        data = await request.json()
-        if not data:
-            return web.json_response({"success": False, "message": "请求数据格式错误", "data": None}, status=400)
-        
-        # 验证字段
-        update_data = {}
-        if 'name' in data:
-            if not isinstance(data['name'], str) or len(data['name']) > 255:
-                return web.json_response({"success": False, "message": "名称必须是字符串且长度不超过255个字符", "data": None}, status=400)
-            update_data['name'] = data['name'].strip()
-        
-        if 'description' in data:
-            update_data['description'] = data['description']
-        
-        if 'content' in data:
-            update_data['content'] = data['content']
-        
-        if not update_data:
-            return web.json_response({"success": False, "message": "没有提供要更新的字段", "data": None}, status=400)
-        
-        # 更新专家记录
-        success = update_rewrite_expert_by_id(
-            expert_id=expert_id,
-            **update_data
-        )
-        
-        if not success:
-            return web.json_response({"success": False, "message": "ID不存在", "data": None}, status=404)
-        
-        logger.info(f"成功部分更新专家记录，ID: {expert_id}")
-        
-        return web.json_response({"success": True, "message": "更新成功", "data": {"id": expert_id}}, status=200)
-        
-    except Exception as e:
-        logger.error(f"部分更新专家记录失败，ID: {expert_id}, 错误: {str(e)}")
-        return web.json_response({"success": False, "message": f"更新失败: {str(e)}", "data": None}, status=500)
-
-# 路由配置函数
-# 所有路由已通过装饰器自动注册到 ComfyUI 的 PromptServer

custom_nodes/ComfyUI-Copilot/backend/core.py

@@ -1,23 +0,0 @@
-import os
-
-from agents._config import set_default_openai_api
-from agents.tracing import set_tracing_disabled
-# from .utils.logger import log
-
-# def load_env_config():
-#     """Load environment variables from .env.llm file"""
-#     from dotenv import load_dotenv
-
-#     env_file_path = os.path.join(os.path.dirname(__file__), '.env.llm')
-#     if os.path.exists(env_file_path):
-#         load_dotenv(env_file_path)
-#         log.info(f"Loaded environment variables from {env_file_path}")
-#     else:
-#         log.warning(f"Warning: .env.llm not found at {env_file_path}")
-
-
-# # Load environment configuration
-# load_env_config()
-
-set_default_openai_api("chat_completions")
-set_tracing_disabled(True)

custom_nodes/ComfyUI-Copilot/backend/dao/workflow_table.py

@@ -1,183 +0,0 @@
-import os
-import json
-from typing import Dict, Any, Optional
-from sqlalchemy import create_engine, Column, Integer, String, DateTime, Text
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-from datetime import datetime
-
-# 创建数据库基类
-Base = declarative_base()
-
-# 定义workflow_version表模型
-class WorkflowVersion(Base):
-    __tablename__ = 'workflow_version'
-    
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    session_id = Column(String(255), nullable=False)
-    workflow_data = Column(Text, nullable=False)  # JSON字符串 api格式
-    workflow_data_ui = Column(Text, nullable=True)  # JSON字符串 ui格式
-    attributes = Column(Text, nullable=True)  # JSON字符串，存储额外属性
-    created_at = Column(DateTime, default=datetime.utcnow)
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'session_id': self.session_id,
-            'workflow_data': json.loads(self.workflow_data) if self.workflow_data else None,
-            'attributes': json.loads(self.attributes) if self.attributes else None,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-class DatabaseManager:
-    """数据库管理器"""
-    
-    def __init__(self, db_path: str = None):
-        if db_path is None:
-            # 默认数据库路径
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            db_dir = os.path.join(current_dir, '..', 'data')
-            os.makedirs(db_dir, exist_ok=True)
-            db_path = os.path.join(db_dir, 'workflow_debug.db')
-        
-        self.db_path = db_path
-        self.engine = create_engine(f'sqlite:///{db_path}', echo=False)
-        self.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
-        
-        # 创建表
-        Base.metadata.create_all(bind=self.engine)
-        
-    def get_session(self):
-        """获取数据库会话"""
-        return self.SessionLocal()
-    
-    def save_workflow_version(self, session_id: str, workflow_data: Dict[str, Any], workflow_data_ui: Dict[str, Any] = None, attributes: Optional[Dict[str, Any]] = None) -> int:
-        """保存工作流版本，返回新版本的ID"""
-        session = self.get_session()
-        try:
-            workflow_version = WorkflowVersion(
-                session_id=session_id,
-                workflow_data=json.dumps(workflow_data),
-                workflow_data_ui=json.dumps(workflow_data_ui) if workflow_data_ui else None,
-                attributes=json.dumps(attributes) if attributes else None
-            )
-            session.add(workflow_version)
-            session.commit()
-            session.refresh(workflow_version)
-            return workflow_version.id
-        except Exception as e:
-            session.rollback()
-            raise e
-        finally:
-            session.close()
-    
-    def get_current_workflow_data(self, session_id: str) -> Optional[Dict[str, Any]]:
-        """获取当前session的最新工作流数据（最大ID版本）"""
-        session = self.get_session()
-        try:
-            latest_version = session.query(WorkflowVersion)\
-                .filter(WorkflowVersion.session_id == session_id)\
-                .order_by(WorkflowVersion.id.desc())\
-                .first()
-            
-            if latest_version:
-                return json.loads(latest_version.workflow_data)
-            return None
-        finally:
-            session.close()
-    
-    def get_current_workflow_data_ui(self, session_id: str) -> Optional[Dict[str, Any]]:
-        """获取当前session的最新工作流数据（最大ID版本）"""
-        session = self.get_session()
-        try:
-            latest_version = session.query(WorkflowVersion)\
-                .filter(WorkflowVersion.session_id == session_id)\
-                .order_by(WorkflowVersion.id.desc())\
-                .first()
-            
-            if latest_version:
-                return json.loads(latest_version.workflow_data_ui)
-            return None
-        finally:
-            session.close() 
-    
-    def get_workflow_version_by_id(self, version_id: int) -> Optional[Dict[str, Any]]:
-        """根据版本ID获取工作流数据"""
-        session = self.get_session()
-        try:
-            version = session.query(WorkflowVersion)\
-                .filter(WorkflowVersion.id == version_id)\
-                .first()
-            
-            if version:
-                result = version.to_dict()
-                # 添加UI格式的工作流数据
-                if version.workflow_data_ui:
-                    result['workflow_data_ui'] = json.loads(version.workflow_data_ui)
-                return result
-            return None
-        finally:
-            session.close()
-    
-    def update_workflow_version(self, version_id: int, workflow_data: Dict[str, Any], attributes: Optional[Dict[str, Any]] = None) -> bool:
-        """更新指定版本的工作流数据"""
-        session = self.get_session()
-        try:
-            version = session.query(WorkflowVersion)\
-                .filter(WorkflowVersion.id == version_id)\
-                .first()
-            
-            if version:
-                version.workflow_data = json.dumps(workflow_data)
-                if attributes:
-                    version.attributes = json.dumps(attributes)
-                session.commit()
-                return True
-            return False
-        except Exception as e:
-            session.rollback()
-            raise e
-        finally:
-            session.close()
-    
-    def update_workflow_ui(self, version_id: int, workflow_data_ui: Dict[str, Any]) -> bool:
-        """只更新指定版本的workflow_data_ui字段，不影响其他字段"""
-        session = self.get_session()
-        try:
-            version = session.query(WorkflowVersion)\
-                .filter(WorkflowVersion.id == version_id)\
-                .first()
-            
-            if version:
-                version.workflow_data_ui = json.dumps(workflow_data_ui)
-                session.commit()
-                return True
-            return False
-        except Exception as e:
-            session.rollback()
-            raise e
-        finally:
-            session.close()
-
-# 全局数据库管理器实例
-db_manager = DatabaseManager()
-
-def get_workflow_data(session_id: str) -> Optional[Dict[str, Any]]:
-    """获取当前session的工作流数据的便捷函数"""
-    return db_manager.get_current_workflow_data(session_id)
-
-def get_workflow_data_ui(session_id: str) -> Optional[Dict[str, Any]]:
-    """获取当前session的工作流数据的便捷函数"""
-    return db_manager.get_current_workflow_data_ui(session_id)
-
-def save_workflow_data(session_id: str, workflow_data: Dict[str, Any], workflow_data_ui: Dict[str, Any] = None, attributes: Optional[Dict[str, Any]] = None) -> int:
-    """保存工作流数据的便捷函数"""
-    return db_manager.save_workflow_version(session_id, workflow_data, workflow_data_ui, attributes)
-
-def get_workflow_data_by_id(version_id: int) -> Optional[Dict[str, Any]]:
-    """根据版本ID获取工作流数据的便捷函数"""
-    return db_manager.get_workflow_version_by_id(version_id)
-
-def update_workflow_ui_by_id(version_id: int, workflow_data_ui: Dict[str, Any]) -> bool:
-    """只更新指定版本的workflow_data_ui字段的便捷函数"""
-    return db_manager.update_workflow_ui(version_id, workflow_data_ui) 

custom_nodes/ComfyUI-Copilot/backend/service/link_agent_tools.py

@@ -1,467 +0,0 @@
-# Link Agent Tools for ComfyUI Workflow Connection Analysis
-
-import json
-import time
-from typing import Dict, Optional, List
-
-from agents.tool import function_tool
-from ..utils.request_context import get_session_id
-from ..dao.workflow_table import get_workflow_data, save_workflow_data
-from ..utils.comfy_gateway import get_object_info
-from ..utils.logger import log
-
-@function_tool
-async def analyze_missing_connections() -> str:
-    """
-    分析工作流中缺失的连接，枚举所有可能的连接选项和所需的新节点。
-    
-    返回格式说明：
-    - missing_connections: 缺失连接的详细列表，包含节点ID、输入名称、需要的数据类型等（仅包含required输入）
-    - possible_connections: 现有节点可以提供的连接选项
-    - universal_inputs: 可以接受任意输出类型的通用输入端口
-    - optional_unconnected_inputs: 未连接的可选输入列表，包含节点ID、输入名称、配置信息等
-    - required_new_nodes: 需要创建的新节点类型列表
-    - connection_summary: 连接分析的统计摘要（包含optional输入的统计）
-    """
-    try:
-        session_id = get_session_id()
-        if not session_id:
-            log.error("analyze_missing_connections: No session_id found in context")
-            return json.dumps({"error": "No session_id found in context"})
-        
-        workflow_data = get_workflow_data(session_id)
-        if not workflow_data:
-            return json.dumps({"error": "No workflow data found for this session"})
-        
-        object_info = await get_object_info()
-        
-        analysis_result = {
-            "missing_connections": [],
-            "possible_connections": [],
-            "universal_inputs": [],  # 可以连接任意输出的输入端口
-            "optional_unconnected_inputs": [],  # 未连接的optional输入
-            "required_new_nodes": [],
-            "connection_summary": {
-                "total_missing": 0,
-                "auto_fixable": 0,
-                "requires_new_nodes": 0,
-                "universal_inputs_count": 0,
-                "optional_unconnected_count": 0
-            }
-        }
-        
-        # 构建现有节点的输出映射
-        available_outputs = {}
-        for node_id, node_data in workflow_data.items():
-            node_class = node_data.get("class_type")
-            if node_class in object_info and "output" in object_info[node_class]:
-                outputs = object_info[node_class]["output"]
-                available_outputs[node_id] = {
-                    "class_type": node_class,
-                    "outputs": [(i, output_type) for i, output_type in enumerate(outputs)]
-                }
-        
-        # 分析每个节点的缺失连接
-        for node_id, node_data in workflow_data.items():
-            node_class = node_data.get("class_type")
-            if node_class not in object_info:
-                continue
-                
-            node_info = object_info[node_class]
-            if "input" not in node_info:
-                continue
-                
-            required_inputs = node_info["input"].get("required", {})
-            current_inputs = node_data.get("inputs", {})
-            
-            # 检查每个required input
-            for input_name, input_config in required_inputs.items():
-                if input_name not in current_inputs:
-                    # 发现缺失的连接
-                    missing_connection = {
-                        "node_id": node_id,
-                        "node_class": node_class,
-                        "input_name": input_name,
-                        "input_config": input_config,
-                        "required": True
-                    }
-                    
-                    # 分析输入类型
-                    if isinstance(input_config, (list, tuple)) and len(input_config) > 0:
-                        expected_types = input_config[0] if isinstance(input_config[0], list) else [input_config[0]]
-                    
-                    missing_connection["expected_types"] = expected_types
-                    
-                    # 检查是否是通用输入（可以接受任意类型）
-                    is_universal_input = "*" in expected_types
-                    
-                    if is_universal_input:
-                        # 这是一个通用输入端口，可以连接任意输出
-                        universal_input = {
-                            "node_id": node_id,
-                            "node_class": node_class,
-                            "input_name": input_name,
-                            "input_config": input_config,
-                            "can_connect_any_output": True
-                        }
-                        analysis_result["universal_inputs"].append(universal_input)
-                        analysis_result["connection_summary"]["universal_inputs_count"] += 1
-                        analysis_result["connection_summary"]["auto_fixable"] += 1
-                        
-                        # 对于通用输入，我们不列出所有可能的连接，而是标记为通用
-                        missing_connection["possible_matches"] = "universal"
-                        missing_connection["is_universal"] = True
-                    else:
-                        # 查找具体类型匹配的连接
-                        possible_matches = []
-                        for source_node_id, source_info in available_outputs.items():
-                            if source_node_id == node_id:  # 不能连接自己
-                                continue
-                                
-                            for output_index, output_type in source_info["outputs"]:
-                                # 检查类型匹配（排除通用类型的情况）
-                                type_match = (output_type in expected_types or output_type == "*")
-                                
-                                if type_match:
-                                    possible_matches.append({
-                                        "source_node_id": source_node_id,
-                                        "source_class": source_info["class_type"],
-                                        "output_index": output_index,
-                                        "output_type": output_type,
-                                        "match_confidence": "high" if output_type in expected_types else "medium"
-                                    })
-                        
-                        missing_connection["possible_matches"] = possible_matches
-                        missing_connection["is_universal"] = False
-                        
-                        # 如果有可能的匹配，添加到possible_connections
-                        if possible_matches:
-                            analysis_result["possible_connections"].extend([
-                                {
-                                    "target_node_id": node_id,
-                                    "target_input": input_name,
-                                    "source_node_id": match["source_node_id"],
-                                    "source_output_index": match["output_index"],
-                                    "connection": [match["source_node_id"], match["output_index"]],
-                                    "confidence": match["match_confidence"],
-                                    "types": {
-                                        "expected": expected_types,
-                                        "provided": match["output_type"]
-                                    }
-                                } for match in possible_matches
-                            ])
-                            analysis_result["connection_summary"]["auto_fixable"] += 1
-                        else:
-                            # 没有匹配的输出，需要新节点
-                            analysis_result["connection_summary"]["requires_new_nodes"] += 1
-                            
-                            # 分析需要什么类型的节点
-                            required_node_types = analyze_required_node_types(expected_types, object_info)
-                            analysis_result["required_new_nodes"].extend([{
-                                "for_node": node_id,
-                                "for_input": input_name,
-                                "expected_types": expected_types,
-                                "suggested_node_types": required_node_types
-                            }])
-                    
-                    analysis_result["missing_connections"].append(missing_connection)
-            
-            # 检查optional inputs (未连接的可选输入)
-            optional_inputs = node_info["input"].get("optional", {})
-            for input_name, input_config in optional_inputs.items():
-                if input_name not in current_inputs:
-                    # 发现未连接的optional输入
-                    optional_unconnected = {
-                        "node_id": node_id,
-                        "node_class": node_class,
-                        "input_name": input_name,
-                        "input_config": input_config,
-                        "required": False
-                    }
-                    
-                    # 分析输入类型
-                    if isinstance(input_config, (list, tuple)) and len(input_config) > 0:
-                        expected_types = input_config[0] if isinstance(input_config[0], list) else [input_config[0]]
-                    else:
-                        expected_types = ["*"]  # 默认为通用类型
-                    
-                    optional_unconnected["expected_types"] = expected_types
-                    
-                    # 检查是否是通用输入（可以接受任意类型）
-                    is_universal_input = "*" in expected_types
-                    optional_unconnected["is_universal"] = is_universal_input
-                    
-                    analysis_result["optional_unconnected_inputs"].append(optional_unconnected)
-        
-        # 更新统计信息
-        analysis_result["connection_summary"]["total_missing"] = len(analysis_result["missing_connections"])
-        analysis_result["connection_summary"]["optional_unconnected_count"] = len(analysis_result["optional_unconnected_inputs"])
-        
-        log.info(f"analysis_result: {json.dumps(analysis_result, ensure_ascii=False)}")
-        return json.dumps(analysis_result)
-        
-    except Exception as e:
-        return json.dumps({"error": f"Failed to analyze missing connections: {str(e)}"})
-
-def analyze_required_node_types(expected_types: List[str], object_info: Dict) -> List[Dict]:
-    """分析需要什么类型的节点来提供指定的输出类型"""
-    suggested_nodes = []
-    
-    # 常见类型到节点的映射
-    type_to_nodes = {
-        "MODEL": ["CheckpointLoaderSimple", "CheckpointLoader", "UNETLoader"],
-        "CLIP": ["CheckpointLoaderSimple", "CheckpointLoader", "CLIPLoader"],
-        "VAE": ["CheckpointLoaderSimple", "CheckpointLoader", "VAELoader"],
-        "CONDITIONING": ["CLIPTextEncode"],
-        "LATENT": ["EmptyLatentImage", "VAEEncode"],
-        "IMAGE": ["LoadImage", "VAEDecode"],
-        "MASK": ["LoadImageMask"],
-        "CONTROL_NET": ["ControlNetLoader"],
-        "LORA": ["LoraLoader"],
-        "IPADAPTER": ["IPAdapterModelLoader"]
-    }
-    
-    for expected_type in expected_types:
-        if expected_type in type_to_nodes:
-            for node_class in type_to_nodes[expected_type]:
-                if node_class in object_info:
-                    suggested_nodes.append({
-                        "node_class": node_class,
-                        "output_type": expected_type,
-                        "confidence": "high",
-                        "description": f"{node_class} can provide {expected_type}"
-                    })
-        else:
-            # 搜索所有能提供该类型输出的节点
-            for node_class, node_info in object_info.items():
-                if "output" in node_info:
-                    outputs = node_info["output"]
-                    if expected_type in outputs:
-                        suggested_nodes.append({
-                            "node_class": node_class,
-                            "output_type": expected_type,
-                            "confidence": "medium",
-                            "description": f"{node_class} can provide {expected_type}"
-                        })
-    
-    # 去重并排序
-    unique_nodes = {}
-    for node in suggested_nodes:
-        key = node["node_class"]
-        if key not in unique_nodes or unique_nodes[key]["confidence"] == "medium":
-            unique_nodes[key] = node
-    
-    return list(unique_nodes.values())
-
-def save_checkpoint_before_link_modification(session_id: str, action_description: str) -> Optional[int]:
-    """在连接修改前保存checkpoint"""
-    try:
-        current_workflow = get_workflow_data(session_id)
-        if not current_workflow:
-            return None
-            
-        checkpoint_id = save_workflow_data(
-            session_id,
-            current_workflow,
-            workflow_data_ui=None,
-            attributes={
-                "checkpoint_type": "link_agent_start",
-                "description": f"Checkpoint before {action_description}",
-                "action": "link_agent_checkpoint",
-                "timestamp": time.time()
-            }
-        )
-        log.info(f"Saved link agent checkpoint with ID: {checkpoint_id}")
-        return checkpoint_id
-    except Exception as e:
-        log.error(f"Failed to save checkpoint before link modification: {str(e)}")
-        return None 
-
-@function_tool
-def apply_connection_fixes(fixes_json: str) -> str:
-    """批量应用连接修复，fixes_json应为包含修复指令的JSON字符串"""
-    try:
-        session_id = get_session_id()
-        if not session_id:
-            log.error("apply_connection_fixes: No session_id found in context")
-            return json.dumps({"error": "No session_id found in context"})
-        
-        # 在修改前保存checkpoint
-        checkpoint_id = save_checkpoint_before_link_modification(session_id, "batch connection fixes")
-        
-        # 解析修复指令
-        fixes = json.loads(fixes_json) if isinstance(fixes_json, str) else fixes_json
-        
-        workflow_data = get_workflow_data(session_id)
-        if not workflow_data:
-            return json.dumps({"error": "No workflow data found for this session"})
-        
-        applied_fixes = []
-        failed_fixes = []
-        
-        # 处理连接修复
-        connections_to_add = fixes.get("connections", [])
-        for conn_fix in connections_to_add:
-            try:
-                target_node_id = conn_fix["target_node_id"]
-                target_input = conn_fix["target_input"]
-                source_node_id = conn_fix["source_node_id"]
-                source_output_index = conn_fix["source_output_index"]
-                
-                if target_node_id not in workflow_data:
-                    failed_fixes.append({
-                        "type": "connection",
-                        "target": f"{target_node_id}.{target_input}",
-                        "error": f"Target node {target_node_id} not found"
-                    })
-                    continue
-                
-                if source_node_id not in workflow_data:
-                    failed_fixes.append({
-                        "type": "connection", 
-                        "target": f"{target_node_id}.{target_input}",
-                        "error": f"Source node {source_node_id} not found"
-                    })
-                    continue
-                
-                # 应用连接
-                if "inputs" not in workflow_data[target_node_id]:
-                    workflow_data[target_node_id]["inputs"] = {}
-                
-                old_value = workflow_data[target_node_id]["inputs"].get(target_input, "not connected")
-                new_connection = [source_node_id, source_output_index]
-                workflow_data[target_node_id]["inputs"][target_input] = new_connection
-                
-                applied_fixes.append({
-                    "type": "connection",
-                    "target": f"{target_node_id}.{target_input}",
-                    "source": f"{source_node_id}[{source_output_index}]",
-                    "old_value": old_value,
-                    "new_value": new_connection
-                })
-                
-            except Exception as e:
-                failed_fixes.append({
-                    "type": "connection",
-                    "target": f"{conn_fix.get('target_node_id', 'unknown')}.{conn_fix.get('target_input', 'unknown')}",
-                    "error": str(e)
-                })
-        
-        # 处理新节点添加
-        nodes_to_add = fixes.get("new_nodes", [])
-        for node_spec in nodes_to_add:
-            try:
-                node_class = node_spec["node_class"]
-                node_id = node_spec.get("node_id", "")
-                inputs = node_spec.get("inputs", {})
-                
-                # 生成节点ID
-                if not node_id:
-                    existing_ids = set(workflow_data.keys())
-                    node_id = "1"
-                    while node_id in existing_ids:
-                        node_id = str(int(node_id) + 1)
-                
-                # 创建新节点
-                new_node = {
-                    "class_type": node_class,
-                    "inputs": inputs,
-                    "_meta": {"title": node_class}
-                }
-                
-                workflow_data[node_id] = new_node
-                
-                applied_fixes.append({
-                    "type": "add_node",
-                    "node_id": node_id,
-                    "node_class": node_class,
-                    "inputs": inputs
-                })
-                
-                # 如果指定了要自动连接的目标，进行连接
-                auto_connect = node_spec.get("auto_connect", [])
-                for auto_conn in auto_connect:
-                    target_node_id = auto_conn["target_node_id"]
-                    target_input = auto_conn["target_input"]
-                    output_index = auto_conn.get("output_index", 0)
-                    
-                    if target_node_id in workflow_data:
-                        if "inputs" not in workflow_data[target_node_id]:
-                            workflow_data[target_node_id]["inputs"] = {}
-                        
-                        workflow_data[target_node_id]["inputs"][target_input] = [node_id, output_index]
-                        
-                        applied_fixes.append({
-                            "type": "auto_connection",
-                            "from_new_node": node_id,
-                            "to": f"{target_node_id}.{target_input}",
-                            "output_index": output_index
-                        })
-                
-            except Exception as e:
-                failed_fixes.append({
-                    "type": "add_node",
-                    "node_class": node_spec.get("node_class", "unknown"),
-                    "error": str(e)
-                })
-        
-        # 保存更新的工作流
-        version_id = save_workflow_data(
-            session_id,
-            workflow_data,
-            attributes={
-                "action": "link_agent_batch_fix",
-                "description": f"Applied {len(applied_fixes)} connection fixes",
-                "fixes_applied": applied_fixes,
-                "fixes_failed": failed_fixes
-            }
-        )
-        
-        # 构建返回数据，包含checkpoint信息
-        ext_data = [{
-            "type": "workflow_update",
-            "data": {
-                "workflow_data": workflow_data,
-                "changes": {
-                    "applied_fixes": applied_fixes,
-                    "failed_fixes": failed_fixes
-                }
-            }
-        }]
-        
-        # 如果成功保存了checkpoint，添加修改前的checkpoint信息
-        if checkpoint_id:
-            ext_data.append({
-                "type": "link_agent_checkpoint",
-                "data": {
-                    "checkpoint_id": checkpoint_id,
-                    "checkpoint_type": "link_agent_start"
-                }
-            })
-        
-        # 添加修改后的版本信息
-        ext_data.append({
-            "type": "link_agent_complete",
-            "data": {
-                "version_id": version_id,
-                "checkpoint_type": "link_agent_complete"
-            }
-        })
-        
-        return json.dumps({
-            "success": True,
-            "version_id": version_id,
-            "applied_fixes": applied_fixes,
-            "failed_fixes": failed_fixes,
-            "summary": {
-                "total_fixes": len(applied_fixes),
-                "failed_fixes": len(failed_fixes),
-                "connections_added": len([f for f in applied_fixes if f["type"] == "connection"]),
-                "nodes_added": len([f for f in applied_fixes if f["type"] == "add_node"])
-            },
-            "message": f"Applied {len(applied_fixes)} fixes successfully, {len(failed_fixes)} failed",
-            "ext": ext_data
-        })
-        
-    except Exception as e:
-        return json.dumps({"error": f"Failed to apply connection fixes: {str(e)}"})