Add custom nodes, Civitai loras (LFS), and vast.ai setup script

Includes 30 custom nodes committed directly, 7 Civitai-exclusive loras stored via Git LFS, and a setup script that installs all dependencies and downloads HuggingFace-hosted models on vast.ai. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-09 00:55:26 +00:00
parent 2b70ab9ad0
commit f09734b0ee
2274 changed files with 748556 additions and 3 deletions
--- a/custom_nodes/rgthree-comfy/web/comfyui/node_mode_relay.js
+++ b/custom_nodes/rgthree-comfy/web/comfyui/node_mode_relay.js
@@ -0,0 +1,205 @@
+import { app } from "../../scripts/app.js";
+import { PassThroughFollowing, addConnectionLayoutSupport, changeModeOfNodes, getConnectedInputNodesAndFilterPassThroughs, getConnectedOutputNodesAndFilterPassThroughs, } from "./utils.js";
+import { wait } from "../../rgthree/common/shared_utils.js";
+import { BaseCollectorNode } from "./base_node_collector.js";
+import { NodeTypesString, stripRgthree } from "./constants.js";
+import { fitString } from "./utils_canvas.js";
+import { rgthree } from "./rgthree.js";
+const MODE_ALWAYS = 0;
+const MODE_MUTE = 2;
+const MODE_BYPASS = 4;
+const MODE_REPEATS = [MODE_MUTE, MODE_BYPASS];
+const MODE_NOTHING = -99;
+const MODE_TO_OPTION = new Map([
+    [MODE_ALWAYS, "ACTIVE"],
+    [MODE_MUTE, "MUTE"],
+    [MODE_BYPASS, "BYPASS"],
+    [MODE_NOTHING, "NOTHING"],
+]);
+const OPTION_TO_MODE = new Map([
+    ["ACTIVE", MODE_ALWAYS],
+    ["MUTE", MODE_MUTE],
+    ["BYPASS", MODE_BYPASS],
+    ["NOTHING", MODE_NOTHING],
+]);
+const MODE_TO_PROPERTY = new Map([
+    [MODE_MUTE, "on_muted_inputs"],
+    [MODE_BYPASS, "on_bypassed_inputs"],
+    [MODE_ALWAYS, "on_any_active_inputs"],
+]);
+const logger = rgthree.newLogSession("[NodeModeRelay]");
+class NodeModeRelay extends BaseCollectorNode {
+    constructor(title) {
+        super(title);
+        this.inputsPassThroughFollowing = PassThroughFollowing.ALL;
+        this.comfyClass = NodeTypesString.NODE_MODE_RELAY;
+        this.properties["on_muted_inputs"] = "MUTE";
+        this.properties["on_bypassed_inputs"] = "BYPASS";
+        this.properties["on_any_active_inputs"] = "ACTIVE";
+        this.onConstructed();
+    }
+    onConstructed() {
+        this.addOutput("REPEATER", "_NODE_REPEATER_", {
+            color_on: "#Fc0",
+            color_off: "#a80",
+            shape: LiteGraph.ARROW_SHAPE,
+        });
+        setTimeout(() => {
+            this.stabilize();
+        }, 500);
+        return super.onConstructed();
+    }
+    onModeChange(from, to) {
+        var _a;
+        super.onModeChange(from, to);
+        if (this.inputs.length <= 1 && !this.isInputConnected(0) && this.isAnyOutputConnected()) {
+            const [n, v] = logger.infoParts(`Mode change without any inputs; relaying our mode.`);
+            (_a = console[n]) === null || _a === void 0 ? void 0 : _a.call(console, ...v);
+            this.dispatchModeToRepeater(to);
+        }
+    }
+    onDrawForeground(ctx, canvas) {
+        var _a;
+        if ((_a = this.flags) === null || _a === void 0 ? void 0 : _a.collapsed) {
+            return;
+        }
+        if (this.properties["on_muted_inputs"] !== "MUTE" ||
+            this.properties["on_bypassed_inputs"] !== "BYPASS" ||
+            this.properties["on_any_active_inputs"] != "ACTIVE") {
+            let margin = 15;
+            ctx.textAlign = "left";
+            let label = `*(MUTE > ${this.properties["on_muted_inputs"]},  `;
+            label += `BYPASS > ${this.properties["on_bypassed_inputs"]},  `;
+            label += `ACTIVE > ${this.properties["on_any_active_inputs"]})`;
+            ctx.fillStyle = LiteGraph.WIDGET_SECONDARY_TEXT_COLOR;
+            const oldFont = ctx.font;
+            ctx.font = "italic " + (LiteGraph.NODE_SUBTEXT_SIZE - 2) + "px Arial";
+            ctx.fillText(fitString(ctx, label, this.size[0] - 20), 15, this.size[1] - 6);
+            ctx.font = oldFont;
+        }
+    }
+    computeSize(out) {
+        let size = super.computeSize(out);
+        if (this.properties["on_muted_inputs"] !== "MUTE" ||
+            this.properties["on_bypassed_inputs"] !== "BYPASS" ||
+            this.properties["on_any_active_inputs"] != "ACTIVE") {
+            size[1] += 17;
+        }
+        return size;
+    }
+    onConnectOutput(outputIndex, inputType, inputSlot, inputNode, inputIndex) {
+        var _a, _b;
+        let canConnect = (_a = super.onConnectOutput) === null || _a === void 0 ? void 0 : _a.call(this, outputIndex, inputType, inputSlot, inputNode, inputIndex);
+        let nextNode = (_b = getConnectedOutputNodesAndFilterPassThroughs(this, inputNode)[0]) !== null && _b !== void 0 ? _b : inputNode;
+        return canConnect && nextNode.type === NodeTypesString.NODE_MODE_REPEATER;
+    }
+    onConnectionsChange(type, slotIndex, isConnected, link_info, ioSlot) {
+        super.onConnectionsChange(type, slotIndex, isConnected, link_info, ioSlot);
+        setTimeout(() => {
+            this.stabilize();
+        }, 500);
+    }
+    stabilize() {
+        if (!this.graph || !this.isAnyOutputConnected() || !this.isInputConnected(0)) {
+            return;
+        }
+        const inputNodes = getConnectedInputNodesAndFilterPassThroughs(this, this, -1, this.inputsPassThroughFollowing);
+        let mode = undefined;
+        for (const inputNode of inputNodes) {
+            if (mode === undefined) {
+                mode = inputNode.mode;
+            }
+            else if (mode === inputNode.mode && MODE_REPEATS.includes(mode)) {
+                continue;
+            }
+            else if (inputNode.mode === MODE_ALWAYS || mode === MODE_ALWAYS) {
+                mode = MODE_ALWAYS;
+            }
+            else {
+                mode = undefined;
+            }
+        }
+        this.dispatchModeToRepeater(mode);
+        setTimeout(() => {
+            this.stabilize();
+        }, 500);
+    }
+    dispatchModeToRepeater(mode) {
+        var _a, _b;
+        if (mode != null) {
+            const propertyVal = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[MODE_TO_PROPERTY.get(mode) || ""];
+            const newMode = OPTION_TO_MODE.get(propertyVal);
+            mode = (newMode !== null ? newMode : mode);
+            if (mode !== null && mode !== MODE_NOTHING) {
+                if ((_b = this.outputs) === null || _b === void 0 ? void 0 : _b.length) {
+                    const outputNodes = getConnectedOutputNodesAndFilterPassThroughs(this);
+                    for (const outputNode of outputNodes) {
+                        changeModeOfNodes(outputNode, mode);
+                        wait(16).then(() => {
+                            outputNode.setDirtyCanvas(true, true);
+                        });
+                    }
+                }
+            }
+        }
+    }
+    getHelp() {
+        return `
+      <p>
+        This node will relay its input nodes' modes (Mute, Bypass, or Active) to a connected
+        ${stripRgthree(NodeTypesString.NODE_MODE_REPEATER)} (which would then repeat that mode
+        change to all of its inputs).
+      </p>
+      <ul>
+          <li><p>
+            When all connected input nodes are muted, the relay will set a connected repeater to
+            mute (by default).
+          </p></li>
+          <li><p>
+            When all connected input nodes are bypassed, the relay will set a connected repeater to
+            bypass (by default).
+          </p></li>
+          <li><p>
+            When any connected input nodes are active, the relay will set a connected repeater to
+            active (by default).
+          </p></li>
+          <li><p>
+            If no inputs are connected, the relay will set a connected repeater to its mode <i>when
+            its own mode is changed</i>. <b>Note</b>, if any inputs are connected, then the above
+            will occur and the Relay's mode does not matter.
+          </p></li>
+      </ul>
+      <p>
+        Note, you can change which signals get sent on the above in the <code>Properties</code>.
+        For instance, you could configure an inverse relay which will send a MUTE when any of its
+        inputs are active (instead of sending an ACTIVE signal), and send an ACTIVE signal when all
+        of its inputs are muted (instead of sending a MUTE signal), etc.
+      </p>
+    `;
+    }
+}
+NodeModeRelay.type = NodeTypesString.NODE_MODE_RELAY;
+NodeModeRelay.title = NodeTypesString.NODE_MODE_RELAY;
+NodeModeRelay["@on_muted_inputs"] = {
+    type: "combo",
+    values: ["MUTE", "ACTIVE", "BYPASS", "NOTHING"],
+};
+NodeModeRelay["@on_bypassed_inputs"] = {
+    type: "combo",
+    values: ["BYPASS", "ACTIVE", "MUTE", "NOTHING"],
+};
+NodeModeRelay["@on_any_active_inputs"] = {
+    type: "combo",
+    values: ["BYPASS", "ACTIVE", "MUTE", "NOTHING"],
+};
+app.registerExtension({
+    name: "rgthree.NodeModeRepeaterHelper",
+    registerCustomNodes() {
+        addConnectionLayoutSupport(NodeModeRelay, app, [
+            ["Left", "Right"],
+            ["Right", "Left"],
+        ]);
+        LiteGraph.registerNodeType(NodeModeRelay.type, NodeModeRelay);
+        NodeModeRelay.category = NodeModeRelay._category;
+    },
+});