diff --git a/.gitattributes b/.gitattributes
index 24540ca10487d666cc448014cb19b669d4212a9c..e2c738d902c7596d56808b332396401c3a8eae2d 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -38,3 +38,7 @@ custom_nodes/ComfyUI-KJNodes/fonts/FreeMono.ttf filter=lfs diff=lfs merge=lfs -t
custom_nodes/ComfyUI-KJNodes/fonts/FreeMonoBoldOblique.otf filter=lfs diff=lfs merge=lfs -text
custom_nodes/ComfyUI-KJNodes/fonts/TTNorms-Black.otf filter=lfs diff=lfs merge=lfs -text
custom_nodes/ComfyUI-LTXVideo/gemma_configs/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_advanced.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_advanced_metadata.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_context.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_context_metadata.png filter=lfs diff=lfs merge=lfs -text
diff --git a/custom_nodes/rgthree-comfy/.github/workflows/publish_comfy_registry_action.yml b/custom_nodes/rgthree-comfy/.github/workflows/publish_comfy_registry_action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d52a3bba8f75308fa0d74dfc211f443c8ebb8bb2
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/.github/workflows/publish_comfy_registry_action.yml
@@ -0,0 +1,20 @@
+name: Publish to Comfy registry
+on:
+ workflow_dispatch:
+ push:
+ branches:
+ - main
+ paths:
+ - "pyproject.toml"
+
+jobs:
+ publish-node:
+ name: Publish Custom Node to registry
+ runs-on: ubuntu-latest
+ steps:
+ - name: Check out code
+ uses: actions/checkout@v4
+ - name: Publish Custom Node
+ uses: Comfy-Org/publish-node-action@main
+ with:
+ personal_access_token: ${{ secrets.COMFY_REGISTRY_ACCESS_TOKEN }}
diff --git a/custom_nodes/rgthree-comfy/.gitignore b/custom_nodes/rgthree-comfy/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..1526efa2a13afec03677a73c3fe07ebdfb37e197
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/.gitignore
@@ -0,0 +1,13 @@
+__pycache__
+*.ini
+wildcards/**
+.vscode/
+.idea/
+node_modules/
+rgthree_config.json
+web/rgthree_config.js
+web/comfyui/rgthree_config.js
+userdata/
+userdata/**
+web/comfyui/testing/
+web/comfyui/tests/
\ No newline at end of file
diff --git a/custom_nodes/rgthree-comfy/.prettierrc.json b/custom_nodes/rgthree-comfy/.prettierrc.json
new file mode 100644
index 0000000000000000000000000000000000000000..582f76b20736717b28dced7aa429721f5f6d0261
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/.prettierrc.json
@@ -0,0 +1,5 @@
+{
+ "printWidth": 100,
+ "bracketSpacing": false,
+ "bracketSameLine": true
+}
diff --git a/custom_nodes/rgthree-comfy/.pylintrc b/custom_nodes/rgthree-comfy/.pylintrc
new file mode 100644
index 0000000000000000000000000000000000000000..8a082e8efeab523b735b15b0d4b3491a1f4a0c99
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/.pylintrc
@@ -0,0 +1,633 @@
+[MAIN]
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Clear in-memory caches upon conclusion of linting. Useful if running pylint
+# in a server-like mode.
+clear-cache-post-run=no
+
+# Load and enable all available extensions. Use --list-extensions to see a list
+# all available extensions.
+#enable-all-extensions=
+
+# In error mode, messages with a category besides ERROR or FATAL are
+# suppressed, and no reports are done by default. Error mode is compatible with
+# disabling specific errors.
+#errors-only=
+
+# Always return a 0 (non-error) status code, even if lint errors are found.
+# This is primarily useful in continuous integration scripts.
+#exit-zero=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Return non-zero exit code if any of these messages/categories are detected,
+# even if score is above --fail-under value. Syntax same as enable. Messages
+# specified are enabled, while categories only check already-enabled messages.
+fail-on=
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=10
+
+# Interpret the stdin as a python script, whose filename needs to be passed as
+# the module_or_package argument.
+#from-stdin=
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=CVS
+
+# Add files or directories matching the regular expressions patterns to the
+# ignore-list. The regex matches against paths and can be in Posix or Windows
+# format. Because '\\' represents the directory delimiter on Windows systems,
+# it can't be used as an escape character.
+ignore-paths=
+
+# Files or directories matching the regular expression patterns are skipped.
+# The regex matches against base names, not paths. The default value ignores
+# Emacs file locks
+ignore-patterns=^\.#
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis). It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use, and will cap the count on Windows to
+# avoid hangs.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Minimum Python version to use for version dependent checks. Will default to
+# the version used to run pylint.
+py-version=3.10
+
+# Discover python modules and packages in the file system subtree.
+recursive=no
+
+# Add paths to the list of the source roots. Supports globbing patterns. The
+# source root is an absolute path or a path relative to the current working
+# directory used to determine a package namespace for modules located under the
+# source root.
+source-roots=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# In verbose mode, extra non-checker-related info will be displayed.
+#verbose=
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style. If left empty, argument names will be checked with the set
+# naming style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style. If left empty, attribute names will be checked with the set naming
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+ bar,
+ baz,
+ toto,
+ tutu,
+ tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style. If left empty, class attribute names will be checked
+# with the set naming style.
+#class-attribute-rgx=
+
+# Naming style matching correct class constant names.
+class-const-naming-style=UPPER_CASE
+
+# Regular expression matching correct class constant names. Overrides class-
+# const-naming-style. If left empty, class constant names will be checked with
+# the set naming style.
+#class-const-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style. If left empty, class names will be checked with the set naming style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style. If left empty, constant names will be checked with the set naming
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style. If left empty, function names will be checked with the set
+# naming style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+ j,
+ k,
+ ex,
+ Run,
+ _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style. If left empty, inline iteration names will be checked
+# with the set naming style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style. If left empty, method names will be checked with the set naming style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style. If left empty, module names will be checked with the set naming style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct type alias names. If left empty, type
+# alias names will be checked with the set naming style.
+#typealias-rgx=
+
+# Regular expression matching correct type variable names. If left empty, type
+# variable names will be checked with the set naming style.
+#typevar-rgx=
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style. If left empty, variable names will be checked with the set
+# naming style.
+#variable-rgx=
+
+
+[CLASSES]
+
+# Warn about protected attribute access inside special methods
+check-protected-access-in-special-methods=no
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+ __new__,
+ setUp,
+ asyncSetUp,
+ __post_init__
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[DESIGN]
+
+# List of regular expressions of class ancestor names to ignore when counting
+# public methods (see R0903)
+exclude-too-few-public-methods=
+
+# List of qualified class names to ignore when counting class parents (see
+# R0901)
+ignored-parents=
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when caught.
+overgeneral-exceptions=builtins.BaseException,builtins.Exception
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )??$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string=' '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow explicit reexports by alias from a package __init__.
+allow-reexport-from-package=no
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=
+
+# Output a graph (.gv or any supported image format) of external dependencies
+# to the given file (report RP0402 must not be disabled).
+ext-import-graph=
+
+# Output a graph (.gv or any supported image format) of all (i.e. internal and
+# external) dependencies to the given file (report RP0402 must not be
+# disabled).
+import-graph=
+
+# Output a graph (.gv or any supported image format) of internal dependencies
+# to the given file (report RP0402 must not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[LOGGING]
+
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
+# UNDEFINED.
+confidence=HIGH,
+ CONTROL_FLOW,
+ INFERENCE,
+ INFERENCE_FAILURE,
+ UNDEFINED
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then re-enable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=raw-checker-failed,
+ bad-inline-option,
+ locally-disabled,
+ file-ignored,
+ suppressed-message,
+ useless-suppression,
+ deprecated-pragma,
+ use-symbolic-message-instead,
+ C0103, # invalid-name :: constant case
+ W0603 # global-statements
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=c-extension-no-member
+
+
+[METHOD_ARGS]
+
+# List of qualified names (i.e., library.method) which require a timeout
+# parameter e.g. 'requests.api.get,requests.api.post'
+timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+ XXX,
+ TODO
+
+# Regular expression of note tags to take in consideration.
+notes-rgx=
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit,argparse.parse_error
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'fatal', 'error', 'warning', 'refactor',
+# 'convention', and 'info' which contain the number of messages in each
+# category, as well as 'statement' which is the total number of statements
+# analyzed. This score is used by the global evaluation report (RP0004).
+evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+msg-template=
+
+# Set the output format. Available formats are text, parseable, colorized, json
+# and msvs (visual studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+#output-format=
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[SIMILARITIES]
+
+# Comments are removed from the similarity computation
+ignore-comments=yes
+
+# Docstrings are removed from the similarity computation
+ignore-docstrings=yes
+
+# Imports are removed from the similarity computation
+ignore-imports=yes
+
+# Signatures are removed from the similarity computation
+ignore-signatures=yes
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. No available dictionaries : You need to install
+# both the python package and the system dependency for enchant to work..
+spelling-dict=
+
+# List of comma separated words that should be considered directives if they
+# appear at the beginning of a comment and should not be checked.
+spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of symbolic message names to ignore for Mixin members.
+ignored-checks-for-mixins=no-member,
+ not-async-context-manager,
+ not-context-manager,
+ attribute-defined-outside-init
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# Regex pattern to define which classes are considered mixins.
+mixin-class-rgx=.*[Mm]ixin
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of names allowed to shadow builtins
+allowed-redefined-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+ _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
diff --git a/custom_nodes/rgthree-comfy/.style.yapf b/custom_nodes/rgthree-comfy/.style.yapf
new file mode 100644
index 0000000000000000000000000000000000000000..9657de3ba37be527405ffcf40e4ed5546ddf79ea
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/.style.yapf
@@ -0,0 +1,11 @@
+# https://github.com/google/yapf
+[style]
+based_on_style = google
+INDENT_WIDTH = 2
+CONTINUATION_INDENT_WIDTH = 2
+COLUMN_LIMIT = 100
+DISABLE_ENDING_COMMA_HEURISTIC = true
+DEDENT_CLOSING_BRACKETS = true
+FORCE_MULTILINE_DICT = false
+coalesce_brackets=True
+ALLOW_SPLIT_BEFORE_DICT_VALUE = false
\ No newline at end of file
diff --git a/custom_nodes/rgthree-comfy/LICENSE b/custom_nodes/rgthree-comfy/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..5a4eb87c0791b74af3db40c2a4d362469a8b6b43
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Regis Gaughan, III (rgthree)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/custom_nodes/rgthree-comfy/README.md b/custom_nodes/rgthree-comfy/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..89034746925113a4d217c66949b519e1586f274f
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/README.md
@@ -0,0 +1,434 @@
+
+ rgthree-comfy
+
+ Making ComfyUI more comfortable!
+
+
+
+
+A collection of nodes and improvements created while messing around with ComfyUI. I made them for myself to make my workflow cleaner, easier, and faster. You're welcome to try them out. But remember, I made them for my own use cases :)
+
+
+
+# Get Started
+
+## Install
+
+1. Install the great [ComfyUi](https://github.com/comfyanonymous/ComfyUI).
+2. Clone this repo into `custom_modules`:
+ ```
+ cd ComfyUI/custom_nodes
+ git clone https://github.com/rgthree/rgthree-comfy.git
+ ```
+3. Start up ComfyUI.
+
+## Settings
+
+You can configure certain aspect of rgthree-comfy. For instance, perhaps a future ComfyUI change breaks rgthree-comfy, or you already have another extension that does something similar and you want to turn it off for rgthree-comfy.
+
+You can get to rgthree-settings by right-clicking on the empty part of the graph, and selecting `rgthree-comfy > Settings (rgthree-comfy)` or by clicking the `rgthree-comfy settings` in the ComfyUI settings dialog.
+
+_(Note, settings are stored in an `rgthree_config.json` in the `rgthree-comfy` directory. There are other advanced settings that can only be configured there; You can copy default settings from `rgthree_config.json.default` before `rgthree_config.json` before modifying)_.
+
+
+
+# ✴️ The Nodes
+
+Note, you can right-click on a bunch of the rgthree-comfy nodes and select `🛟 Node Help` menu item for in-app help when available.
+
+## Seed
+> An intuitive seed control node for ComfyUI that works very much like Automatic1111's seed control.
+>
+> ℹ️ See More Information
+>
+> - Set the seed value to "-1" to use a random seed every time
+> - Set any other number in there to use as a static/fixed seed
+> - Quick actions to randomize, or (re-)use the last queued seed.
+> - Images metadata will store the seed value _(so dragging an image in, will have the seed field already fixed to its seed)_.
+> - _Secret Features_: You can manually set the seed value to "-2" or "-3" to increment or decrement the last seed value. If there was not last seed value, it will randomly use on first.
+>
+> 
+>
+
+
+## Reroute
+> Keep your workflow neat with this much improved Reroute node with, like, actual rerouting with multiple directions and sizes.
+>
+> ℹ️ More Information
+>
+> - Use the right-click context menu to change the width, height and connection layout
+> - Also toggle resizability (min size is 40x43 if resizing though), and title/type display.
+>
+> 
+>
+
+## Bookmark (🔖)
+> Place the bookmark node anywhere on screen to quickly navigate to that with a shortcut key.
+>
+> ℹ️ See More Information
+>
+> - Define the `shortcut_key` to press to go right to that bookmark node, anchored in the top left.
+> - You can also define the zoom level as well!
+> - Pro tip: `shortcut_key` can be multiple keys. For instance "alt + shift + !" would require
+> pressing the alt key, the shift key, and the "!" (as in the "1" key, but with shift pressed)
+> in order to trigger.
+>
+
+
+## Context / Context Big
+> Pass along in general flow properties, and merge in new data. Similar to some other node suites "pipes" but easier merging, is more easily interoperable with standard nodes by both combining and exploding all in a single node.
+>
+> ℹ️ More Information
+>
+> - Context and Context Big are backwards compatible with each other. That is, an input connected to a Context Big will be passed through the CONTEXT outputs through normal Context nodes and available as an output on either (or, Context Big if the output is only on that node, like "steps").
+> - Pro Tip: When dragging a Context output over a nother node, hold down "ctrl" and release to automatically connect the other Context outputs to the hovered node.
+> - Pro Tip: You can change between Context and Context Big nodes from the menu.
+>
+> 
+>
+
+## Image Comparer
+> The Image Comparer node compares two images on top of each other.
+>
+> ℹ️ More Information
+>
+> - **Note:** The right-click menu may show image options (Open Image, Save Image, etc.) which will correspond to the first image (image_a) if clicked on the left-half of the node, or the second image if on the right half of the node.
+> - **Inputs:**
+> - `image_a` _Required._ The first image to use to compare. If image_b is not supplied and image_a is a batch, the comparer will use the first two images of image_a.
+> - `image_b` _Optional._ The second image to use to compare. Optional only if image_a is a batch with two images.
+> - **Properties:** You can change the following properties (by right-clicking on the node, and select "Properties" or "Properties Panel" from the menu):
+> - `comparer_mode` - Choose between "Slide" and "Click". Defaults to "Slide".
+
+
+## Image Inset Crop
+> The node that lets you crop an input image by either pixel value, or percentage value.
+
+
+## Display Any
+> Displays most any piece of text data from the backend _after execution_.
+
+## Power Lora Loader
+> A super-simply Lora Loader node that can load multiple Loras at once, and quick toggle each, all in an ultra-condensed node.
+>
+> ℹ️ More Information
+>
+> - Add as many Lora's as you would like by clicking the "+ Add Lora" button. There's no real limit!
+> - Right-click on a Lora widget for special options to move the lora up or down
+> _(no affect on image, just presentation)_, toggle it on/off, or delete the row all together.
+> - from the properties, change the `Show Strengths` to choose between showing a single, simple
+> strength value (which will be used for both model and clip), or a more advanced view with
+> both model and clip strengths being modifiable.
+>
+
+
+## ~~Lora Loader Stack~~
+> _**Deprecated.** Used the `Power Lora Loader` instead._
+>
+> A simplified Lora Loader stack. Much like other suites, but more interoperable with standard inputs/outputs.
+
+
+## Power Prompt
+> Power up your prompt and get drop downs for adding your embeddings, loras, and even have saved prompt snippets.
+>
+> ℹ️ More Information
+>
+> - At the core, you can use Power Prompt almost as a String Primitive node with additional features of dropdowns for choosing your embeddings, and even loras, with no further processing. This will output just the raw `TEXT` to another node for any lora processing, CLIP Encoding, etc.
+> - Connect a `CLIP` to the input to encode the text, with both the `CLIP` and `CONDITIONING` output right from the node.
+> - Connect a `MODEL` to the input to parse and load any `` tags in the text automatically, without
+> needing a separate Lora Loaders
+>
+
+## Power Prompt - Simple
+> Same as Power Prompt above, but without LORA support; made for a slightly cleaner negative prompt _(since negative prompts do not support loras)_.
+
+## SDXL Power Prompt - Positive
+> The SDXL sibling to the Power Prompt above. It contains the text_g and text_l as separate text inputs, as well a couple more input slots necessary to ensure proper clipe encoding. Combine with
+
+## SDXL Power Prompt - Simple
+> Like the non-SDXL `Power Prompt - Simple` node, this one is essentially the same as the SDXL Power Prompt but without lora support for either non-lora positive prompts or SDXL negative prompts _(since negative prompts do not support loras)_.
+
+## SDXL Config
+> Just some configuration fields for SDXL prompting. Honestly, could be used for non SDXL too.
+
+## Context Switch / Context Switch Big
+> A powerful node to branch your workflow. Works by choosing the first Context input that is not null/empty.
+>
+> ℹ️ More Information
+>
+> - Pass in several context nodes and the Context Switch will automatically choose the first non-null context to continue onward with.
+> - Wondering how to toggle contexts to null? Use in conjuction with the **Fast Muter** or **Fast Groups Muter**
+>
+>
+
+## Any Switch
+> A powerful node to similar to the Context Switch above, that chooses the first input that is not null/empty.
+>
+> ℹ️ More Information
+>
+> - Pass in several inmputs of the same type and the Any Switch will automatically choose the first non-null value to continue onward with.
+> - Wondering how to toggle contexts to null? Use in conjuction with the **Fast Muter** or **Fast Groups Muter**
+>
+>
+
+
+## Power Primitive
+> A single node that can output primitives (STRING, INT, FLOAT, BOOLEAN). If connecting an input, it will cast/convert the primitive input to the desired output.
+>
+> ℹ️ More Information
+>
+> - You can hide the type selector input from the right-click menu or properties.
+> - You can also fast-switch the output type from the right-click menu as well.
+>
+>
+
+
+## Power Puter
+> A powerful and versatile node that opens the door for a wide range of utility by offering mult-line code parsing for output. This node can be used for simple string concatenation, or math operations; to an image dimension or a node's widgets with advanced list comprehension. If you want to output something in your workflow, this is the node to do it.
+>
+> Additional documentation available in the [wiki](https://github.com/rgthree/rgthree-comfy/wiki/Node:-Power-Puter)
+>
+> ℹ️ More Information
+>
+> - Evaluate almost any kind of input and more, and choose your output from INT, FLOAT, STRING, or BOOLEAN.
+> - Connect some nodes and do simply math operations like `a + b` or `ceil(1 / 2)`.
+> - Or do more advanced things, like input an image, and get the width like `a.shape[2]`.
+> - Even more powerful, you can target nodes in the prompt that's sent to the backend. For instance; if you have a Power Lora Loader node at id #5, and want to get a comma-delimited list of the enabled loras, you could enter:
+>
+> ```
+> loras = [v.lora for v in node(5).inputs.values() if 'lora' in v and v.on]
+> ', '.join(loras)
+> ```
+>
+>
+
+## Fast Groups Muter
+> The Fast Groups Muter is an input-less node that automatically collects all groups in your current workflow and allows you to quickly mute and unmute all nodes within the group.
+>
+> ℹ️ More Information
+>
+> - Groups will automatically be shown, though you can filter, sort and more from the **node Properties** _(by right-clicking on the node, and select "Properties" or "Properties Panel" from the menu)_. Properties include:
+> - `matchColors` - Only add groups that match the provided colors. Can be ComfyUI colors (red, pale_blue) or hex codes (#a4d399). Multiple can be added, comma delimited.
+> - `matchTitle` - Filter the list of toggles by title match (string match, or regular expression).
+> - `showNav` - Add / remove a quick navigation arrow to take you to the group. (default: true)
+> - `showAllGraphs` - Show groups from all [sub]graphs in the workflow. (default: true)
+> - `sort` - Sort the toggles' order by "alphanumeric", graph "position", or "custom alphabet". (default: "position")
+> - `customSortAlphabet` - When the sort property is "custom alphabet" you can define the alphabet to use here, which will match the beginning of each group name and sort against it. If group titles do not match any custom alphabet entry, then they will be put after groups that do, ordered alphanumerically.
+>
+> This can be a list of single characters, like "zyxw..." or comma delimited strings for more control, like "sdxl,pro,sd,n,p".
+>
+> Note, when two group title match the same custom alphabet entry, the normal alphanumeric alphabet breaks the tie. For instance, a custom alphabet of "e,s,d" will order groups names like "SDXL, SEGS, Detailer" eventhough the custom alphabet has an "e" before "d" (where one may expect "SE" to be before "SD").
+>
+> To have "SEGS" appear before "SDXL" you can use longer strings. For instance, the custom alphabet value of "se,s,f" would work here.
+> - `toggleRestriction` - Optionally, attempt to restrict the number of widgets that can be enabled to a maximum of one, or always one.
+>
+> _Note: If using "max one" or "always one" then this is only enforced when clicking a toggle on this node; if nodes within groups are changed outside of the initial toggle click, then these restriction will not be enforced, and could result in a state where more than one toggle is enabled. This could also happen if nodes are overlapped with multiple groups._
+>
+
+## Fast Groups Bypasser
+> _Same as **Fast Groups Muter** above, but sets the connected nodes to "Bypass" instead of "Mute"_
+
+
+## Fast Muter
+> A powerful 'control panel' node to quickly toggle connected nodes allowing them to quickly be muted or enabled
+>
+> ℹ️ More Information
+>
+> - Add a collection of all connected nodes allowing a single-spot as a "dashboard" to quickly enable and disable nodes. Two distinct nodes; one for "Muting" connected nodes, and one for "Bypassing" connected nodes.
+>
+
+
+## Fast Bypasser
+> Same as Fast Muter but sets the connected nodes to "Bypass"
+
+## Fast Actions Button
+> Oh boy, this node allows you to semi-automate connected nodes and/or ConfyUI.
+>
+> ℹ️ More Information
+>
+> - Connect nodes and, at the least, mute, bypass or enable them when the button is pressed.
+> - Certain nodes expose additional actions. For instance, the `Seed` node you can set `Randomize Each Time` or `Use Last Queued Seed` when the button is pressed.
+> - Also, from the node properties, set a shortcut key to toggle the button actions, without needing a click!
+>
+
+
+## Node Collector
+> Used to cleanup noodles, this will accept any number of input nodes and passes it along to another node.
+>
+> ⚠️ *Currently, this should really only be connected to **Fast Muter**, **Fast Bypasser**, or **Mute / Bypass Relay**.*
+
+
+## Mute / Bypass Repeater
+> A powerful node that will dispatch its Mute/Bypass/Active mode to all connected input nodes or, if in a group w/o any connected inputs, will dispatch its Mute/Bypass/Active mode to all nodes in that group.
+>
+> ℹ️ More Information
+>
+> - 💡 Pro Tip #1: Connect this node's output to a **Fast Muter** or **Fast Bypasser** to have a single toggle there that can mute/bypass/enable many nodes with one click.
+>
+> - 💡 Pro Tip #2: Connect a **Mute / Bypass Relay** node to this node's inputs to have the relay automatically dispatch a mute/bypass/enable change to the repeater.
+>
+
+
+## Mute / Bypass Relay
+> An advanced node that, when working with a **Mute / Bypass Repeater**, will relay its input nodes'
+> modes (Mute, Bypass, or Active) to a connected repeater (which would then repeat that mode change
+> to all of its inputs).
+>
+> ℹ️ More Information
+>
+> - When all connected input nodes are muted, the relay will set a connected repeater to mute (by
+> default).
+> - When all connected input nodes are bypassed, the relay will set a connected repeater to
+> bypass (by default).
+> - When _any_ connected input nodes are active, the relay will set a connected repeater to
+> active (by default).
+> - **Note:** If no inputs are connected, the relay will set a connected repeater to its mode
+> _when its own mode is changed_. **Note**, if any inputs are connected, then the above bullets
+> will occur and the Relay's mode does not matter.
+> - **Pro Tip:** You can change which signals get sent on the above in the `Properties`.
+> 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.
+>
+
+
+## Random Unmuter
+> An advanced node used to unmute one of its inputs randomly when the graph is queued (and, immediately mute it back).
+>
+> ℹ️ More Information
+>
+> - **Note:** All input nodes MUST be muted to start; if not this node will not randomly unmute another. (This is powerful, as the generated image can be dragged in and the chosen input will already by unmuted and work w/o any further action.)
+> - **Tip:** Connect a Repeater's output to this nodes input and place that Repeater on a group without any other inputs, and it will mute/unmute the entire group.
+>
+
+
+## Label
+> A purely visual node, this allows you to add a floating label to your workflow.
+>
+> ℹ️ More Information
+>
+> - The text shown is the "Title" of the node and you can adjust the the font size, font family,
+> font color, text alignment as well as a background color, padding, background border
+> radius, and angle (in degrees) from the node's properties. You can double-click the node to
+> open the properties panel.
+> - The Title also supports the literal sequence "\\n" to insert a newline when drawing the label.
+> - ~**Pro Tip #1:** You can add multiline text from the properties panel _(because ComfyUI let's
+> you shift + enter there, only)._~
+> - **Pro Tip #2:** You can use ComfyUI's native "pin" option in the right-click menu to make the
+> label stick to the workflow and clicks to "go through". You can right-click at any time to
+> unpin.
+> - **Pro Tip #3:** Color values are hexidecimal strings, like "#FFFFFF" for white, or "#660000"
+> for dark red. You can supply a 7th & 8th value (or 5th if using shorthand) to create a
+> transluscent color. For instance, "#FFFFFF88" is semi-transparent white.
+>
+
+
+# Advanced Techniques
+
+## First, a word on muting
+
+A lot of the power of these nodes comes from *Muting*. Muting is the basis of correctly implementing multiple paths for a workflow utlizing the Context Switch node.
+
+While other extensions may provide switches, they often get it wrong causing your workflow to do more work than is needed. While other switches may have a selector to choose which input to pass along, they don't stop the execution of the other inputs, which will result in wasted work. Instead, Context Switch works by choosing the first non-empty context to pass along and correctly Muting is one way to make a previous node empty, and causes no extra work to be done when set up correctly.
+
+### To understand muting, is to understand the graph flow
+
+Muting, and therefore using Switches, can often confuse people at first because it _feels_ like muting a node, or using a switch, should be able to stop or direct the _forward_ flow of the graph. However, this is not the case and, in fact, the graph actually starts working backwards.
+
+If you have a workflow that has a path like `... > Context > KSampler > VAE Decode > Save Image` it may initially _feel_ like you should be able to mute that first Context node and the graph would stop there when moving forward and skip the rest of that workflow.
+
+But you'll quickly find that will cause an error, becase the graph doesn't actually move forward. When a workflow is processed, it _first moves backwards_ starting at each "Output Node" (Preview Image, Save Image, even "Display String" etc.) and then walking backwards to all possible paths to get there.
+
+So, with that `... > Context > KSampler > VAE Decode > Save Image` example from above, we actually want to mute the `Save Image` node to stop this path. Once we do, since the output node is gone, none of these nodes will be run.
+
+Let's take a look at an example.
+
+### A powerful combination: Using Context, Context Switch, & Fast Muter
+
+
+
+1. Using the **Context Switch** (aqua colored in screenshot) feed context inputs in order of preference. In the workflow above, the `Upscale Out` context is first so, if that one is enabled, it will be chosen for the output. If not, the second input slot which comes from the context rerouted from above (before the Upscaler booth) will be chosen.
+
+ - Notice the `Upscale Preview` is _after_ the `Upscale Out` context node, using the image from it instead of the image from the upscale `VAE Decoder`. This is on purpose so, when we disable the `Upscale Out` context, none of the Upscaler nodes will run, saving precious GPU cycles. If we had the preview hooked up directly to the `VAE Decoder` the upscaler would always run to generate the preview, even if we had the `Upscale Out` context node disabled.
+
+2. We can now disable the `Upscale Out` context node by _muting_ it. Highlighting it and pressing `ctrl + m` will work. By doing so, it's output will be None, and it will not pass anthing onto the further nodes. In the diagram you can see the `Upscale Preview` is red, but that's OK; there are no actual errors to stop execution.
+
+3. Now, let's hook it up to the `Fast Muter` node. `The Fast Muter` node works as dashboard by adding quick toggles for any connected node (ignoring reroutes). In the diagram, we have both the `Upscaler Out` context node, and the `Save File` context node hooked up. So, we can quickly enable and disable those.
+
+ - The workflow seen here would be a common one where we can generate a handful of base previews cheaply with a random seed, and then choose one to upscale and save to disk.
+
+4. Lastly, and optionally, you can see the `Node Collector`. Use it to clean up noodles if you want and connect it to the muter. You can connect anything to it, but doing so may break your workflow's execution.
+
+
+
+# ⚡ Improvements & Features
+
+rgthree-comfy adds several improvements, features, and optimizations to ComfyUI that are not directly tied to nodes.
+
+## Progress Bar
+> A minimal progress bar that run alongs the top of the app window that shows the queue size, the current progress of the a prompt execution (within the same window), and the progress of multi-step nodes as well.
+>
+> You can remove/enable from rgthree-comfy settings, as well as configure the height/size.
+
+
+## ~~ComfyUI Recursive Optimization~~
+> 🎉 The newest version of ComfyUI no longer suffers from poor execution recursion! This feature
+> has been removed from rgthree-comfy.
+
+
+## "Queue Selected Output Nodes" in right-click menu
+> Sometimes you want to just queue one or two paths to specific output node(s) without executing the entire workflow. Well, now you can do just that by right-clicking on an output node and selecting `Queue Selected Output Nodes (rgthree)`.
+>
+>
+> ℹ️ More Information
+>
+> - Select the _output_ nodes you want to execute.
+>
+> - Note: Only output nodes are captured and traversed, not all selected nodes. So if you select an output AND a node from a different path, only the path connected to the output will be executed and not non-output nodes, even if they were selected.
+>
+> - Note: The whole workflow is serialized, and then we trim what we don't want for the backend. So things like all seed random/increment/decrement will run even if that node isn't being sent in the end, etc.
+>
+>
+
+
+## Auto-Nest Subdirectories in long Combos
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Automatically detect top-level subdirectories in long combo lists (like, Load Checkpoint) and break out into sub directories.
+
+
+## Quick Mute/Bypass Toggles in Group Headers
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Adds a mute and/or bypass toggle icons in the top-right of Group Headers for one-click toggling of groups you may be currently looking at.
+
+
+## Import Individual Node Widgets (Drag & Drop)
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Allows dragging and dropping an image/JSON workflow from a previous generation and overriding the same node's widgets
+> (that match with the same id & type). This is useful if you have several generations using the same general workflow
+> and would like to import just some data, like a previous generation's seed, or prompt, etc.
+
+
+
+## "Copy Image" in right-click menu
+> Right clicking on a node that has an image should have a context-menu item of "Copy Image" will allow you to copy the image right to your clipboard
+>
+> 🎓 I believe this has graduated, with ComfyUI recently adding this setting too. You won't get two menu items; my code checks that there isn't already a "Copy Image" item there before adding it.
+
+
+## Other/Smaller Fixes
+- Fixed the width of ultra-wide node chooser on double click.
+- Fixed z-indexes for textareas that would overlap above other elements, like Properties Panel, or @pythongosssss's image viewer.
+- Check for bad links when loading a workflow and log to console, by default. _(See Link Fixer below)._
+
+
+
+# 📄 Link Fixer
+
+If your workflows sometimes have missing connections, or even errors on load, start up ComfyUI and go to http://127.0.0.1:8188/rgthree/link_fixer which will allow you to drop in an image or workflow json file and check for and fix any bad links.
+
+You can also enable a link fixer check in the rgthree-comfy settings to give you an alert if you load a workflow with bad linking data to start.
diff --git a/custom_nodes/rgthree-comfy/__build__.py b/custom_nodes/rgthree-comfy/__build__.py
new file mode 100644
index 0000000000000000000000000000000000000000..32b78d04df69d9f1502b517f5695867628a61c85
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/__build__.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+
+import subprocess
+import os
+from shutil import rmtree, copytree, ignore_patterns
+from glob import glob
+import time
+import re
+import argparse
+
+from py.log import COLORS
+from py.config import RGTHREE_CONFIG
+
+step_msg = ''
+step_start = 0
+step_infos = []
+
+def log_step(msg=None, status=None):
+ """ Logs a step keeping track of timing and initial msg. """
+ global step_msg # pylint: disable=W0601
+ global step_start # pylint: disable=W0601
+ global step_infos # pylint: disable=W0601
+ if msg:
+ tag = f'{COLORS["YELLOW"]}[ Notice ]' if status == 'Notice' else f'{COLORS["RESET"]}[Starting]'
+ step_msg = f'▻ {tag}{COLORS["RESET"]} {msg}...'
+ step_start = time.time()
+ step_infos = []
+ print(step_msg, end="\r")
+ elif status:
+ if status != 'Error':
+ warnings = [w for w in step_infos if w["type"] == 'warn']
+ status = "Warn" if warnings else status
+ step_time = round(time.time() - step_start, 3)
+ if status == 'Error':
+ status_msg = f'{COLORS["RED"]}⤫ {status}{COLORS["RESET"]}'
+ elif status == 'Warn':
+ status_msg = f'{COLORS["YELLOW"]}! {status}{COLORS["RESET"]}'
+ else:
+ status_msg = f'{COLORS["BRIGHT_GREEN"]}🗸 {status}{COLORS["RESET"]}'
+ print(f'{step_msg.ljust(64, ".")} {status_msg} ({step_time}s)')
+ for info in step_infos:
+ print(info["msg"])
+
+def log_step_info(msg:str, status='info'):
+ global step_infos # pylint: disable=W0601
+ step_infos.append({"msg": f' - {msg}', "type": status})
+
+
+def build(without_tests = True, fix = False):
+
+ THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+ DIR_SRC_WEB = os.path.abspath(f'{THIS_DIR}/src_web/')
+ DIR_WEB = os.path.abspath(f'{THIS_DIR}/web/')
+ DIR_WEB_COMFYUI = os.path.abspath(f'{DIR_WEB}/comfyui/')
+
+ if fix:
+ tss = glob(os.path.join(DIR_SRC_WEB, "**", "*.ts"), recursive=True)
+ log_step(msg=f'Fixing {len(tss)} ts files')
+ for ts in tss:
+ with open(ts, 'r', encoding="utf-8") as f:
+ content = f.read()
+ # (\s*from\s*['"](?!.*[.]js['"]).*?)(['"];) in vscode.
+ content, n = re.subn(r'(\s*from [\'"](?!.*[.]js[\'"]).*?)([\'"];)', '\\1.js\\2', content)
+ if n > 0:
+ filename = os.path.basename(ts)
+ log_step_info(
+ f'{filename} has {n} import{"s" if n > 1 else ""} that do not end in ".js"', 'warn')
+ with open(ts, 'w', encoding="utf-8") as f:
+ f.write(content)
+ log_step(status="Done")
+
+ log_step(msg='Copying web directory')
+ rmtree(DIR_WEB)
+ copytree(DIR_SRC_WEB, DIR_WEB, ignore=ignore_patterns("typings*", "*.ts", "*.scss"))
+ log_step(status="Done")
+
+ ts_version_result = subprocess.run(["node", "./node_modules/typescript/bin/tsc", "-v"],
+ capture_output=True,
+ text=True,
+ check=True)
+ ts_version = re.sub(r'^.*Version\s*([\d\.]+).*', 'v\\1', ts_version_result.stdout, flags=re.DOTALL)
+
+ log_step(msg=f'TypeScript ({ts_version})')
+ checked = subprocess.run(["node", "./node_modules/typescript/bin/tsc"], check=True)
+ log_step(status="Done")
+
+ if not without_tests:
+ log_step(msg='Removing directories (KEEPING TESTING)', status="Notice")
+ else:
+ log_step(msg='Removing unneeded directories')
+ test_path = os.path.join(DIR_WEB, 'comfyui', 'tests')
+ if os.path.exists(test_path):
+ rmtree(test_path)
+ rmtree(os.path.join(DIR_WEB, 'comfyui', 'testing'))
+ # Always remove the dummy scripts_comfy directory
+ rmtree(os.path.join(DIR_WEB, 'scripts_comfy'))
+ log_step(status="Done")
+
+ scsss = glob(os.path.join(DIR_SRC_WEB, "**", "*.scss"), recursive=True)
+ log_step(msg=f'SASS for {len(scsss)} files')
+ scsss = [i.replace(THIS_DIR, '.') for i in scsss]
+ cmds = ["node", "./node_modules/sass/sass"]
+ for scss in scsss:
+ out = scss.replace('src_web', 'web').replace('.scss', '.css')
+ cmds.append(f'{scss}:{out}')
+ cmds.append('--no-source-map')
+ checked = subprocess.run(cmds, check=True)
+ log_step(status="Done")
+
+ # Handle the common directories. Because ComfyUI loads under /extensions/rgthree-comfy we can't
+ # easily share sources outside of the `DIR_WEB_COMFYUI` _and_ allow typescript to resolve them in
+ # src view, so we set the path in the tsconfig to map an import of "rgthree/common" to the
+ # "src_web/common" directory, but then need to rewrite the comfyui JS files to load from
+ # "../../rgthree/common" (which we map correctly in rgthree_server.py).
+ log_step(msg='Cleaning Imports')
+ js_files = glob(os.path.join(DIR_WEB, '**', '*.js'), recursive=True)
+ for file in js_files:
+ rel_path = file.replace(f'{DIR_WEB}/', "")
+ with open(file, 'r', encoding="utf-8") as f:
+ filedata = f.read()
+ num = rel_path.count(os.sep)
+ if rel_path.startswith('comfyui'):
+ filedata = re.sub(r'(from\s+["\'])rgthree/', f'\\1{"../" * (num + 1)}rgthree/', filedata)
+ filedata = re.sub(r'(from\s+["\'])scripts/', f'\\1{"../" * (num + 1)}scripts/', filedata)
+ # Dynamic Imports
+ filedata = re.sub(r'(import\(["\'])rgthree/', f'\\1{"../" * (num + 1)}rgthree/', filedata)
+ else:
+ filedata = re.sub(r'(from\s+["\'])rgthree/', f'\\1{"../" * num}', filedata)
+ filedata = re.sub(r'(from\s+["\'])scripts/', f'\\1{"../" * (num + 1)}scripts/', filedata)
+ # Dynamic Imports
+ filedata = re.sub(r'(import\(["\'])rgthree/', f'\\1{"../" * num}', filedata)
+
+ filedata, n = re.subn(r'(\s*from [\'"](?!.*[.]js[\'"]).*?)([\'"];)', '\\1.js\\2', filedata)
+ if n > 0:
+ filename = file.split('rgthree-comfy')[1]
+ log_step_info(
+ f'{filename} has {n} import{"s" if n > 1 else ""} that do not end in ".js"', 'warn')
+ with open(file, 'w', encoding="utf-8") as f:
+ f.write(filedata)
+ log_step(status="Done")
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("-t", "--no-tests", default=False, action="store_true")
+ parser.add_argument("-f", "--fix", default=False, action="store_true")
+ args = parser.parse_args()
+
+ start = time.time()
+ build(without_tests=args.no_tests, fix=args.fix)
+ print(f'Finished all in {round(time.time() - start, 3)}s')
diff --git a/custom_nodes/rgthree-comfy/__commit__.py b/custom_nodes/rgthree-comfy/__commit__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bab14170261566dca011e247765b4e5c86d8c2cb
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/__commit__.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+import subprocess
+import os
+import re
+import datetime
+import time
+import argparse
+
+from __build__ import build, log_step, log_step_info
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+_FILE_PY_PROJECT = os.path.join(_THIS_DIR, 'pyproject.toml')
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+ "-m", "--message", help="The git commit message", required=True, action="store", type=str
+)
+args = parser.parse_args()
+
+start = time.time()
+build()
+
+log_step(msg='Updating version in pyproject.toml')
+py_project = ''
+with open(_FILE_PY_PROJECT, "r", encoding='utf-8') as f:
+ py_project = f.read()
+
+version = re.search(r'^\s*version\s*=\s*"(.*?)"', py_project, flags=re.MULTILINE)
+version_old = version[1]
+
+now = datetime.datetime.now()
+version_new = version_old.split('.')
+version_new[-1] = f'{str(now.year)[2:]}{now.month:02}{now.day:02}{now.hour:02}{now.minute:02}'
+version_new = '.'.join(version_new)
+
+log_step_info(f'Updating from v{version_old} to v{version_new}')
+py_project = py_project.replace(version_old, version_new)
+with open(_FILE_PY_PROJECT, "w", encoding='utf-8') as f:
+ f.write(py_project)
+log_step(status="Done")
+
+log_step('Running git add')
+process = subprocess.Popen(['git', 'add', '.'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+stdout, stderr = process.communicate()
+log_step(status="Done")
+
+log_step('Running git commit')
+process = subprocess.Popen(['git', 'commit', '-a', '-v', '-m', args.message],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+stdout, stderr = process.communicate()
+log_step(status="Done")
+
+print(f'Finished all in {round(time.time() - start, 3)}s')
diff --git a/custom_nodes/rgthree-comfy/__init__.py b/custom_nodes/rgthree-comfy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..edf954cbbeafef1f99748e7927aa405ab73e3a1d
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/__init__.py
@@ -0,0 +1,126 @@
+"""
+@author: rgthree
+@title: Comfy Nodes
+@nickname: rgthree
+@description: A bunch of nodes I created that I also find useful.
+"""
+
+from glob import glob
+import json
+import os
+import shutil
+import re
+import random
+
+import execution
+
+from .py.log import log
+from .py.config import get_config_value
+from .py.server.rgthree_server import *
+
+from .py.context import RgthreeContext
+from .py.context_switch import RgthreeContextSwitch
+from .py.context_switch_big import RgthreeContextSwitchBig
+from .py.display_any import RgthreeDisplayAny, RgthreeDisplayInt
+from .py.lora_stack import RgthreeLoraLoaderStack
+from .py.seed import RgthreeSeed
+from .py.sdxl_empty_latent_image import RgthreeSDXLEmptyLatentImage
+from .py.power_prompt import RgthreePowerPrompt
+from .py.power_prompt_simple import RgthreePowerPromptSimple
+from .py.image_inset_crop import RgthreeImageInsetCrop
+from .py.context_big import RgthreeBigContext
+from .py.dynamic_context import RgthreeDynamicContext
+from .py.dynamic_context_switch import RgthreeDynamicContextSwitch
+from .py.ksampler_config import RgthreeKSamplerConfig
+from .py.sdxl_power_prompt_postive import RgthreeSDXLPowerPromptPositive
+from .py.sdxl_power_prompt_simple import RgthreeSDXLPowerPromptSimple
+from .py.any_switch import RgthreeAnySwitch
+from .py.context_merge import RgthreeContextMerge
+from .py.context_merge_big import RgthreeContextMergeBig
+from .py.image_comparer import RgthreeImageComparer
+from .py.power_lora_loader import RgthreePowerLoraLoader
+from .py.power_primitive import RgthreePowerPrimitive
+from .py.image_or_latent_size import RgthreeImageOrLatentSize
+from .py.image_resize import RgthreeImageResize
+from .py.power_puter import RgthreePowerPuter
+
+NODE_CLASS_MAPPINGS = {
+ RgthreeBigContext.NAME: RgthreeBigContext,
+ RgthreeContext.NAME: RgthreeContext,
+ RgthreeContextSwitch.NAME: RgthreeContextSwitch,
+ RgthreeContextSwitchBig.NAME: RgthreeContextSwitchBig,
+ RgthreeContextMerge.NAME: RgthreeContextMerge,
+ RgthreeContextMergeBig.NAME: RgthreeContextMergeBig,
+ RgthreeDisplayInt.NAME: RgthreeDisplayInt,
+ RgthreeDisplayAny.NAME: RgthreeDisplayAny,
+ RgthreeLoraLoaderStack.NAME: RgthreeLoraLoaderStack,
+ RgthreeSeed.NAME: RgthreeSeed,
+ RgthreeImageInsetCrop.NAME: RgthreeImageInsetCrop,
+ RgthreePowerPrompt.NAME: RgthreePowerPrompt,
+ RgthreePowerPromptSimple.NAME: RgthreePowerPromptSimple,
+ RgthreeKSamplerConfig.NAME: RgthreeKSamplerConfig,
+ RgthreeSDXLEmptyLatentImage.NAME: RgthreeSDXLEmptyLatentImage,
+ RgthreeSDXLPowerPromptPositive.NAME: RgthreeSDXLPowerPromptPositive,
+ RgthreeSDXLPowerPromptSimple.NAME: RgthreeSDXLPowerPromptSimple,
+ RgthreeAnySwitch.NAME: RgthreeAnySwitch,
+ RgthreeImageComparer.NAME: RgthreeImageComparer,
+ RgthreePowerLoraLoader.NAME: RgthreePowerLoraLoader,
+ RgthreePowerPrimitive.NAME: RgthreePowerPrimitive,
+ RgthreeImageOrLatentSize.NAME: RgthreeImageOrLatentSize,
+ RgthreeImageResize.NAME: RgthreeImageResize,
+ RgthreePowerPuter.NAME: RgthreePowerPuter,
+}
+
+if get_config_value('unreleased.dynamic_context.enabled') is True:
+ NODE_CLASS_MAPPINGS[RgthreeDynamicContext.NAME] = RgthreeDynamicContext
+ NODE_CLASS_MAPPINGS[RgthreeDynamicContextSwitch.NAME] = RgthreeDynamicContextSwitch
+
+# WEB_DIRECTORY is the comfyui nodes directory that ComfyUI will link and auto-load.
+WEB_DIRECTORY = "./web/comfyui"
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DIR_WEB = os.path.abspath(f'{THIS_DIR}/{WEB_DIRECTORY}')
+DIR_PY = os.path.abspath(f'{THIS_DIR}/py')
+
+# remove old directories
+OLD_DIRS = [
+ os.path.abspath(f'{THIS_DIR}/../../web/extensions/rgthree'),
+ os.path.abspath(f'{THIS_DIR}/../../web/extensions/rgthree-comfy'),
+]
+for old_dir in OLD_DIRS:
+ if os.path.exists(old_dir):
+ shutil.rmtree(old_dir)
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'WEB_DIRECTORY']
+
+NOT_NODES = ['constants', 'log', 'utils', 'rgthree', 'rgthree_server', 'image_clipbaord', 'config']
+
+nodes = []
+for file in glob(os.path.join(DIR_PY, '*.py')) + glob(os.path.join(DIR_WEB, '*.js')):
+ name = os.path.splitext(os.path.basename(file))[0]
+ if name in NOT_NODES or name in nodes:
+ continue
+ if name.startswith('_') or name.startswith('base') or 'utils' in name:
+ continue
+ nodes.append(name)
+ if name == 'display_any':
+ nodes.append('display_int')
+
+print()
+adjs = ['exciting', 'extraordinary', 'epic', 'fantastic', 'magnificent']
+log(f'Loaded {len(nodes)} {random.choice(adjs)} nodes. 🎉', color='BRIGHT_GREEN')
+print()
+
+if get_config_value('announcements.comfy-nodes-20.incompatible', True):
+ message = (
+ "ComfyUI's new Node 2.0 rendering may be incompatible with some rgthree-comfy nodes "
+ "and features, breaking some rendering as well as losing the ability to "
+ "access a node's properties (a vital part of many nodes). It also appears to run MUCH more "
+ "slowly spiking CPU usage and causing jankiness and unresponsiveness, especially with large "
+ "workflows. Personally I am not planning to use the new Nodes 2.0 and, unfortunately, am not "
+ "able to invest the time to investigate and overhaul rgthree-comfy where needed. "
+ "If you have issues when Nodes 2.0 is enabled, I'd urge you to switch it off as well and "
+ "join me in hoping ComfyUI is not planning to deprecate the existing, stable canvas rendering "
+ "all together.\n"
+ )
+ log(message, color='YELLOW', id='announcements.comfy-nodes-20.incompatible', at_most_secs=60)
diff --git a/custom_nodes/rgthree-comfy/__update_comfy__.py b/custom_nodes/rgthree-comfy/__update_comfy__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7c0062dcd26ea18bd6f9beb70aa2f0e7e55aa05
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/__update_comfy__.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+# A nicer output for git pulling custom nodes (and ComfyUI).
+# Quick shell version: ls | xargs -I % sh -c 'echo; echo %; git -C % pull'
+
+import os
+from subprocess import Popen, PIPE, STDOUT
+
+
+def pull_path(path, origin = None, restore = False):
+ if restore:
+ p = Popen(["git", "-C", path, "restore", "."], stdout=PIPE, stderr=STDOUT)
+ output, error = p.communicate()
+
+ args = ["git", "-C", path, "pull"]
+ if origin is not None:
+ args.append('origin')
+ args.append(origin)
+ p = Popen(args, stdout=PIPE, stderr=STDOUT)
+ output, error = p.communicate()
+ return output.decode()
+
+THIS_DIR=os.path.dirname(os.path.abspath(__file__))
+
+def show_output(output):
+ if 'Already up to date' in output:
+ print(f' \33[32m🗸 Already up to date\33[0m', end ='')
+ elif output.startswith('error:'):
+ print(f' \33[31m🞫 Error.\33[0m \n {output}')
+ else:
+ print(f' \33[33m🡅 Needs update.\33[0m \n {output}', end='')
+
+
+os.chdir(THIS_DIR)
+os.chdir("../")
+
+# Get the list or custom nodes, so we can format the output a little more nicely.
+custom_extensions = []
+custom_extensions_name_max = 0
+for directory in os.listdir(os.getcwd()):
+ if os.path.isdir(directory) and directory != "__pycache__": #and directory != "rgthree-comfy" :
+ custom_extensions.append({
+ 'directory': directory
+ })
+ if len(directory) > custom_extensions_name_max:
+ custom_extensions_name_max = len(directory)
+
+if len(custom_extensions) == 0:
+ custom_extensions_name_max = 15
+else:
+ custom_extensions_name_max += 6
+
+# Update ComfyUI itself.
+label = "{0:.<{max}}".format('Updating ComfyUI ', max=custom_extensions_name_max)
+print(label, end = '')
+show_output(pull_path('../', origin='master', restore=True))
+
+# If we have custom nodes, update them as well.
+if len(custom_extensions) > 0:
+ print(f'\nUpdating custom_nodes ({len(custom_extensions)}):')
+ for custom_extension in custom_extensions:
+ directory = custom_extension['directory']
+ label = "{0:.<{max}}".format(f'🗀 {directory} ', max=custom_extensions_name_max)
+ print(label, end = '')
+ show_output(pull_path(directory))
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_advanced.png b/custom_nodes/rgthree-comfy/docs/rgthree_advanced.png
new file mode 100644
index 0000000000000000000000000000000000000000..49d85226499c791db835ddc5b5fd91c6621b8c70
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/docs/rgthree_advanced.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77d88a50847fa76d95a1470bf0315b035a06e3c87a8d4e8132d49d8d5b8a31ce
+size 455664
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_advanced_metadata.png b/custom_nodes/rgthree-comfy/docs/rgthree_advanced_metadata.png
new file mode 100644
index 0000000000000000000000000000000000000000..90aedcf8107dcadcd59519896af8bad9ae4399fa
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/docs/rgthree_advanced_metadata.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c33be251bd628225b9e29249b766b45539a62a9f94f2e0085b10c469f5ef0956
+size 491188
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_context.png b/custom_nodes/rgthree-comfy/docs/rgthree_context.png
new file mode 100644
index 0000000000000000000000000000000000000000..583922074a628160d4d82f667fd0df54961f2a56
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/docs/rgthree_context.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d7c4401b0f4b6958d75b9eca531b0c16d8eeb121f3ec8092ccf1336966c43cd
+size 544154
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_context_metadata.png b/custom_nodes/rgthree-comfy/docs/rgthree_context_metadata.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc9ee9116fd3f12848db064e5c4967743752d6ab
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/docs/rgthree_context_metadata.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f89ef9decfee6b65831780a85235f6bfedd99ff1f16eaaf0567a17d94997ba7
+size 1689098
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_router.png b/custom_nodes/rgthree-comfy/docs/rgthree_router.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3581d708f98c6352dfcc414ac0bd81f2eb2fc59
Binary files /dev/null and b/custom_nodes/rgthree-comfy/docs/rgthree_router.png differ
diff --git a/custom_nodes/rgthree-comfy/docs/rgthree_seed.png b/custom_nodes/rgthree-comfy/docs/rgthree_seed.png
new file mode 100644
index 0000000000000000000000000000000000000000..32c392fbccf38f7e0d150cbeed0cc9066f8ac610
Binary files /dev/null and b/custom_nodes/rgthree-comfy/docs/rgthree_seed.png differ
diff --git a/custom_nodes/rgthree-comfy/package-lock.json b/custom_nodes/rgthree-comfy/package-lock.json
new file mode 100644
index 0000000000000000000000000000000000000000..ccb4fd2758dfd8ea0b2165078a270f3c5bb9b4cb
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/package-lock.json
@@ -0,0 +1,568 @@
+{
+ "name": "rgthree-comfy",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "devDependencies": {
+ "@comfyorg/comfyui-frontend-types": "^1.32.4",
+ "prettier": "^3.3.3",
+ "sass": "^1.77.8",
+ "typescript": "^5.5.4",
+ "web-tree-sitter": "0.25.6"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.25.9",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+ "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+ "dev": true,
+ "peer": true,
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.25.9",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+ "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+ "dev": true,
+ "peer": true,
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.27.0",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
+ "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@babel/types": "^7.27.0"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.27.0",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
+ "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.25.9",
+ "@babel/helper-validator-identifier": "^7.25.9"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@comfyorg/comfyui-frontend-types": {
+ "version": "1.32.4",
+ "resolved": "https://registry.npmjs.org/@comfyorg/comfyui-frontend-types/-/comfyui-frontend-types-1.32.4.tgz",
+ "integrity": "sha512-9EBFwQPaSMLI151caWN5nA0qVmY5S9BR9lHP5NboPnTsmkFwnWdrAPadAnafwmZcK40ZWntKJZxO0Uuju0jw/w==",
+ "dev": true,
+ "peerDependencies": {
+ "vue": "^3.5.13",
+ "zod": "^3.23.8"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+ "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+ "dev": true,
+ "peer": true
+ },
+ "node_modules/@vue/compiler-core": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz",
+ "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@babel/parser": "^7.25.3",
+ "@vue/shared": "3.5.13",
+ "entities": "^4.5.0",
+ "estree-walker": "^2.0.2",
+ "source-map-js": "^1.2.0"
+ }
+ },
+ "node_modules/@vue/compiler-dom": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz",
+ "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/compiler-core": "3.5.13",
+ "@vue/shared": "3.5.13"
+ }
+ },
+ "node_modules/@vue/compiler-sfc": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz",
+ "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@babel/parser": "^7.25.3",
+ "@vue/compiler-core": "3.5.13",
+ "@vue/compiler-dom": "3.5.13",
+ "@vue/compiler-ssr": "3.5.13",
+ "@vue/shared": "3.5.13",
+ "estree-walker": "^2.0.2",
+ "magic-string": "^0.30.11",
+ "postcss": "^8.4.48",
+ "source-map-js": "^1.2.0"
+ }
+ },
+ "node_modules/@vue/compiler-ssr": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz",
+ "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/compiler-dom": "3.5.13",
+ "@vue/shared": "3.5.13"
+ }
+ },
+ "node_modules/@vue/reactivity": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz",
+ "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/shared": "3.5.13"
+ }
+ },
+ "node_modules/@vue/runtime-core": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz",
+ "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/reactivity": "3.5.13",
+ "@vue/shared": "3.5.13"
+ }
+ },
+ "node_modules/@vue/runtime-dom": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz",
+ "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/reactivity": "3.5.13",
+ "@vue/runtime-core": "3.5.13",
+ "@vue/shared": "3.5.13",
+ "csstype": "^3.1.3"
+ }
+ },
+ "node_modules/@vue/server-renderer": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz",
+ "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/compiler-ssr": "3.5.13",
+ "@vue/shared": "3.5.13"
+ },
+ "peerDependencies": {
+ "vue": "3.5.13"
+ }
+ },
+ "node_modules/@vue/shared": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz",
+ "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==",
+ "dev": true,
+ "peer": true
+ },
+ "node_modules/anymatch": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+ "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+ "dev": true,
+ "dependencies": {
+ "normalize-path": "^3.0.0",
+ "picomatch": "^2.0.4"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/binary-extensions": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+ "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+ "dev": true,
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/braces": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+ "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+ "dev": true,
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/chokidar": {
+ "version": "3.5.3",
+ "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+ "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://paulmillr.com/funding/"
+ }
+ ],
+ "dependencies": {
+ "anymatch": "~3.1.2",
+ "braces": "~3.0.2",
+ "glob-parent": "~5.1.2",
+ "is-binary-path": "~2.1.0",
+ "is-glob": "~4.0.1",
+ "normalize-path": "~3.0.0",
+ "readdirp": "~3.6.0"
+ },
+ "engines": {
+ "node": ">= 8.10.0"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/csstype": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+ "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+ "dev": true,
+ "peer": true
+ },
+ "node_modules/entities": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+ "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+ "dev": true,
+ "peer": true,
+ "engines": {
+ "node": ">=0.12"
+ },
+ "funding": {
+ "url": "https://github.com/fb55/entities?sponsor=1"
+ }
+ },
+ "node_modules/estree-walker": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+ "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+ "dev": true,
+ "peer": true
+ },
+ "node_modules/fill-range": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+ "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+ "dev": true,
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "dev": true,
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/immutable": {
+ "version": "4.3.5",
+ "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.5.tgz",
+ "integrity": "sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==",
+ "dev": true
+ },
+ "node_modules/is-binary-path": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+ "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+ "dev": true,
+ "dependencies": {
+ "binary-extensions": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "dev": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-glob": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+ "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+ "dev": true,
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "dev": true,
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/magic-string": {
+ "version": "0.30.17",
+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+ "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0"
+ }
+ },
+ "node_modules/nanoid": {
+ "version": "3.3.11",
+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+ "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "peer": true,
+ "bin": {
+ "nanoid": "bin/nanoid.cjs"
+ },
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ }
+ },
+ "node_modules/normalize-path": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+ "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+ "dev": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "dev": true,
+ "peer": true
+ },
+ "node_modules/picomatch": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+ "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+ "dev": true,
+ "engines": {
+ "node": ">=8.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/postcss": {
+ "version": "8.5.3",
+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
+ "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/postcss"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "peer": true,
+ "dependencies": {
+ "nanoid": "^3.3.8",
+ "picocolors": "^1.1.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ }
+ },
+ "node_modules/prettier": {
+ "version": "3.3.3",
+ "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.3.3.tgz",
+ "integrity": "sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==",
+ "dev": true,
+ "bin": {
+ "prettier": "bin/prettier.cjs"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "funding": {
+ "url": "https://github.com/prettier/prettier?sponsor=1"
+ }
+ },
+ "node_modules/readdirp": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+ "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+ "dev": true,
+ "dependencies": {
+ "picomatch": "^2.2.1"
+ },
+ "engines": {
+ "node": ">=8.10.0"
+ }
+ },
+ "node_modules/sass": {
+ "version": "1.77.8",
+ "resolved": "https://registry.npmjs.org/sass/-/sass-1.77.8.tgz",
+ "integrity": "sha512-4UHg6prsrycW20fqLGPShtEvo/WyHRVRHwOP4DzkUrObWoWI05QBSfzU71TVB7PFaL104TwNaHpjlWXAZbQiNQ==",
+ "dev": true,
+ "dependencies": {
+ "chokidar": ">=3.0.0 <4.0.0",
+ "immutable": "^4.0.0",
+ "source-map-js": ">=0.6.2 <2.0.0"
+ },
+ "bin": {
+ "sass": "sass.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/source-map-js": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+ "dev": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "dev": true,
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/typescript": {
+ "version": "5.9.2",
+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+ "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+ "dev": true,
+ "bin": {
+ "tsc": "bin/tsc",
+ "tsserver": "bin/tsserver"
+ },
+ "engines": {
+ "node": ">=14.17"
+ }
+ },
+ "node_modules/vue": {
+ "version": "3.5.13",
+ "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz",
+ "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==",
+ "dev": true,
+ "peer": true,
+ "dependencies": {
+ "@vue/compiler-dom": "3.5.13",
+ "@vue/compiler-sfc": "3.5.13",
+ "@vue/runtime-dom": "3.5.13",
+ "@vue/server-renderer": "3.5.13",
+ "@vue/shared": "3.5.13"
+ },
+ "peerDependencies": {
+ "typescript": "*"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/web-tree-sitter": {
+ "version": "0.25.6",
+ "resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.25.6.tgz",
+ "integrity": "sha512-WG+/YGbxw8r+rLlzzhV+OvgiOJCWdIpOucG3qBf3RCBFMkGDb1CanUi2BxCxjnkpzU3/hLWPT8VO5EKsMk9Fxg==",
+ "dev": true
+ },
+ "node_modules/zod": {
+ "version": "3.24.2",
+ "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
+ "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
+ "dev": true,
+ "peer": true,
+ "funding": {
+ "url": "https://github.com/sponsors/colinhacks"
+ }
+ }
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/package.json b/custom_nodes/rgthree-comfy/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..39fc9c3f0ef7f340e4d8bc03eb1153f835728919
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/package.json
@@ -0,0 +1,12 @@
+{
+ "devDependencies": {
+ "prettier": "^3.3.3",
+ "typescript": "^5.5.4",
+ "sass": "^1.77.8",
+ "@comfyorg/comfyui-frontend-types": "^1.32.4",
+ "web-tree-sitter": "0.25.6"
+ },
+ "scripts": {
+ "build": "./__build__.py || python .\\__build__.py"
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/pnpm-lock.yaml b/custom_nodes/rgthree-comfy/pnpm-lock.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d3ca55960ab786477934a5329aa9a9bd662daee5
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/pnpm-lock.yaml
@@ -0,0 +1,507 @@
+lockfileVersion: '9.0'
+
+settings:
+ autoInstallPeers: true
+ excludeLinksFromLockfile: false
+
+importers:
+
+ .:
+ devDependencies:
+ '@comfyorg/comfyui-frontend-types':
+ specifier: ^1.32.4
+ version: 1.32.4(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)
+ prettier:
+ specifier: ^3.3.3
+ version: 3.6.2
+ sass:
+ specifier: ^1.77.8
+ version: 1.93.3
+ typescript:
+ specifier: ^5.5.4
+ version: 5.9.3
+ web-tree-sitter:
+ specifier: 0.25.6
+ version: 0.25.6
+
+packages:
+
+ '@babel/helper-string-parser@7.27.1':
+ resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+ engines: {node: '>=6.9.0'}
+
+ '@babel/helper-validator-identifier@7.28.5':
+ resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+ engines: {node: '>=6.9.0'}
+
+ '@babel/parser@7.28.5':
+ resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
+ engines: {node: '>=6.0.0'}
+ hasBin: true
+
+ '@babel/types@7.28.5':
+ resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
+ engines: {node: '>=6.9.0'}
+
+ '@comfyorg/comfyui-frontend-types@1.32.4':
+ resolution: {integrity: sha512-9EBFwQPaSMLI151caWN5nA0qVmY5S9BR9lHP5NboPnTsmkFwnWdrAPadAnafwmZcK40ZWntKJZxO0Uuju0jw/w==}
+ peerDependencies:
+ vue: ^3.5.13
+ zod: ^3.23.8
+
+ '@jridgewell/sourcemap-codec@1.5.5':
+ resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+ '@parcel/watcher-android-arm64@2.5.1':
+ resolution: {integrity: sha512-KF8+j9nNbUN8vzOFDpRMsaKBHZ/mcjEjMToVMJOhTozkDonQFFrRcfdLWn6yWKCmJKmdVxSgHiYvTCef4/qcBA==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm64]
+ os: [android]
+
+ '@parcel/watcher-darwin-arm64@2.5.1':
+ resolution: {integrity: sha512-eAzPv5osDmZyBhou8PoF4i6RQXAfeKL9tjb3QzYuccXFMQU0ruIc/POh30ePnaOyD1UXdlKguHBmsTs53tVoPw==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm64]
+ os: [darwin]
+
+ '@parcel/watcher-darwin-x64@2.5.1':
+ resolution: {integrity: sha512-1ZXDthrnNmwv10A0/3AJNZ9JGlzrF82i3gNQcWOzd7nJ8aj+ILyW1MTxVk35Db0u91oD5Nlk9MBiujMlwmeXZg==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [x64]
+ os: [darwin]
+
+ '@parcel/watcher-freebsd-x64@2.5.1':
+ resolution: {integrity: sha512-SI4eljM7Flp9yPuKi8W0ird8TI/JK6CSxju3NojVI6BjHsTyK7zxA9urjVjEKJ5MBYC+bLmMcbAWlZ+rFkLpJQ==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [x64]
+ os: [freebsd]
+
+ '@parcel/watcher-linux-arm-glibc@2.5.1':
+ resolution: {integrity: sha512-RCdZlEyTs8geyBkkcnPWvtXLY44BCeZKmGYRtSgtwwnHR4dxfHRG3gR99XdMEdQ7KeiDdasJwwvNSF5jKtDwdA==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm]
+ os: [linux]
+
+ '@parcel/watcher-linux-arm-musl@2.5.1':
+ resolution: {integrity: sha512-6E+m/Mm1t1yhB8X412stiKFG3XykmgdIOqhjWj+VL8oHkKABfu/gjFj8DvLrYVHSBNC+/u5PeNrujiSQ1zwd1Q==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm]
+ os: [linux]
+
+ '@parcel/watcher-linux-arm64-glibc@2.5.1':
+ resolution: {integrity: sha512-LrGp+f02yU3BN9A+DGuY3v3bmnFUggAITBGriZHUREfNEzZh/GO06FF5u2kx8x+GBEUYfyTGamol4j3m9ANe8w==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm64]
+ os: [linux]
+
+ '@parcel/watcher-linux-arm64-musl@2.5.1':
+ resolution: {integrity: sha512-cFOjABi92pMYRXS7AcQv9/M1YuKRw8SZniCDw0ssQb/noPkRzA+HBDkwmyOJYp5wXcsTrhxO0zq1U11cK9jsFg==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm64]
+ os: [linux]
+
+ '@parcel/watcher-linux-x64-glibc@2.5.1':
+ resolution: {integrity: sha512-GcESn8NZySmfwlTsIur+49yDqSny2IhPeZfXunQi48DMugKeZ7uy1FX83pO0X22sHntJ4Ub+9k34XQCX+oHt2A==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [x64]
+ os: [linux]
+
+ '@parcel/watcher-linux-x64-musl@2.5.1':
+ resolution: {integrity: sha512-n0E2EQbatQ3bXhcH2D1XIAANAcTZkQICBPVaxMeaCVBtOpBZpWJuf7LwyWPSBDITb7In8mqQgJ7gH8CILCURXg==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [x64]
+ os: [linux]
+
+ '@parcel/watcher-win32-arm64@2.5.1':
+ resolution: {integrity: sha512-RFzklRvmc3PkjKjry3hLF9wD7ppR4AKcWNzH7kXR7GUe0Igb3Nz8fyPwtZCSquGrhU5HhUNDr/mKBqj7tqA2Vw==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [arm64]
+ os: [win32]
+
+ '@parcel/watcher-win32-ia32@2.5.1':
+ resolution: {integrity: sha512-c2KkcVN+NJmuA7CGlaGD1qJh1cLfDnQsHjE89E60vUEMlqduHGCdCLJCID5geFVM0dOtA3ZiIO8BoEQmzQVfpQ==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [ia32]
+ os: [win32]
+
+ '@parcel/watcher-win32-x64@2.5.1':
+ resolution: {integrity: sha512-9lHBdJITeNR++EvSQVUcaZoWupyHfXe1jZvGZ06O/5MflPcuPLtEphScIBL+AiCWBO46tDSHzWyD0uDmmZqsgA==}
+ engines: {node: '>= 10.0.0'}
+ cpu: [x64]
+ os: [win32]
+
+ '@parcel/watcher@2.5.1':
+ resolution: {integrity: sha512-dfUnCxiN9H4ap84DvD2ubjw+3vUNpstxa0TneY/Paat8a3R4uQZDLSvWjmznAY/DoahqTHl9V46HF/Zs3F29pg==}
+ engines: {node: '>= 10.0.0'}
+
+ '@vue/compiler-core@3.5.24':
+ resolution: {integrity: sha512-eDl5H57AOpNakGNAkFDH+y7kTqrQpJkZFXhWZQGyx/5Wh7B1uQYvcWkvZi11BDhscPgj8N7XV3oRwiPnx1Vrig==}
+
+ '@vue/compiler-dom@3.5.24':
+ resolution: {integrity: sha512-1QHGAvs53gXkWdd3ZMGYuvQFXHW4ksKWPG8HP8/2BscrbZ0brw183q2oNWjMrSWImYLHxHrx1ItBQr50I/q2zw==}
+
+ '@vue/compiler-sfc@3.5.24':
+ resolution: {integrity: sha512-8EG5YPRgmTB+YxYBM3VXy8zHD9SWHUJLIGPhDovo3Z8VOgvP+O7UP5vl0J4BBPWYD9vxtBabzW1EuEZ+Cqs14g==}
+
+ '@vue/compiler-ssr@3.5.24':
+ resolution: {integrity: sha512-trOvMWNBMQ/odMRHW7Ae1CdfYx+7MuiQu62Jtu36gMLXcaoqKvAyh+P73sYG9ll+6jLB6QPovqoKGGZROzkFFg==}
+
+ '@vue/reactivity@3.5.24':
+ resolution: {integrity: sha512-BM8kBhtlkkbnyl4q+HiF5R5BL0ycDPfihowulm02q3WYp2vxgPcJuZO866qa/0u3idbMntKEtVNuAUp5bw4teg==}
+
+ '@vue/runtime-core@3.5.24':
+ resolution: {integrity: sha512-RYP/byyKDgNIqfX/gNb2PB55dJmM97jc9wyF3jK7QUInYKypK2exmZMNwnjueWwGceEkP6NChd3D2ZVEp9undQ==}
+
+ '@vue/runtime-dom@3.5.24':
+ resolution: {integrity: sha512-Z8ANhr/i0XIluonHVjbUkjvn+CyrxbXRIxR7wn7+X7xlcb7dJsfITZbkVOeJZdP8VZwfrWRsWdShH6pngMxRjw==}
+
+ '@vue/server-renderer@3.5.24':
+ resolution: {integrity: sha512-Yh2j2Y4G/0/4z/xJ1Bad4mxaAk++C2v4kaa8oSYTMJBJ00/ndPuxCnWeot0/7/qafQFLh5pr6xeV6SdMcE/G1w==}
+ peerDependencies:
+ vue: 3.5.24
+
+ '@vue/shared@3.5.24':
+ resolution: {integrity: sha512-9cwHL2EsJBdi8NY22pngYYWzkTDhld6fAD6jlaeloNGciNSJL6bLpbxVgXl96X00Jtc6YWQv96YA/0sxex/k1A==}
+
+ braces@3.0.3:
+ resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+ engines: {node: '>=8'}
+
+ chokidar@4.0.3:
+ resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+ engines: {node: '>= 14.16.0'}
+
+ csstype@3.1.3:
+ resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+
+ detect-libc@1.0.3:
+ resolution: {integrity: sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg==}
+ engines: {node: '>=0.10'}
+ hasBin: true
+
+ entities@4.5.0:
+ resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+ engines: {node: '>=0.12'}
+
+ estree-walker@2.0.2:
+ resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
+
+ fill-range@7.1.1:
+ resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+ engines: {node: '>=8'}
+
+ immutable@5.1.4:
+ resolution: {integrity: sha512-p6u1bG3YSnINT5RQmx/yRZBpenIl30kVxkTLDyHLIMk0gict704Q9n+thfDI7lTRm9vXdDYutVzXhzcThxTnXA==}
+
+ is-extglob@2.1.1:
+ resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+ engines: {node: '>=0.10.0'}
+
+ is-glob@4.0.3:
+ resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+ engines: {node: '>=0.10.0'}
+
+ is-number@7.0.0:
+ resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+ engines: {node: '>=0.12.0'}
+
+ magic-string@0.30.21:
+ resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+ micromatch@4.0.8:
+ resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+ engines: {node: '>=8.6'}
+
+ nanoid@3.3.11:
+ resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+ engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+ hasBin: true
+
+ node-addon-api@7.1.1:
+ resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
+
+ picocolors@1.1.1:
+ resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+ picomatch@2.3.1:
+ resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+ engines: {node: '>=8.6'}
+
+ postcss@8.5.6:
+ resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+ engines: {node: ^10 || ^12 || >=14}
+
+ prettier@3.6.2:
+ resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==}
+ engines: {node: '>=14'}
+ hasBin: true
+
+ readdirp@4.1.2:
+ resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+ engines: {node: '>= 14.18.0'}
+
+ sass@1.93.3:
+ resolution: {integrity: sha512-elOcIZRTM76dvxNAjqYrucTSI0teAF/L2Lv0s6f6b7FOwcwIuA357bIE871580AjHJuSvLIRUosgV+lIWx6Rgg==}
+ engines: {node: '>=14.0.0'}
+ hasBin: true
+
+ source-map-js@1.2.1:
+ resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+ engines: {node: '>=0.10.0'}
+
+ to-regex-range@5.0.1:
+ resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+ engines: {node: '>=8.0'}
+
+ typescript@5.9.3:
+ resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+ engines: {node: '>=14.17'}
+ hasBin: true
+
+ vue@3.5.24:
+ resolution: {integrity: sha512-uTHDOpVQTMjcGgrqFPSb8iO2m1DUvo+WbGqoXQz8Y1CeBYQ0FXf2z1gLRaBtHjlRz7zZUBHxjVB5VTLzYkvftg==}
+ peerDependencies:
+ typescript: '*'
+ peerDependenciesMeta:
+ typescript:
+ optional: true
+
+ web-tree-sitter@0.25.6:
+ resolution: {integrity: sha512-WG+/YGbxw8r+rLlzzhV+OvgiOJCWdIpOucG3qBf3RCBFMkGDb1CanUi2BxCxjnkpzU3/hLWPT8VO5EKsMk9Fxg==}
+
+ zod@3.25.76:
+ resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+snapshots:
+
+ '@babel/helper-string-parser@7.27.1': {}
+
+ '@babel/helper-validator-identifier@7.28.5': {}
+
+ '@babel/parser@7.28.5':
+ dependencies:
+ '@babel/types': 7.28.5
+
+ '@babel/types@7.28.5':
+ dependencies:
+ '@babel/helper-string-parser': 7.27.1
+ '@babel/helper-validator-identifier': 7.28.5
+
+ '@comfyorg/comfyui-frontend-types@1.32.4(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)':
+ dependencies:
+ vue: 3.5.24(typescript@5.9.3)
+ zod: 3.25.76
+
+ '@jridgewell/sourcemap-codec@1.5.5': {}
+
+ '@parcel/watcher-android-arm64@2.5.1':
+ optional: true
+
+ '@parcel/watcher-darwin-arm64@2.5.1':
+ optional: true
+
+ '@parcel/watcher-darwin-x64@2.5.1':
+ optional: true
+
+ '@parcel/watcher-freebsd-x64@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-arm-glibc@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-arm-musl@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-arm64-glibc@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-arm64-musl@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-x64-glibc@2.5.1':
+ optional: true
+
+ '@parcel/watcher-linux-x64-musl@2.5.1':
+ optional: true
+
+ '@parcel/watcher-win32-arm64@2.5.1':
+ optional: true
+
+ '@parcel/watcher-win32-ia32@2.5.1':
+ optional: true
+
+ '@parcel/watcher-win32-x64@2.5.1':
+ optional: true
+
+ '@parcel/watcher@2.5.1':
+ dependencies:
+ detect-libc: 1.0.3
+ is-glob: 4.0.3
+ micromatch: 4.0.8
+ node-addon-api: 7.1.1
+ optionalDependencies:
+ '@parcel/watcher-android-arm64': 2.5.1
+ '@parcel/watcher-darwin-arm64': 2.5.1
+ '@parcel/watcher-darwin-x64': 2.5.1
+ '@parcel/watcher-freebsd-x64': 2.5.1
+ '@parcel/watcher-linux-arm-glibc': 2.5.1
+ '@parcel/watcher-linux-arm-musl': 2.5.1
+ '@parcel/watcher-linux-arm64-glibc': 2.5.1
+ '@parcel/watcher-linux-arm64-musl': 2.5.1
+ '@parcel/watcher-linux-x64-glibc': 2.5.1
+ '@parcel/watcher-linux-x64-musl': 2.5.1
+ '@parcel/watcher-win32-arm64': 2.5.1
+ '@parcel/watcher-win32-ia32': 2.5.1
+ '@parcel/watcher-win32-x64': 2.5.1
+ optional: true
+
+ '@vue/compiler-core@3.5.24':
+ dependencies:
+ '@babel/parser': 7.28.5
+ '@vue/shared': 3.5.24
+ entities: 4.5.0
+ estree-walker: 2.0.2
+ source-map-js: 1.2.1
+
+ '@vue/compiler-dom@3.5.24':
+ dependencies:
+ '@vue/compiler-core': 3.5.24
+ '@vue/shared': 3.5.24
+
+ '@vue/compiler-sfc@3.5.24':
+ dependencies:
+ '@babel/parser': 7.28.5
+ '@vue/compiler-core': 3.5.24
+ '@vue/compiler-dom': 3.5.24
+ '@vue/compiler-ssr': 3.5.24
+ '@vue/shared': 3.5.24
+ estree-walker: 2.0.2
+ magic-string: 0.30.21
+ postcss: 8.5.6
+ source-map-js: 1.2.1
+
+ '@vue/compiler-ssr@3.5.24':
+ dependencies:
+ '@vue/compiler-dom': 3.5.24
+ '@vue/shared': 3.5.24
+
+ '@vue/reactivity@3.5.24':
+ dependencies:
+ '@vue/shared': 3.5.24
+
+ '@vue/runtime-core@3.5.24':
+ dependencies:
+ '@vue/reactivity': 3.5.24
+ '@vue/shared': 3.5.24
+
+ '@vue/runtime-dom@3.5.24':
+ dependencies:
+ '@vue/reactivity': 3.5.24
+ '@vue/runtime-core': 3.5.24
+ '@vue/shared': 3.5.24
+ csstype: 3.1.3
+
+ '@vue/server-renderer@3.5.24(vue@3.5.24(typescript@5.9.3))':
+ dependencies:
+ '@vue/compiler-ssr': 3.5.24
+ '@vue/shared': 3.5.24
+ vue: 3.5.24(typescript@5.9.3)
+
+ '@vue/shared@3.5.24': {}
+
+ braces@3.0.3:
+ dependencies:
+ fill-range: 7.1.1
+ optional: true
+
+ chokidar@4.0.3:
+ dependencies:
+ readdirp: 4.1.2
+
+ csstype@3.1.3: {}
+
+ detect-libc@1.0.3:
+ optional: true
+
+ entities@4.5.0: {}
+
+ estree-walker@2.0.2: {}
+
+ fill-range@7.1.1:
+ dependencies:
+ to-regex-range: 5.0.1
+ optional: true
+
+ immutable@5.1.4: {}
+
+ is-extglob@2.1.1:
+ optional: true
+
+ is-glob@4.0.3:
+ dependencies:
+ is-extglob: 2.1.1
+ optional: true
+
+ is-number@7.0.0:
+ optional: true
+
+ magic-string@0.30.21:
+ dependencies:
+ '@jridgewell/sourcemap-codec': 1.5.5
+
+ micromatch@4.0.8:
+ dependencies:
+ braces: 3.0.3
+ picomatch: 2.3.1
+ optional: true
+
+ nanoid@3.3.11: {}
+
+ node-addon-api@7.1.1:
+ optional: true
+
+ picocolors@1.1.1: {}
+
+ picomatch@2.3.1:
+ optional: true
+
+ postcss@8.5.6:
+ dependencies:
+ nanoid: 3.3.11
+ picocolors: 1.1.1
+ source-map-js: 1.2.1
+
+ prettier@3.6.2: {}
+
+ readdirp@4.1.2: {}
+
+ sass@1.93.3:
+ dependencies:
+ chokidar: 4.0.3
+ immutable: 5.1.4
+ source-map-js: 1.2.1
+ optionalDependencies:
+ '@parcel/watcher': 2.5.1
+
+ source-map-js@1.2.1: {}
+
+ to-regex-range@5.0.1:
+ dependencies:
+ is-number: 7.0.0
+ optional: true
+
+ typescript@5.9.3: {}
+
+ vue@3.5.24(typescript@5.9.3):
+ dependencies:
+ '@vue/compiler-dom': 3.5.24
+ '@vue/compiler-sfc': 3.5.24
+ '@vue/runtime-dom': 3.5.24
+ '@vue/server-renderer': 3.5.24(vue@3.5.24(typescript@5.9.3))
+ '@vue/shared': 3.5.24
+ optionalDependencies:
+ typescript: 5.9.3
+
+ web-tree-sitter@0.25.6: {}
+
+ zod@3.25.76: {}
diff --git a/custom_nodes/rgthree-comfy/prestartup_script.py b/custom_nodes/rgthree-comfy/prestartup_script.py
new file mode 100644
index 0000000000000000000000000000000000000000..81d81b35a80675a13e3d5d279644a96e52658838
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/prestartup_script.py
@@ -0,0 +1,5 @@
+import folder_paths
+
+# Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully.
+# TODO: See if anyone actually used this.
+# folder_paths.folder_names_and_paths['saved_prompts'] = ([], set(['.txt']))
diff --git a/custom_nodes/rgthree-comfy/py/__init__.py b/custom_nodes/rgthree-comfy/py/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/custom_nodes/rgthree-comfy/py/any_switch.py b/custom_nodes/rgthree-comfy/py/any_switch.py
new file mode 100644
index 0000000000000000000000000000000000000000..99713fafd3db1812b384689b7ed70b6e7f96f4d9
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/any_switch.py
@@ -0,0 +1,38 @@
+from .context_utils import is_context_empty
+from .constants import get_category, get_name
+from .utils import FlexibleOptionalInputType, any_type
+
+
+def is_none(value):
+ """Checks if a value is none. Pulled out in case we want to expand what 'None' means."""
+ if value is not None:
+ if isinstance(value, dict) and 'model' in value and 'clip' in value:
+ return is_context_empty(value)
+ return value is None
+
+
+class RgthreeAnySwitch:
+ """The dynamic Any Switch. """
+
+ NAME = get_name("Any Switch")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType(any_type),
+ }
+
+ RETURN_TYPES = (any_type,)
+ RETURN_NAMES = ('*',)
+ FUNCTION = "switch"
+
+ def switch(self, **kwargs):
+ """Chooses the first non-empty item to output."""
+ any_value = None
+ for key, value in kwargs.items():
+ if key.startswith('any_') and not is_none(value):
+ any_value = value
+ break
+ return (any_value,)
diff --git a/custom_nodes/rgthree-comfy/py/config.py b/custom_nodes/rgthree-comfy/py/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..a50c49293e3a574881351a0f04d58b72d638561b
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/config.py
@@ -0,0 +1,111 @@
+import os
+import json
+
+from .utils import get_dict_value, set_dict_value, dict_has_key, load_json_file
+from .pyproject import VERSION
+
+
+def get_config_value(key, default=None):
+ return get_dict_value(RGTHREE_CONFIG, key, default)
+
+
+def extend_config(default_config, user_config):
+ """ Returns a new config dict combining user_config into defined keys for default_config."""
+ cfg = {}
+ for key, value in default_config.items():
+ if key not in user_config:
+ cfg[key] = value
+ elif isinstance(value, dict):
+ cfg[key] = extend_config(value, user_config[key])
+ else:
+ cfg[key] = user_config[key] if key in user_config else value
+ return cfg
+
+
+def set_user_config(data: dict):
+ """ Sets the user configuration."""
+ count = 0
+ for key, value in data.items():
+ if dict_has_key(DEFAULT_CONFIG, key):
+ set_dict_value(USER_CONFIG, key, value)
+ set_dict_value(RGTHREE_CONFIG, key, value)
+ count += 1
+ if count > 0:
+ write_user_config()
+
+
+def get_rgthree_default_config():
+ """ Gets the default configuration."""
+ return load_json_file(DEFAULT_CONFIG_FILE, default={})
+
+
+def get_rgthree_user_config():
+ """ Gets the user configuration."""
+ return load_json_file(USER_CONFIG_FILE, default={})
+
+
+def write_user_config():
+ """ Writes the user configuration."""
+ with open(USER_CONFIG_FILE, 'w+', encoding='UTF-8') as file:
+ json.dump(USER_CONFIG, file, sort_keys=True, indent=2, separators=(",", ": "))
+
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_CONFIG_FILE = os.path.join(THIS_DIR, '..', 'rgthree_config.json.default')
+USER_CONFIG_FILE = os.path.join(THIS_DIR, '..', 'rgthree_config.json')
+
+DEFAULT_CONFIG = {}
+USER_CONFIG = {}
+RGTHREE_CONFIG = {}
+
+
+def refresh_config():
+ """Refreshes the config."""
+ global DEFAULT_CONFIG, USER_CONFIG, RGTHREE_CONFIG
+ DEFAULT_CONFIG = get_rgthree_default_config()
+ USER_CONFIG = get_rgthree_user_config()
+
+ # Migrate old config options into "features"
+ needs_to_write_user_config = False
+ if 'patch_recursive_execution' in USER_CONFIG:
+ del USER_CONFIG['patch_recursive_execution']
+ needs_to_write_user_config = True
+
+ if 'features' in USER_CONFIG and 'patch_recursive_execution' in USER_CONFIG['features']:
+ del USER_CONFIG['features']['patch_recursive_execution']
+ needs_to_write_user_config = True
+
+ if 'show_alerts_for_corrupt_workflows' in USER_CONFIG:
+ if 'features' not in USER_CONFIG:
+ USER_CONFIG['features'] = {}
+ USER_CONFIG['features']['show_alerts_for_corrupt_workflows'] = USER_CONFIG[
+ 'show_alerts_for_corrupt_workflows']
+ del USER_CONFIG['show_alerts_for_corrupt_workflows']
+ needs_to_write_user_config = True
+
+ if 'monitor_for_corrupt_links' in USER_CONFIG:
+ if 'features' not in USER_CONFIG:
+ USER_CONFIG['features'] = {}
+ USER_CONFIG['features']['monitor_for_corrupt_links'] = USER_CONFIG['monitor_for_corrupt_links']
+ del USER_CONFIG['monitor_for_corrupt_links']
+ needs_to_write_user_config = True
+
+ if needs_to_write_user_config is True:
+ print('writing new user config.')
+ write_user_config()
+
+ RGTHREE_CONFIG = {"version": VERSION} | extend_config(DEFAULT_CONFIG, USER_CONFIG)
+
+ if "unreleased" in USER_CONFIG and "unreleased" not in RGTHREE_CONFIG:
+ RGTHREE_CONFIG["unreleased"] = USER_CONFIG["unreleased"]
+
+ if "debug" in USER_CONFIG and "debug" not in RGTHREE_CONFIG:
+ RGTHREE_CONFIG["debug"] = USER_CONFIG["debug"]
+
+
+def get_config():
+ """Returns the congfig."""
+ return RGTHREE_CONFIG
+
+
+refresh_config()
diff --git a/custom_nodes/rgthree-comfy/py/constants.py b/custom_nodes/rgthree-comfy/py/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..73b7d687ad24999c3b441f2c2ef39e4e8b3f3d54
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/constants.py
@@ -0,0 +1,11 @@
+
+NAMESPACE='rgthree'
+
+def get_name(name):
+ return '{} ({})'.format(name, NAMESPACE)
+
+def get_category(sub_dirs = None):
+ if sub_dirs is None:
+ return NAMESPACE
+ else:
+ return "{}/utils".format(NAMESPACE)
diff --git a/custom_nodes/rgthree-comfy/py/context.py b/custom_nodes/rgthree-comfy/py/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2c94f6a687606708cd1399e228c6b6b7d451318
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context.py
@@ -0,0 +1,33 @@
+"""The Context node."""
+from .context_utils import (ORIG_CTX_OPTIONAL_INPUTS, ORIG_CTX_RETURN_NAMES, ORIG_CTX_RETURN_TYPES,
+ get_orig_context_return_tuple, new_context)
+from .constants import get_category, get_name
+
+
+class RgthreeContext:
+ """The initial Context node.
+
+ For now, this nodes' outputs will remain as-is, as they are perfect for most 1.5 application, but
+ is also backwards compatible with other Context nodes.
+ """
+
+ NAME = get_name("Context")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": ORIG_CTX_OPTIONAL_INPUTS,
+ "hidden": {
+ "version": "FLOAT"
+ },
+ }
+
+ RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+ RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+ FUNCTION = "convert"
+
+ def convert(self, base_ctx=None, **kwargs): # pylint: disable = missing-function-docstring
+ ctx = new_context(base_ctx, **kwargs)
+ return get_orig_context_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_big.py b/custom_nodes/rgthree-comfy/py/context_big.py
new file mode 100644
index 0000000000000000000000000000000000000000..411cdc8fee86118c0a4201ff7441eab0f5c792d1
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_big.py
@@ -0,0 +1,31 @@
+"""The Conmtext big node."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_OPTIONAL_INPUTS, ALL_CTX_RETURN_NAMES, ALL_CTX_RETURN_TYPES,
+ new_context, get_context_return_tuple)
+
+
+class RgthreeBigContext:
+ """The Context Big node.
+
+ This context node will expose all context fields as inputs and outputs. It is backwards compatible
+ with other context nodes and can be intertwined with them.
+ """
+
+ NAME = get_name("Context Big")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name,missing-function-docstring
+ return {
+ "required": {},
+ "optional": ALL_CTX_OPTIONAL_INPUTS,
+ "hidden": {},
+ }
+
+ RETURN_TYPES = ALL_CTX_RETURN_TYPES
+ RETURN_NAMES = ALL_CTX_RETURN_NAMES
+ FUNCTION = "convert"
+
+ def convert(self, base_ctx=None, **kwargs): # pylint: disable = missing-function-docstring
+ ctx = new_context(base_ctx, **kwargs)
+ return get_context_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_merge.py b/custom_nodes/rgthree-comfy/py/context_merge.py
new file mode 100644
index 0000000000000000000000000000000000000000..02d0afe68554f16e99d99ff969afbd98a646ff8c
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_merge.py
@@ -0,0 +1,37 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES, merge_new_context,
+ get_orig_context_return_tuple, is_context_empty)
+from .utils import FlexibleOptionalInputType
+
+
+class RgthreeContextMerge:
+ """The Context Merge node."""
+
+ NAME = get_name("Context Merge")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType("RGTHREE_CONTEXT"),
+ }
+
+ RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+ RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+ FUNCTION = "merge"
+
+ def get_return_tuple(self, ctx):
+ """Returns the context data. Separated so it can be overridden."""
+ return get_orig_context_return_tuple(ctx)
+
+ def merge(self, **kwargs):
+ """Merges any non-null passed contexts; later ones overriding earlier."""
+ ctxs = [
+ value for key, value in kwargs.items()
+ if key.startswith('ctx_') and not is_context_empty(value)
+ ]
+ ctx = merge_new_context(*ctxs)
+
+ return self.get_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_merge_big.py b/custom_nodes/rgthree-comfy/py/context_merge_big.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4039e4eb87a3e6fedae2a871f13bb4537cc12a9
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_merge_big.py
@@ -0,0 +1,16 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES, get_context_return_tuple)
+from .context_merge import RgthreeContextMerge
+
+
+class RgthreeContextMergeBig(RgthreeContextMerge):
+ """The Context Merge Big node."""
+
+ NAME = get_name("Context Merge Big")
+ RETURN_TYPES = ALL_CTX_RETURN_TYPES
+ RETURN_NAMES = ALL_CTX_RETURN_NAMES
+
+ def get_return_tuple(self, ctx):
+ """Returns the context data. Separated so it can be overridden."""
+ return get_context_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_switch.py b/custom_nodes/rgthree-comfy/py/context_switch.py
new file mode 100644
index 0000000000000000000000000000000000000000..67e02e1452da99b4df57f0d00a3fd6963a5d48ce
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_switch.py
@@ -0,0 +1,36 @@
+"""The original Context Switch."""
+from .constants import get_category, get_name
+from .context_utils import (ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES, is_context_empty,
+ get_orig_context_return_tuple)
+from .utils import FlexibleOptionalInputType
+
+
+class RgthreeContextSwitch:
+ """The (original) Context Switch node."""
+
+ NAME = get_name("Context Switch")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType("RGTHREE_CONTEXT"),
+ }
+
+ RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+ RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+ FUNCTION = "switch"
+
+ def get_return_tuple(self, ctx):
+ """Returns the context data. Separated so it can be overridden."""
+ return get_orig_context_return_tuple(ctx)
+
+ def switch(self, **kwargs):
+ """Chooses the first non-empty Context to output."""
+ ctx = None
+ for key, value in kwargs.items():
+ if key.startswith('ctx_') and not is_context_empty(value):
+ ctx = value
+ break
+ return self.get_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_switch_big.py b/custom_nodes/rgthree-comfy/py/context_switch_big.py
new file mode 100644
index 0000000000000000000000000000000000000000..4382e3027641d8a546ef509be824e18533376551
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_switch_big.py
@@ -0,0 +1,16 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES, get_context_return_tuple)
+from .context_switch import RgthreeContextSwitch
+
+
+class RgthreeContextSwitchBig(RgthreeContextSwitch):
+ """The Context Switch Big node."""
+
+ NAME = get_name("Context Switch Big")
+ RETURN_TYPES = ALL_CTX_RETURN_TYPES
+ RETURN_NAMES = ALL_CTX_RETURN_NAMES
+
+ def get_return_tuple(self, ctx):
+ """Overrides the RgthreeContextSwitch `get_return_tuple` to return big context data."""
+ return get_context_return_tuple(ctx)
diff --git a/custom_nodes/rgthree-comfy/py/context_utils.py b/custom_nodes/rgthree-comfy/py/context_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c2e68478fce2cd97042af8a9aed2ea84ef78b3e
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/context_utils.py
@@ -0,0 +1,118 @@
+"""A set of constants and utilities for handling contexts.
+
+Sets up the inputs and outputs for the Context going forward, with additional functions for
+creating and exporting context objects.
+"""
+import comfy.samplers
+import folder_paths
+
+_all_context_input_output_data = {
+ "base_ctx": ("base_ctx", "RGTHREE_CONTEXT", "CONTEXT"),
+ "model": ("model", "MODEL", "MODEL"),
+ "clip": ("clip", "CLIP", "CLIP"),
+ "vae": ("vae", "VAE", "VAE"),
+ "positive": ("positive", "CONDITIONING", "POSITIVE"),
+ "negative": ("negative", "CONDITIONING", "NEGATIVE"),
+ "latent": ("latent", "LATENT", "LATENT"),
+ "images": ("images", "IMAGE", "IMAGE"),
+ "seed": ("seed", "INT", "SEED"),
+ "steps": ("steps", "INT", "STEPS"),
+ "step_refiner": ("step_refiner", "INT", "STEP_REFINER"),
+ "cfg": ("cfg", "FLOAT", "CFG"),
+ "ckpt_name": ("ckpt_name", folder_paths.get_filename_list("checkpoints"), "CKPT_NAME"),
+ "sampler": ("sampler", comfy.samplers.KSampler.SAMPLERS, "SAMPLER"),
+ "scheduler": ("scheduler", comfy.samplers.KSampler.SCHEDULERS, "SCHEDULER"),
+ "clip_width": ("clip_width", "INT", "CLIP_WIDTH"),
+ "clip_height": ("clip_height", "INT", "CLIP_HEIGHT"),
+ "text_pos_g": ("text_pos_g", "STRING", "TEXT_POS_G"),
+ "text_pos_l": ("text_pos_l", "STRING", "TEXT_POS_L"),
+ "text_neg_g": ("text_neg_g", "STRING", "TEXT_NEG_G"),
+ "text_neg_l": ("text_neg_l", "STRING", "TEXT_NEG_L"),
+ "mask": ("mask", "MASK", "MASK"),
+ "control_net": ("control_net", "CONTROL_NET", "CONTROL_NET"),
+}
+
+force_input_types = ["INT", "STRING", "FLOAT"]
+force_input_names = ["sampler", "scheduler", "ckpt_name"]
+
+
+def _create_context_data(input_list=None):
+ """Returns a tuple of context inputs, return types, and return names to use in a node"s def"""
+ if input_list is None:
+ input_list = _all_context_input_output_data.keys()
+ list_ctx_return_types = []
+ list_ctx_return_names = []
+ ctx_optional_inputs = {}
+ for inp in input_list:
+ data = _all_context_input_output_data[inp]
+ list_ctx_return_types.append(data[1])
+ list_ctx_return_names.append(data[2])
+ ctx_optional_inputs[data[0]] = tuple([data[1]] + ([{
+ "forceInput": True
+ }] if data[1] in force_input_types or data[0] in force_input_names else []))
+
+ ctx_return_types = tuple(list_ctx_return_types)
+ ctx_return_names = tuple(list_ctx_return_names)
+ return (ctx_optional_inputs, ctx_return_types, ctx_return_names)
+
+
+ALL_CTX_OPTIONAL_INPUTS, ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES = _create_context_data()
+
+_original_ctx_inputs_list = [
+ "base_ctx", "model", "clip", "vae", "positive", "negative", "latent", "images", "seed"
+]
+ORIG_CTX_OPTIONAL_INPUTS, ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES = _create_context_data(
+ _original_ctx_inputs_list)
+
+
+def new_context(base_ctx, **kwargs):
+ """Creates a new context from the provided data, with an optional base ctx to start."""
+ context = base_ctx if base_ctx is not None else None
+ new_ctx = {}
+ for key in _all_context_input_output_data:
+ if key == "base_ctx":
+ continue
+ v = kwargs[key] if key in kwargs else None
+ new_ctx[key] = v if v is not None else context[
+ key] if context is not None and key in context else None
+ return new_ctx
+
+
+def merge_new_context(*args):
+ """Creates a new context by merging provided contexts with the latter overriding same fields."""
+ new_ctx = {}
+ for key in _all_context_input_output_data:
+ if key == "base_ctx":
+ continue
+ v = None
+ # Move backwards through the passed contexts until we find a value and use it.
+ for ctx in reversed(args):
+ v = ctx[key] if not is_context_empty(ctx) and key in ctx else None
+ if v is not None:
+ break
+ new_ctx[key] = v
+ return new_ctx
+
+
+def get_context_return_tuple(ctx, inputs_list=None):
+ """Returns a tuple for returning in the order of the inputs list."""
+ if inputs_list is None:
+ inputs_list = _all_context_input_output_data.keys()
+ tup_list = [
+ ctx,
+ ]
+ for key in inputs_list:
+ if key == "base_ctx":
+ continue
+ tup_list.append(ctx[key] if ctx is not None and key in ctx else None)
+ return tuple(tup_list)
+
+
+def get_orig_context_return_tuple(ctx):
+ """Returns a tuple for returning from a node with only the original context keys."""
+ return get_context_return_tuple(ctx, _original_ctx_inputs_list)
+
+
+def is_context_empty(ctx):
+ """Checks if the provided ctx is None or contains just None values."""
+ return not ctx or all(v is None for v in ctx.values())
diff --git a/custom_nodes/rgthree-comfy/py/display_any.py b/custom_nodes/rgthree-comfy/py/display_any.py
new file mode 100644
index 0000000000000000000000000000000000000000..19238dbab0cc886cbde4d0106724cd3bc95ed085
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/display_any.py
@@ -0,0 +1,77 @@
+import json
+from .constants import get_category, get_name
+from .utils import any_type, get_dict_value
+
+
+class RgthreeDisplayAny:
+ """Display any data node."""
+
+ NAME = get_name('Display Any')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "source": (any_type, {}),
+ },
+ "hidden": {
+ "unique_id": "UNIQUE_ID",
+ "extra_pnginfo": "EXTRA_PNGINFO",
+ },
+ }
+
+ RETURN_TYPES = ()
+ FUNCTION = "main"
+ OUTPUT_NODE = True
+
+ def main(self, source=None, unique_id=None, extra_pnginfo=None):
+ value = 'None'
+ if isinstance(source, str):
+ value = source
+ elif isinstance(source, (int, float, bool)):
+ value = str(source)
+ elif source is not None:
+ try:
+ value = json.dumps(source)
+ except Exception:
+ try:
+ value = str(source)
+ except Exception:
+ value = 'source exists, but could not be serialized.'
+
+ # Save the output to the pnginfo so it's pre-filled when loading the data.
+ if extra_pnginfo and unique_id:
+ for node in get_dict_value(extra_pnginfo, 'workflow.nodes', []):
+ if str(node['id']) == str(unique_id):
+ node['widgets_values'] = [value]
+ break
+
+ return {"ui": {"text": (value,)}}
+
+
+class RgthreeDisplayInt:
+ """Old DisplayInt node.
+
+ Can be ported over to DisplayAny if https://github.com/comfyanonymous/ComfyUI/issues/1527 fixed.
+ """
+
+ NAME = get_name('Display Int')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(s):
+ return {
+ "required": {
+ "input": ("INT", {
+ "forceInput": True
+ }),
+ },
+ }
+
+ RETURN_TYPES = ()
+ FUNCTION = "main"
+ OUTPUT_NODE = True
+
+ def main(self, input=None):
+ return {"ui": {"text": (input,)}}
diff --git a/custom_nodes/rgthree-comfy/py/dynamic_context.py b/custom_nodes/rgthree-comfy/py/dynamic_context.py
new file mode 100644
index 0000000000000000000000000000000000000000..411210d0e0cbc3c038b8b9c0822b69658fc63c7d
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/dynamic_context.py
@@ -0,0 +1,56 @@
+"""The Dynamic Context node."""
+from mimetypes import add_type
+from .constants import get_category, get_name
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType
+
+
+class RgthreeDynamicContext:
+ """The Dynamic Context node.
+
+ Similar to the static Context and Context Big nodes, this allows users to add any number and
+ variety of inputs to a Dynamic Context node, and return the outputs by key name.
+ """
+
+ NAME = get_name("Dynamic Context")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name,missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType(add_type),
+ "hidden": {},
+ }
+
+ RETURN_TYPES = ByPassTypeTuple(("RGTHREE_DYNAMIC_CONTEXT",))
+ RETURN_NAMES = ByPassTypeTuple(("CONTEXT",))
+ FUNCTION = "main"
+
+ def main(self, **kwargs):
+ """Creates a new context from the provided data, with an optional base ctx to start.
+
+ This node takes a list of named inputs that are the named keys (with an optional "+ " prefix)
+ which are to be stored within the ctx dict as well as a list of keys contained in `output_keys`
+ to determine the list of output data.
+ """
+
+ base_ctx = kwargs.get('base_ctx', None)
+ output_keys = kwargs.get('output_keys', None)
+
+ new_ctx = base_ctx.copy() if base_ctx is not None else {}
+
+ for key_raw, value in kwargs.items():
+ if key_raw in ['base_ctx', 'output_keys']:
+ continue
+ key = key_raw.upper()
+ if key.startswith('+ '):
+ key = key[2:]
+ new_ctx[key] = value
+
+ print(new_ctx)
+
+ res = [new_ctx]
+ output_keys = output_keys.split(',') if output_keys is not None else []
+ for key in output_keys:
+ res.append(new_ctx[key] if key in new_ctx else None)
+ return tuple(res)
diff --git a/custom_nodes/rgthree-comfy/py/dynamic_context_switch.py b/custom_nodes/rgthree-comfy/py/dynamic_context_switch.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d1b9e6a7eb1a592db3941298e57ff0c38dfb5e0
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/dynamic_context_switch.py
@@ -0,0 +1,39 @@
+"""The original Context Switch."""
+from .constants import get_category, get_name
+from .context_utils import is_context_empty
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType
+
+
+class RgthreeDynamicContextSwitch:
+ """The initial Context Switch node."""
+
+ NAME = get_name("Dynamic Context Switch")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType("RGTHREE_DYNAMIC_CONTEXT"),
+ }
+
+ RETURN_TYPES = ByPassTypeTuple(("RGTHREE_DYNAMIC_CONTEXT",))
+ RETURN_NAMES = ByPassTypeTuple(("CONTEXT",))
+ FUNCTION = "switch"
+
+ def switch(self, **kwargs):
+ """Chooses the first non-empty Context to output."""
+
+ output_keys = kwargs.get('output_keys', None)
+
+ ctx = None
+ for key, value in kwargs.items():
+ if key.startswith('ctx_') and not is_context_empty(value):
+ ctx = value
+ break
+
+ res = [ctx]
+ output_keys = output_keys.split(',') if output_keys is not None else []
+ for key in output_keys:
+ res.append(ctx[key] if ctx is not None and key in ctx else None)
+ return tuple(res)
diff --git a/custom_nodes/rgthree-comfy/py/image_comparer.py b/custom_nodes/rgthree-comfy/py/image_comparer.py
new file mode 100644
index 0000000000000000000000000000000000000000..079ebdbf6051fa86cf89f75f55f8502904d0c93f
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/image_comparer.py
@@ -0,0 +1,42 @@
+from nodes import PreviewImage
+
+from .constants import get_category, get_name
+
+
+class RgthreeImageComparer(PreviewImage):
+ """A node that compares two images in the UI."""
+
+ NAME = get_name('Image Comparer')
+ CATEGORY = get_category()
+ FUNCTION = "compare_images"
+ DESCRIPTION = "Compares two images with a hover slider, or click from properties."
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": {
+ "image_a": ("IMAGE",),
+ "image_b": ("IMAGE",),
+ },
+ "hidden": {
+ "prompt": "PROMPT",
+ "extra_pnginfo": "EXTRA_PNGINFO"
+ },
+ }
+
+ def compare_images(self,
+ image_a=None,
+ image_b=None,
+ filename_prefix="rgthree.compare.",
+ prompt=None,
+ extra_pnginfo=None):
+
+ result = { "ui": { "a_images":[], "b_images": [] } }
+ if image_a is not None and len(image_a) > 0:
+ result['ui']['a_images'] = self.save_images(image_a, filename_prefix, prompt, extra_pnginfo)['ui']['images']
+
+ if image_b is not None and len(image_b) > 0:
+ result['ui']['b_images'] = self.save_images(image_b, filename_prefix, prompt, extra_pnginfo)['ui']['images']
+
+ return result
\ No newline at end of file
diff --git a/custom_nodes/rgthree-comfy/py/image_inset_crop.py b/custom_nodes/rgthree-comfy/py/image_inset_crop.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f5f29adf825494dc91dd00519d8d2af287cce19
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/image_inset_crop.py
@@ -0,0 +1,93 @@
+"""Image Inset Crop, with percentages."""
+from .log import log_node_info
+from .constants import get_category, get_name
+from nodes import MAX_RESOLUTION
+
+
+def get_new_bounds(width, height, left, right, top, bottom):
+ """Returns the new bounds for an image with inset crop data."""
+ left = 0 + left
+ right = width - right
+ top = 0 + top
+ bottom = height - bottom
+ return (left, right, top, bottom)
+
+
+class RgthreeImageInsetCrop:
+ """Image Inset Crop, with percentages."""
+
+ NAME = get_name('Image Inset Crop')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "image": ("IMAGE",),
+ "measurement": (['Pixels', 'Percentage'],),
+ "left": ("INT", {
+ "default": 0,
+ "min": 0,
+ "max": MAX_RESOLUTION,
+ "step": 8
+ }),
+ "right": ("INT", {
+ "default": 0,
+ "min": 0,
+ "max": MAX_RESOLUTION,
+ "step": 8
+ }),
+ "top": ("INT", {
+ "default": 0,
+ "min": 0,
+ "max": MAX_RESOLUTION,
+ "step": 8
+ }),
+ "bottom": ("INT", {
+ "default": 0,
+ "min": 0,
+ "max": MAX_RESOLUTION,
+ "step": 8
+ }),
+ },
+ }
+
+ RETURN_TYPES = ("IMAGE",)
+ FUNCTION = "crop"
+
+ # pylint: disable = too-many-arguments
+ def crop(self, measurement, left, right, top, bottom, image=None):
+ """Does the crop."""
+
+ _, height, width, _ = image.shape
+
+ if measurement == 'Percentage':
+ left = int(width - (width * (100 - left) / 100))
+ right = int(width - (width * (100 - right) / 100))
+ top = int(height - (height * (100 - top) / 100))
+ bottom = int(height - (height * (100 - bottom) / 100))
+
+ # Snap to 8 pixels
+ left = left // 8 * 8
+ right = right // 8 * 8
+ top = top // 8 * 8
+ bottom = bottom // 8 * 8
+
+ if left == 0 and right == 0 and bottom == 0 and top == 0:
+ return (image,)
+
+ inset_left, inset_right, inset_top, inset_bottom = get_new_bounds(width, height, left, right,
+ top, bottom)
+ if inset_top > inset_bottom:
+ raise ValueError(
+ f"Invalid cropping dimensions top ({inset_top}) exceeds bottom ({inset_bottom})")
+ if inset_left > inset_right:
+ raise ValueError(
+ f"Invalid cropping dimensions left ({inset_left}) exceeds right ({inset_right})")
+
+ log_node_info(
+ self.NAME, f'Cropping image {width}x{height} width inset by {inset_left},{inset_right}, ' +
+ f'and height inset by {inset_top}, {inset_bottom}')
+ image = image[:, inset_top:inset_bottom, inset_left:inset_right, :]
+
+ return (image,)
diff --git a/custom_nodes/rgthree-comfy/py/image_or_latent_size.py b/custom_nodes/rgthree-comfy/py/image_or_latent_size.py
new file mode 100644
index 0000000000000000000000000000000000000000..65f62f86fcfdfc5caedfddf773cb808f796bbef1
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/image_or_latent_size.py
@@ -0,0 +1,31 @@
+from .utils import FlexibleOptionalInputType, any_type
+from .constants import get_category, get_name
+
+
+class RgthreeImageOrLatentSize:
+ """The ImageOrLatentSize Node."""
+
+ NAME = get_name('Image or Latent Size')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType(any_type),
+ }
+
+ RETURN_TYPES = ("INT", "INT")
+ RETURN_NAMES = ('WIDTH', 'HEIGHT')
+ FUNCTION = "main"
+
+ def main(self, **kwargs):
+ """Does the node's work."""
+ image_or_latent_or_mask = kwargs.get('input', None)
+
+ if isinstance(image_or_latent_or_mask, dict) and 'samples' in image_or_latent_or_mask:
+ count, _, height, width = image_or_latent_or_mask['samples'].shape
+ return (width * 8, height * 8)
+
+ batch, height, width, channel = image_or_latent_or_mask.shape
+ return (width, height)
diff --git a/custom_nodes/rgthree-comfy/py/image_resize.py b/custom_nodes/rgthree-comfy/py/image_resize.py
new file mode 100644
index 0000000000000000000000000000000000000000..a21001b36ac8f6de616d68c2a9827d791acff2ee
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/image_resize.py
@@ -0,0 +1,117 @@
+import torch
+import comfy.utils
+import nodes
+
+from .constants import get_category, get_name
+
+
+class RgthreeImageResize:
+ """Image Resize."""
+
+ NAME = get_name("Image Resize")
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "image": ("IMAGE",),
+ "measurement": (["pixels", "percentage"],),
+ "width": (
+ "INT", {
+ "default": 0,
+ "min": 0,
+ "max": nodes.MAX_RESOLUTION,
+ "step": 1,
+ "tooltip": (
+ "The width of the desired resize. A pixel value if measurement is 'pixels' or a"
+ " 100% scale percentage value if measurement is 'percentage'. Passing '0' will"
+ " calculate the dimension based on the height."
+ ),
+ },
+ ),
+ "height": ("INT", {
+ "default": 0,
+ "min": 0,
+ "max": nodes.MAX_RESOLUTION,
+ "step": 1
+ }),
+ "fit": (["crop", "pad", "contain"], {
+ "tooltip": (
+ "'crop' resizes so the image covers the desired width and height, and center-crops the"
+ " excess, returning exactly the desired width and height."
+ "\n'pad' resizes so the image fits inside the desired width and height, and fills the"
+ " empty space returning exactly the desired width and height."
+ "\n'contain' resizes so the image fits inside the desired width and height, and"
+ " returns the image with it's new size, with one side liekly smaller than the desired."
+ "\n\nNote, if either width or height is '0', the effective fit is 'contain'."
+ )
+ },
+ ),
+ "method": (nodes.ImageScale.upscale_methods,),
+ },
+ }
+
+ RETURN_TYPES = ("IMAGE", "INT", "INT",)
+ RETURN_NAMES = ("IMAGE", "WIDTH", "HEIGHT",)
+ FUNCTION = "main"
+ DESCRIPTION = """Resize the image."""
+
+ def main(self, image, measurement, width, height, method, fit):
+ """Resizes the image."""
+ _, H, W, _ = image.shape
+
+ if measurement == "percentage":
+ width = round(width * W / 100)
+ height = round(height * H / 100)
+
+ if (width == 0 and height == 0) or (width == W and height == H):
+ return (image, W, H)
+
+ # If one dimension is 0, then calculate the desired value from the ratio of the set dimension.
+ # This also implies a 'contain' fit since the width and height will be scaled with a locked
+ # aspect ratio.
+ if width == 0 or height == 0:
+ width = round(height / H * W) if width == 0 else width
+ height = round(width / W * H) if height == 0 else height
+ fit = "contain"
+
+ # At this point, width and height are our output height, but our resize sizes will be different.
+ resized_width = width
+ resized_height = height
+ if fit == "crop":
+ # If we resize against the opposite ratio, then choose the ratio that has the overhang.
+ if (height / H * W) > width:
+ resized_width = round(height / H * W)
+ elif (width / W * H) > height:
+ resized_height = round(width / W * H)
+ elif fit == "contain" or fit == "pad":
+ # If we resize against the opposite ratio, then choose the ratio that has the overhang.
+ if (height / H * W) > width:
+ resized_height = round(width / W * H)
+ elif (width / W * H) > height:
+ resized_width = round(height / H * W)
+
+ out_image = comfy.utils.common_upscale(
+ image.clone().movedim(-1, 1), resized_width, resized_height, method, crop="disabled"
+ ).movedim(1, -1)
+ OB, OH, OW, OC = out_image.shape
+
+ if fit != "contain":
+ # First, we crop, then we pad; no need to check fit (other than not 'contain') since the size
+ # should already be correct.
+ if OW > width:
+ out_image = out_image.narrow(-2, (OW - width) // 2, width)
+ if OH > height:
+ out_image = out_image.narrow(-3, (OH - height) // 2, height)
+
+ OB, OH, OW, OC = out_image.shape
+ if width != OW or height != OH:
+ padded_image = torch.zeros((OB, height, width, OC), dtype=image.dtype, device=image.device)
+ x = (width - OW) // 2
+ y = (height - OH) // 2
+ for b in range(OB):
+ padded_image[b, y:y + OH, x:x + OW, :] = out_image[b]
+ out_image = padded_image
+
+ return (out_image, out_image.shape[2], out_image.shape[1])
diff --git a/custom_nodes/rgthree-comfy/py/ksampler_config.py b/custom_nodes/rgthree-comfy/py/ksampler_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..043ea49e4d09fe1b8fdae92d2d95bb6ee324c717
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/ksampler_config.py
@@ -0,0 +1,56 @@
+"""Some basic config stuff I use for SDXL."""
+
+from .constants import get_category, get_name
+from nodes import MAX_RESOLUTION
+import comfy.samplers
+
+
+class RgthreeKSamplerConfig:
+ """Some basic config stuff I started using for SDXL, but useful in other spots too."""
+
+ NAME = get_name('KSampler Config')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "steps_total": ("INT", {
+ "default": 30,
+ "min": 1,
+ "max": MAX_RESOLUTION,
+ "step": 1,
+ }),
+ "refiner_step": ("INT", {
+ "default": 24,
+ "min": 1,
+ "max": MAX_RESOLUTION,
+ "step": 1,
+ }),
+ "cfg": ("FLOAT", {
+ "default": 8.0,
+ "min": 0.0,
+ "max": 100.0,
+ "step": 0.5,
+ }),
+ "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+ "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+ #"refiner_ascore_pos": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 1000.0, "step": 0.01}),
+ #"refiner_ascore_neg": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 1000.0, "step": 0.01}),
+ },
+ }
+
+ RETURN_TYPES = ("INT", "INT", "FLOAT", comfy.samplers.KSampler.SAMPLERS,
+ comfy.samplers.KSampler.SCHEDULERS)
+ RETURN_NAMES = ("STEPS", "REFINER_STEP", "CFG", "SAMPLER", "SCHEDULER")
+ FUNCTION = "main"
+
+ def main(self, steps_total, refiner_step, cfg, sampler_name, scheduler):
+ """main"""
+ return (
+ steps_total,
+ refiner_step,
+ cfg,
+ sampler_name,
+ scheduler,
+ )
diff --git a/custom_nodes/rgthree-comfy/py/log.py b/custom_nodes/rgthree-comfy/py/log.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f41675ef6ccdb610821f147cb860c7b720f3eab
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/log.py
@@ -0,0 +1,100 @@
+import datetime
+import time
+from .pyproject import NAME
+
+# https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences
+# https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit
+COLORS = {
+ 'BLACK': '\33[30m',
+ 'RED': '\33[31m',
+ 'GREEN': '\33[32m',
+ 'YELLOW': '\33[33m',
+ 'BLUE': '\33[34m',
+ 'MAGENTA': '\33[35m',
+ 'CYAN': '\33[36m',
+ 'WHITE': '\33[37m',
+ 'GREY': '\33[90m',
+ 'BRIGHT_RED': '\33[91m',
+ 'BRIGHT_GREEN': '\33[92m',
+ 'BRIGHT_YELLOW': '\33[93m',
+ 'BRIGHT_BLUE': '\33[94m',
+ 'BRIGHT_MAGENTA': '\33[95m',
+ 'BRIGHT_CYAN': '\33[96m',
+ 'BRIGHT_WHITE': '\33[97m',
+ # Styles.
+ 'RESET': '\33[0m', # Note, Portainer doesn't like 00 here, so we'll use 0. Should be fine...
+ 'BOLD': '\33[01m',
+ 'NORMAL': '\33[22m',
+ 'ITALIC': '\33[03m',
+ 'UNDERLINE': '\33[04m',
+ 'BLINK': '\33[05m',
+ 'BLINK2': '\33[06m',
+ 'SELECTED': '\33[07m',
+ # Backgrounds
+ 'BG_BLACK': '\33[40m',
+ 'BG_RED': '\33[41m',
+ 'BG_GREEN': '\33[42m',
+ 'BG_YELLOW': '\33[43m',
+ 'BG_BLUE': '\33[44m',
+ 'BG_MAGENTA': '\33[45m',
+ 'BG_CYAN': '\33[46m',
+ 'BG_WHITE': '\33[47m',
+ 'BG_GREY': '\33[100m',
+ 'BG_BRIGHT_RED': '\33[101m',
+ 'BG_BRIGHT_GREEN': '\33[102m',
+ 'BG_BRIGHT_YELLOW': '\33[103m',
+ 'BG_BRIGHT_BLUE': '\33[104m',
+ 'BG_BRIGHT_MAGENTA': '\33[105m',
+ 'BG_BRIGHT_CYAN': '\33[106m',
+ 'BG_BRIGHT_WHITE': '\33[107m',
+}
+
+
+def log_node_success(node_name, message, msg_color='RESET'):
+ """Logs a success message."""
+ _log_node("BRIGHT_GREEN", node_name, message, msg_color=msg_color)
+
+
+def log_node_info(node_name, message, msg_color='RESET'):
+ """Logs an info message."""
+ _log_node("CYAN", node_name, message, msg_color=msg_color)
+
+
+def log_node_error(node_name, message, msg_color='RESET'):
+ """Logs an info message."""
+ _log_node("RED", node_name, message, msg_color=msg_color)
+
+
+def log_node_warn(node_name, message, msg_color='RESET'):
+ """Logs an warn message."""
+ _log_node("YELLOW", node_name, message, msg_color=msg_color)
+
+
+def log_node(node_name, message, msg_color='RESET'):
+ """Logs a message."""
+ _log_node("CYAN", node_name, message, msg_color=msg_color)
+
+
+def _log_node(color, node_name, message, msg_color='RESET'):
+ """Logs for a node message."""
+ log(message, color=color, prefix=node_name.replace(" (rgthree)", ""), msg_color=msg_color)
+
+LOGGED = {}
+
+def log(message, color=None, msg_color=None, prefix=None, id=None, at_most_secs=None):
+ """Basic logging."""
+ now = int(time.time())
+ if id:
+ if at_most_secs is None:
+ raise ValueError('at_most_secs should be set if an id is set.')
+ if id in LOGGED:
+ last_logged = LOGGED[id]
+ if now < last_logged + at_most_secs:
+ return
+ LOGGED[id] = now
+ color = COLORS[color] if color is not None and color in COLORS else COLORS["BRIGHT_GREEN"]
+ msg_color = COLORS[msg_color] if msg_color is not None and msg_color in COLORS else ''
+ prefix = f'[{prefix}]' if prefix is not None else ''
+ msg = f'{color}[{NAME}]{prefix}'
+ msg += f'{msg_color} {message}{COLORS["RESET"]}'
+ print(msg)
diff --git a/custom_nodes/rgthree-comfy/py/lora_stack.py b/custom_nodes/rgthree-comfy/py/lora_stack.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6d947aadcd7fcd3a49564695275041c8ac9e223
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/lora_stack.py
@@ -0,0 +1,46 @@
+from .constants import get_category, get_name
+from nodes import LoraLoader
+import folder_paths
+
+
+class RgthreeLoraLoaderStack:
+
+ NAME = get_name('Lora Loader Stack')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "model": ("MODEL",),
+ "clip": ("CLIP", ),
+
+ "lora_01": (['None'] + folder_paths.get_filename_list("loras"), ),
+ "strength_01":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ "lora_02": (['None'] + folder_paths.get_filename_list("loras"), ),
+ "strength_02":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ "lora_03": (['None'] + folder_paths.get_filename_list("loras"), ),
+ "strength_03":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+ "lora_04": (['None'] + folder_paths.get_filename_list("loras"), ),
+ "strength_04":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+ }
+ }
+
+ RETURN_TYPES = ("MODEL", "CLIP")
+ FUNCTION = "load_lora"
+
+ def load_lora(self, model, clip, lora_01, strength_01, lora_02, strength_02, lora_03, strength_03, lora_04, strength_04):
+ if lora_01 != "None" and strength_01 != 0:
+ model, clip = LoraLoader().load_lora(model, clip, lora_01, strength_01, strength_01)
+ if lora_02 != "None" and strength_02 != 0:
+ model, clip = LoraLoader().load_lora(model, clip, lora_02, strength_02, strength_02)
+ if lora_03 != "None" and strength_03 != 0:
+ model, clip = LoraLoader().load_lora(model, clip, lora_03, strength_03, strength_03)
+ if lora_04 != "None" and strength_04 != 0:
+ model, clip = LoraLoader().load_lora(model, clip, lora_04, strength_04, strength_04)
+
+ return (model, clip)
+
diff --git a/custom_nodes/rgthree-comfy/py/power_lora_loader.py b/custom_nodes/rgthree-comfy/py/power_lora_loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d11ac547205a95aa6b100cc90816954146abd44
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/power_lora_loader.py
@@ -0,0 +1,101 @@
+import folder_paths
+
+from typing import Union
+
+from nodes import LoraLoader
+from .constants import get_category, get_name
+from .power_prompt_utils import get_lora_by_filename
+from .utils import FlexibleOptionalInputType, any_type
+from .server.utils_info import get_model_info_file_data
+from .log import log_node_warn
+
+NODE_NAME = get_name('Power Lora Loader')
+
+
+class RgthreePowerLoraLoader:
+ """ The Power Lora Loader is a powerful, flexible node to add multiple loras to a model/clip."""
+
+ NAME = NODE_NAME
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ },
+ # Since we will pass any number of loras in from the UI, this needs to always allow an
+ "optional": FlexibleOptionalInputType(type=any_type, data={
+ "model": ("MODEL",),
+ "clip": ("CLIP",),
+ }),
+ "hidden": {},
+ }
+
+ RETURN_TYPES = ("MODEL", "CLIP")
+ RETURN_NAMES = ("MODEL", "CLIP")
+ FUNCTION = "load_loras"
+
+ def load_loras(self, model=None, clip=None, **kwargs):
+ """Loops over the provided loras in kwargs and applies valid ones."""
+ for key, value in kwargs.items():
+ key = key.upper()
+ if key.startswith('LORA_') and 'on' in value and 'lora' in value and 'strength' in value:
+ strength_model = value['strength']
+ # If we just passed one strength value, then use it for both, if we passed a strengthTwo
+ # as well, then our `strength` will be for the model, and `strengthTwo` for clip.
+ strength_clip = value['strengthTwo'] if 'strengthTwo' in value else None
+ if clip is None:
+ if strength_clip is not None and strength_clip != 0:
+ log_node_warn(NODE_NAME, 'Recieved clip strength eventhough no clip supplied!')
+ strength_clip = 0
+ else:
+ strength_clip = strength_clip if strength_clip is not None else strength_model
+ if value['on'] and (strength_model != 0 or strength_clip != 0):
+ lora = get_lora_by_filename(value['lora'], log_node=self.NAME)
+ if model is not None and lora is not None:
+ model, clip = LoraLoader().load_lora(model, clip, lora, strength_model, strength_clip)
+
+ return (model, clip)
+
+ @classmethod
+ def get_enabled_loras_from_prompt_node(cls,
+ prompt_node: dict) -> list[dict[str, Union[str, float]]]:
+ """Gets enabled loras of a node within a server prompt."""
+ result = []
+ for name, lora in prompt_node['inputs'].items():
+ if name.startswith('lora_') and lora['on']:
+ lora_file = get_lora_by_filename(lora['lora'], log_node=cls.NAME)
+ if lora_file is not None: # Add the same safety check
+ lora_dict = {
+ 'name': lora['lora'],
+ 'strength': lora['strength'],
+ 'path': folder_paths.get_full_path("loras", lora_file)
+ }
+ if 'strengthTwo' in lora:
+ lora_dict['strength_clip'] = lora['strengthTwo']
+ result.append(lora_dict)
+ return result
+
+ @classmethod
+ def get_enabled_triggers_from_prompt_node(cls, prompt_node: dict, max_each: int = 1):
+ """Gets trigger words up to the max for enabled loras of a node within a server prompt."""
+ loras = [l['name'] for l in cls.get_enabled_loras_from_prompt_node(prompt_node)]
+ trained_words = []
+ for lora in loras:
+ info = get_model_info_file_data(lora, 'loras', default={})
+ if not info or not info.keys():
+ log_node_warn(
+ NODE_NAME,
+ f'No info found for lora {lora} when grabbing triggers. Have you generated an info file'
+ ' from the Power Lora Loader "Show Info" dialog?'
+ )
+ continue
+ if 'trainedWords' not in info or not info['trainedWords']:
+ log_node_warn(
+ NODE_NAME,
+ f'No trained words for lora {lora} when grabbing triggers. Have you fetched data from'
+ 'civitai or manually added words?'
+ )
+ continue
+ trained_words += [w for wi in info['trainedWords'][:max_each] if (wi and (w := wi['word']))]
+ return trained_words
diff --git a/custom_nodes/rgthree-comfy/py/power_primitive.py b/custom_nodes/rgthree-comfy/py/power_primitive.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8deea1c8bbe4d0e48c16b9b535f0478f3cbae04
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/power_primitive.py
@@ -0,0 +1,83 @@
+import re
+
+from .utils import FlexibleOptionalInputType, any_type
+from .constants import get_category, get_name
+
+
+def cast_to_str(x):
+ """Handles our cast to a string."""
+ if x is None:
+ return ''
+ try:
+ return str(x)
+ except (ValueError, TypeError):
+ return ''
+
+
+def cast_to_float(x):
+ """Handles our cast to a float."""
+ try:
+ return float(x)
+ except (ValueError, TypeError):
+ return 0.0
+
+
+def cast_to_bool(x):
+ """Handles our cast to a bool."""
+ try:
+ return bool(float(x))
+ except (ValueError, TypeError):
+ return str(x).lower() not in ['0', 'false', 'null', 'none', '']
+
+
+output_to_type = {
+ 'STRING': {
+ 'cast': cast_to_str,
+ 'null': '',
+ },
+ 'FLOAT': {
+ 'cast': cast_to_float,
+ 'null': 0.0,
+ },
+ 'INT': {
+ 'cast': lambda x: int(cast_to_float(x)),
+ 'null': 0,
+ },
+ 'BOOLEAN': {
+ 'cast': cast_to_bool,
+ 'null': False,
+ },
+ # This can be removed soon, there was a bug where this should have been BOOLEAN
+ 'BOOL': {
+ 'cast': cast_to_bool,
+ 'null': False,
+ },
+}
+
+
+class RgthreePowerPrimitive:
+ """The Power Primitive Node."""
+
+ NAME = get_name('Power Primitive')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {},
+ "optional": FlexibleOptionalInputType(any_type),
+ }
+
+ RETURN_TYPES = (any_type,)
+ RETURN_NAMES = ('*',)
+ FUNCTION = "main"
+
+ def main(self, **kwargs):
+ """Outputs the expected type."""
+ output = kwargs.get('value', None)
+ output_type = re.sub(r'\s*\([^\)]*\)\s*$', '', kwargs.get('type', ''))
+ output_type = output_to_type[output_type]
+ cast = output_type['cast']
+ output = cast(output)
+
+ return (output,)
diff --git a/custom_nodes/rgthree-comfy/py/power_prompt.py b/custom_nodes/rgthree-comfy/py/power_prompt.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fa75bf084f6a6b089adcec549886d5942004af7
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/power_prompt.py
@@ -0,0 +1,95 @@
+import os
+
+from .log import log_node_warn, log_node_info, log_node_success
+
+from .constants import get_category, get_name
+from .power_prompt_utils import get_and_strip_loras
+from nodes import LoraLoader, CLIPTextEncode
+import folder_paths
+
+NODE_NAME = get_name('Power Prompt')
+
+
+class RgthreePowerPrompt:
+
+ NAME = NODE_NAME
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ # Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully,
+ # TODO: Rip out saved prompt input data
+ SAVED_PROMPTS_FILES=[]
+ SAVED_PROMPTS_CONTENT=[]
+ return {
+ 'required': {
+ 'prompt': ('STRING', {
+ 'multiline': True,
+ 'dynamicPrompts': True
+ }),
+ },
+ 'optional': {
+ "opt_model": ("MODEL",),
+ "opt_clip": ("CLIP",),
+ 'insert_lora': (['CHOOSE', 'DISABLE LORAS'] +
+ [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('loras')],),
+ 'insert_embedding': ([
+ 'CHOOSE',
+ ] + [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('embeddings')],),
+ 'insert_saved': ([
+ 'CHOOSE',
+ ] + SAVED_PROMPTS_FILES,),
+ },
+ 'hidden': {
+ 'values_insert_saved': (['CHOOSE'] + SAVED_PROMPTS_CONTENT,),
+ }
+ }
+
+ RETURN_TYPES = (
+ 'CONDITIONING',
+ 'MODEL',
+ 'CLIP',
+ 'STRING',
+ )
+ RETURN_NAMES = (
+ 'CONDITIONING',
+ 'MODEL',
+ 'CLIP',
+ 'TEXT',
+ )
+ FUNCTION = 'main'
+
+ def main(self,
+ prompt,
+ opt_model=None,
+ opt_clip=None,
+ insert_lora=None,
+ insert_embedding=None,
+ insert_saved=None,
+ values_insert_saved=None):
+ if insert_lora == 'DISABLE LORAS':
+ prompt, loras, skipped, unfound = get_and_strip_loras(prompt, log_node=NODE_NAME, silent=True)
+ log_node_info(
+ NODE_NAME,
+ f'Disabling all found loras ({len(loras)}) and stripping lora tags for TEXT output.')
+ elif opt_model is not None and opt_clip is not None:
+ prompt, loras, skipped, unfound = get_and_strip_loras(prompt, log_node=NODE_NAME)
+ if len(loras) > 0:
+ for lora in loras:
+ opt_model, opt_clip = LoraLoader().load_lora(opt_model, opt_clip, lora['lora'],
+ lora['strength'], lora['strength'])
+ log_node_success(NODE_NAME, f'Loaded "{lora["lora"]}" from prompt')
+ log_node_info(NODE_NAME, f'{len(loras)} Loras processed; stripping tags for TEXT output.')
+ elif ']*?)(?::(-?\d*(?:\.\d*)?))?>'
+ lora_paths = folder_paths.get_filename_list('loras')
+
+ matches = re.findall(pattern, prompt)
+
+ loras = []
+ unfound_loras = []
+ skipped_loras = []
+ for match in matches:
+ tag_path = match[0]
+
+ strength = float(match[1] if len(match) > 1 and len(match[1]) else 1.0)
+ if strength == 0:
+ if not silent:
+ log_node_info(log_node, f'Skipping "{tag_path}" with strength of zero')
+ skipped_loras.append({'lora': tag_path, 'strength': strength})
+ continue
+
+ lora_path = get_lora_by_filename(tag_path, lora_paths, log_node=None if silent else log_node)
+ if lora_path is None:
+ unfound_loras.append({'lora': tag_path, 'strength': strength})
+ continue
+
+ loras.append({'lora': lora_path, 'strength': strength})
+
+ return (re.sub(pattern, '', prompt), loras, skipped_loras, unfound_loras)
+
+
+# pylint: disable = too-many-return-statements, too-many-branches
+def get_lora_by_filename(file_path, lora_paths=None, log_node=None):
+ """Returns a lora by filename, looking for exactl paths and then fuzzier matching."""
+ lora_paths = lora_paths if lora_paths is not None else folder_paths.get_filename_list('loras')
+
+ if file_path in lora_paths:
+ return file_path
+
+ lora_paths_no_ext = [os.path.splitext(x)[0] for x in lora_paths]
+
+ # See if we've entered the exact path, but without the extension
+ if file_path in lora_paths_no_ext:
+ found = lora_paths[lora_paths_no_ext.index(file_path)]
+ return found
+
+ # Same check, but ensure file_path is without extension.
+ file_path_force_no_ext = os.path.splitext(file_path)[0]
+ if file_path_force_no_ext in lora_paths_no_ext:
+ found = lora_paths[lora_paths_no_ext.index(file_path_force_no_ext)]
+ return found
+
+ # See if we passed just the name, without paths.
+ lora_filenames_only = [os.path.basename(x) for x in lora_paths]
+ if file_path in lora_filenames_only:
+ found = lora_paths[lora_filenames_only.index(file_path)]
+ if log_node is not None:
+ log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+ return found
+
+ # Same, but force the input to be without paths
+ file_path_force_filename = os.path.basename(file_path)
+ lora_filenames_only = [os.path.basename(x) for x in lora_paths]
+ if file_path_force_filename in lora_filenames_only:
+ found = lora_paths[lora_filenames_only.index(file_path_force_filename)]
+ if log_node is not None:
+ log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+ return found
+
+ # Check the filenames and without extension.
+ lora_filenames_and_no_ext = [os.path.splitext(os.path.basename(x))[0] for x in lora_paths]
+ if file_path in lora_filenames_and_no_ext:
+ found = lora_paths[lora_filenames_and_no_ext.index(file_path)]
+ if log_node is not None:
+ log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+ return found
+
+ # And, one last forcing the input to be the same
+ file_path_force_filename_and_no_ext = os.path.splitext(os.path.basename(file_path))[0]
+ if file_path_force_filename_and_no_ext in lora_filenames_and_no_ext:
+ found = lora_paths[lora_filenames_and_no_ext.index(file_path_force_filename_and_no_ext)]
+ if log_node is not None:
+ log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+ return found
+
+ # Finally, super fuzzy, we'll just check if the input exists in the path at all.
+ for index, lora_path in enumerate(lora_paths):
+ if file_path in lora_path:
+ found = lora_paths[index]
+ if log_node is not None:
+ log_node_warn(log_node, f'Fuzzy-matched Lora input "{file_path}" to "{found}".')
+ return found
+
+ if log_node is not None:
+ log_node_warn(log_node, f'Lora "{file_path}" not found, skipping.')
+
+ return None
diff --git a/custom_nodes/rgthree-comfy/py/power_puter.py b/custom_nodes/rgthree-comfy/py/power_puter.py
new file mode 100644
index 0000000000000000000000000000000000000000..80cd7b016f4265d1784e961eaa2b9cf7477572cf
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/power_puter.py
@@ -0,0 +1,848 @@
+"""The Power Puter is a powerful node that can compute and evaluate Python-like code safely allowing
+for complex operations for primitives and workflow items for output. From string concatenation, to
+math operations, list comprehension, and node value output.
+
+Originally based off https://github.com/pythongosssss/ComfyUI-Custom-Scripts/blob/aac13aa7ce35b07d43633c3bbe654a38c00d74f5/py/math_expression.py
+under an MIT License https://github.com/pythongosssss/ComfyUI-Custom-Scripts/blob/aac13aa7ce35b07d43633c3bbe654a38c00d74f5/LICENSE
+"""
+
+import math
+import ast
+import json
+import random
+import dataclasses
+import re
+import time
+import operator as op
+import datetime
+import numpy as np
+import hashlib
+
+from typing import Any, Callable, Iterable, Optional, Union
+from types import MappingProxyType
+
+from .constants import get_category, get_name
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType, any_type, get_dict_value
+from .log import log_node_error, log_node_warn, log_node_info
+
+from .power_lora_loader import RgthreePowerLoraLoader
+
+from nodes import ImageBatch
+from comfy_extras.nodes_latent import LatentBatch
+
+
+class LoopBreak(Exception):
+ """A special error type that is caught in a loop for correct breaking behavior."""
+
+ def __init__(self):
+ super().__init__('Cannot use "break" outside of a loop.')
+
+
+class LoopContinue(Exception):
+ """A special error type that is caught in a loop for correct continue behavior."""
+
+ def __init__(self):
+ super().__init__('Cannot use "continue" outside of a loop.')
+
+
+@dataclasses.dataclass(frozen=True) # Note, kw_only=True is only python 3.10+
+class Function():
+ """Function data.
+
+ Attributes:
+ name: The name of the function as called from the node.
+ call: The callable (reference, lambda, etc), or a string if on _Puter instance.
+ args: A tuple that represents the minimum and maximum number of args (or arg for no limit).
+ """
+
+ name: str
+ call: Union[Callable, str]
+ args: tuple[int, Optional[int]]
+
+
+def purge_vram(purge_models=True):
+ """Purges vram and, optionally, unloads models."""
+ import gc
+ import torch
+ gc.collect()
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ torch.cuda.ipc_collect()
+ if purge_models:
+ import comfy
+ comfy.model_management.unload_all_models()
+ comfy.model_management.soft_empty_cache()
+
+
+def batch(*args):
+ """Batches multiple image or latents together."""
+
+ def check_is_latent(item) -> bool:
+ return isinstance(item, dict) and 'samples' in item
+
+ args = list(args)
+ result = args.pop(0)
+ is_latent = check_is_latent(result)
+ node = LatentBatch() if is_latent else ImageBatch()
+
+ for arg in args:
+ if is_latent != check_is_latent(arg):
+ raise ValueError(
+ f'batch() error: Expecting "{"LATENT" if is_latent else "IMAGE"}"'
+ f' but got "{"IMAGE" if is_latent else "LATENT"}".'
+ )
+ result = node.batch(result, arg)[0]
+ return result
+
+
+_BUILTIN_FN_PREFIX = '__rgthreefn.'
+
+
+def _get_built_in_fn_key(fn: Function) -> str:
+ """Returns a key for a built-in function."""
+ return f'{_BUILTIN_FN_PREFIX}{hash(fn.name)}'
+
+
+def _get_built_in_fn_by_key(fn_key: str):
+ """Returns the `Function` for the provided key (purposefully, not name)."""
+ if not fn_key.startswith(_BUILTIN_FN_PREFIX) or fn_key not in _BUILT_INS_BY_NAME_AND_KEY:
+ raise ValueError('No built in function found.')
+ return _BUILT_INS_BY_NAME_AND_KEY[fn_key]
+
+def sha264(message: str):
+ if isinstance(message, str):
+ return hashlib.sha256(message.encode()).hexdigest()
+ return None
+
+_BUILT_IN_FNS_LIST = [
+ Function(name="round", call=round, args=(1, 2)),
+ Function(name="ceil", call=math.ceil, args=(1, 1)),
+ Function(name="floor", call=math.floor, args=(1, 1)),
+ Function(name="sqrt", call=math.sqrt, args=(1, 1)),
+ Function(name="min", call=min, args=(2, None)),
+ Function(name="max", call=max, args=(2, None)),
+ Function(name=".random_int", call=random.randint, args=(2, 2)),
+ Function(name=".random_choice", call=random.choice, args=(1, 1)),
+ Function(name=".random_seed", call=random.seed, args=(1, 1)),
+ Function(name="re", call=re.compile, args=(1, 1)),
+ Function(name="len", call=len, args=(1, 1)),
+ Function(name="enumerate", call=enumerate, args=(1, 1)),
+ Function(name="range", call=range, args=(1, 3)),
+ # Casts
+ Function(name="int", call=int, args=(1, 1)),
+ Function(name="float", call=float, args=(1, 1)),
+ Function(name="str", call=str, args=(1, 1)),
+ Function(name="bool", call=bool, args=(1, 1)),
+ Function(name="list", call=list, args=(1, 1)),
+ Function(name="tuple", call=tuple, args=(1, 1)),
+ # Special
+ Function(name="dir", call=dir, args=(1, 1)),
+ Function(name="type", call=type, args=(1, 1)),
+ Function(name="print", call=print, args=(0, None)),
+ Function(name="sha264", call=sha264, args=(1, 1)),
+ # Comfy Specials
+ Function(name="node", call='_get_node', args=(0, 1)),
+ Function(name="nodes", call='_get_nodes', args=(0, 1)),
+ Function(name="input_node", call='_get_input_node', args=(0, 1)),
+ Function(name="purge_vram", call=purge_vram, args=(0, 1)),
+ Function(name="batch", call=batch, args=(2, None)),
+]
+
+_BUILT_INS_BY_NAME_AND_KEY = {
+ fn.name: fn for fn in _BUILT_IN_FNS_LIST
+} | {
+ key: fn for fn in _BUILT_IN_FNS_LIST if (key := _get_built_in_fn_key(fn))
+}
+
+_BUILT_INS = MappingProxyType(
+ {fn.name: key for fn in _BUILT_IN_FNS_LIST if (key := _get_built_in_fn_key(fn))} | {
+ 'random':
+ MappingProxyType({
+ 'int': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_int']),
+ 'choice': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_choice']),
+ 'seed': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_seed']),
+ }),
+ }
+)
+
+# A dict of types to blocked attributes/methods. Used to disallow file system access or other
+# invocations we may want to block. Necessary for any instance type that is possible to create from
+# the code or standard ComfyUI inputs.
+#
+# For instance, a user does not have access to the numpy module directly, so they cannot invoke
+# `numpy.save`. However, a user can access a numpy.ndarray instance from a tensor and, from there,
+# an attempt to call `tofile` or `dump` etc. would need to be blocked.
+_BLOCKED_METHODS_OR_ATTRS = MappingProxyType({np.ndarray: ['tofile', 'dump']})
+
+# Special functions by class type (called from the Attrs.)
+_SPECIAL_FUNCTIONS = {
+ RgthreePowerLoraLoader.NAME: {
+ # Get a list of the enabled loras from a power lora loader.
+ "loras": RgthreePowerLoraLoader.get_enabled_loras_from_prompt_node,
+ "triggers": RgthreePowerLoraLoader.get_enabled_triggers_from_prompt_node,
+ }
+}
+
+# Series of regex checks for usage of a non-deterministic function. Using these is fine, but means
+# the output can't be cached because it's either random, or is associated with another node that is
+# not connected to ours (like looking up a node in the prompt). Using these means downstream nodes
+# would always be run; that is fine for something like a final JSON output, but less so for a prompt
+# text.
+_NON_DETERMINISTIC_FUNCTION_CHECKS = [r'(? has_rand_int_or_choice.span()[0]:
+ log_node_warn(
+ _NODE_NAME,
+ f"Note, Power Puter (node #{kwargs['unique_id']}) cannot be cached b/c it's using a"
+ " non-deterministic function call. Matches function call for"
+ f" `{has_rand_int_or_choice.group(1)}`."
+ )
+ return time.time()
+ if has_rand_seed:
+ log_node_info(
+ _NODE_NAME,
+ f"Power Puter node #{kwargs['unique_id']} WILL be cached eventhough it's using"
+ f" a non-deterministic random call `{has_rand_int_or_choice.group(1)}` because it also"
+ f" calls `random.seed` first. NOTE: Please ensure that the seed value is deterministic."
+ )
+
+ return 42
+
+ def main(self, **kwargs):
+ """Does the nodes' work."""
+ code = kwargs['code']
+ unique_id = kwargs['unique_id']
+ pnginfo = kwargs['extra_pnginfo']
+ workflow = pnginfo["workflow"] if "workflow" in pnginfo else {"nodes": []}
+ prompt = kwargs['prompt']
+ dynprompt = kwargs['dynprompt']
+
+ outputs = get_dict_value(kwargs, 'outputs.outputs', None)
+ if not outputs:
+ output = kwargs.get('output', None)
+ if not output:
+ output = 'STRING'
+ outputs = [output]
+
+ ctx = {}
+ # Set variable names, defaulting to None instead of KeyErrors
+ for c in list('abcdefghijklmnopqrstuvwxyz'):
+ ctx[c] = kwargs[c] if c in kwargs else None
+
+ code = _update_code(kwargs['code'], unique_id=kwargs['unique_id'], log=True)
+
+ eva = _Puter(
+ code=code,
+ ctx=ctx,
+ workflow=workflow,
+ prompt=prompt,
+ dynprompt=dynprompt,
+ unique_id=unique_id
+ )
+ values = eva.execute()
+
+ # Check if we have multiple outputs that the returned value is a tuple and raise if not.
+ if len(outputs) > 1 and not isinstance(values, tuple):
+ t = re.sub(r'^<[a-z]*\s(.*?)>$', r'\1', str(type(values)))
+ msg = (
+ f"When using multiple node outputs, the value from the code should be a 'tuple' with the"
+ f" number of items equal to the number of outputs. But value from code was of type {t}."
+ )
+ log_node_error(_NODE_NAME, f'{msg}\n')
+ raise ValueError(msg)
+
+ if len(outputs) == 1:
+ values = (values,)
+
+ if len(values) > len(outputs):
+ log_node_warn(
+ _NODE_NAME,
+ f"Expected value from code to be tuple with {len(outputs)} items, but value from code had"
+ f" {len(values)} items. Extra values will be dropped."
+ )
+ elif len(values) < len(outputs):
+ log_node_warn(
+ _NODE_NAME,
+ f"Expected value from code to be tuple with {len(outputs)} items, but value from code had"
+ f" {len(values)} items. Extra outputs will be null."
+ )
+
+ # Now, we'll go over out return tuple, and cast as the output types.
+ response = []
+ for i, output in enumerate(outputs):
+ value = values[i] if len(values) > i else None
+ if value is not None:
+ if output == 'INT':
+ value = int(value)
+ elif output == 'FLOAT':
+ value = float(value)
+ # Accidentally defined "BOOL" when should have been "BOOLEAN."
+ # TODO: Can prob get rid of BOOl after a bit when UIs would be updated from sending
+ # BOOL incorrectly.
+ elif output in ('BOOL', 'BOOLEAN'):
+ value = bool(value)
+ elif output == 'STRING':
+ if isinstance(value, (dict, list)):
+ value = json.dumps(value, indent=2)
+ else:
+ value = str(value)
+ elif output == '*':
+ # Do nothing, the output will be passed as-is. This could be anything and it's up to the
+ # user to control the intended output, like passing through an input value, etc.
+ pass
+ response.append(value)
+ return tuple(response)
+
+
+class _Puter:
+ """The main computation evaluator, using ast.parse the code.
+
+ See https://www.basicexamples.com/example/python/ast for examples.
+ """
+
+ def __init__(self, *, code: str, ctx: dict[str, Any], workflow, prompt, dynprompt, unique_id):
+ ctx = ctx or {}
+ self._ctx = {**ctx}
+ self._code = code
+ self._workflow = workflow
+ self._prompt = prompt
+ self._unique_id = unique_id
+ self._dynprompt = dynprompt
+ # These are now expanded lazily when needed.
+ self._prompt_nodes = None
+ self._prompt_node = None
+
+ def execute(self, code=Optional[str]) -> Any:
+ """Evaluates a the code block."""
+
+ # Always store random state and initialize a new seed. We'll restore the state later.
+ initial_random_state = random.getstate()
+ random.seed(datetime.datetime.now().timestamp())
+ last_value = None
+ try:
+ code = code or self._code
+ node = ast.parse(self._code)
+ ctx = {**self._ctx}
+ for body in node.body:
+ last_value = self._eval_statement(body, ctx)
+ # If we got a return, then that's it folks.
+ if isinstance(body, ast.Return):
+ break
+ except:
+ random.setstate(initial_random_state)
+ raise
+ random.setstate(initial_random_state)
+ return last_value
+
+ def _get_prompt_nodes(self):
+ """Expands the prompt nodes lazily from the dynamic prompt.
+
+ https://github.com/comfyanonymous/ComfyUI/blob/fc657f471a29d07696ca16b566000e8e555d67d1/comfy_execution/graph.py#L22
+ """
+ if self._prompt_nodes is None:
+ self._prompt_nodes = []
+ if self._dynprompt:
+ all_ids = self._dynprompt.all_node_ids()
+ self._prompt_nodes = [{'id': k} | {**self._dynprompt.get_node(k)} for k in all_ids]
+ return self._prompt_nodes
+
+ def _get_prompt_node(self):
+ if self._prompt_nodes is None:
+ self._prompt_node = [n for n in self._get_prompt_nodes() if n['id'] == self._unique_id][0]
+ return self._prompt_node
+
+ def _get_nodes(self, node_id: Union[int, str, re.Pattern, None] = None) -> list[Any]:
+ """Get a list of the nodes that match the node_id, or all the nodes in the prompt."""
+ nodes = self._get_prompt_nodes().copy()
+ if not node_id:
+ return nodes
+
+ if isinstance(node_id, re.Pattern):
+ found = [n for n in nodes if re.search(node_id, get_dict_value(n, '_meta.title', ''))]
+ else:
+ node_id = str(node_id)
+ found = None
+ if re.match(r'\d+$', node_id):
+ found = [n for n in nodes if node_id == n['id']]
+ if not found:
+ found = [n for n in nodes if node_id == get_dict_value(n, '_meta.title', '')]
+ return found
+
+ def _get_node(self, node_id: Union[int, str, re.Pattern, None] = None) -> Union[Any, None]:
+ """Returns a prompt-node from the hidden prompt."""
+ if node_id is None:
+ return self._get_prompt_node()
+ nodes = self._get_nodes(node_id)
+ if nodes and len(nodes) > 1:
+ log_node_warn(_NODE_NAME, f"More than one node found for '{node_id}'. Returning first.")
+ return nodes[0] if nodes else None
+
+ def _get_input_node(self, input_name, node=None):
+ """Gets the (non-muted) node of an input connection from a node (default to the power puter)."""
+ node = node if node else self._get_prompt_node()
+ try:
+ connected_node_id = node['inputs'][input_name][0]
+ return [n for n in self._get_prompt_nodes() if n['id'] == connected_node_id][0]
+ except (TypeError, IndexError, KeyError):
+ log_node_warn(_NODE_NAME, f'No input node found for "{input_name}". ')
+ return None
+
+ def _eval_statement(self, stmt: ast.AST, ctx: dict, prev_stmt: Union[ast.AST, None] = None):
+ """Evaluates an ast.stmt."""
+
+ if '__returned__' in ctx:
+ return ctx['__returned__']
+
+ # print('\n\n----: _eval_statement')
+ # print(type(stmt))
+ # print(ctx)
+
+ if isinstance(stmt, (ast.FormattedValue, ast.Expr)):
+ return self._eval_statement(stmt.value, ctx=ctx)
+
+ if isinstance(stmt, (ast.Constant, ast.Num)):
+ return stmt.n
+
+ if isinstance(stmt, ast.BinOp):
+ left = self._eval_statement(stmt.left, ctx=ctx)
+ right = self._eval_statement(stmt.right, ctx=ctx)
+ return _OPERATORS[type(stmt.op)](left, right)
+
+ if isinstance(stmt, ast.BoolOp):
+ is_and = isinstance(stmt.op, ast.And)
+ is_or = isinstance(stmt.op, ast.Or)
+ stmt_value_eval = None
+ for stmt_value in stmt.values:
+ stmt_value_eval = self._eval_statement(stmt_value, ctx=ctx)
+ # If we're an and operator and have a falsyt value, then we stop and return. Likewise, if
+ # we're an or operator and have a truthy value, we can stop and return.
+ if (is_and and not stmt_value_eval) or (is_or and stmt_value_eval):
+ return stmt_value_eval
+ # Always return the last if we made it here w/o success.
+ return stmt_value_eval
+
+ if isinstance(stmt, ast.UnaryOp):
+ return _OPERATORS[type(stmt.op)](self._eval_statement(stmt.operand, ctx=ctx))
+
+ if isinstance(stmt, (ast.Attribute, ast.Subscript)):
+ # Like: node(14).inputs.sampler_name (Attribute)
+ # Like: node(14)['inputs']['sampler_name'] (Subscript)
+ item = self._eval_statement(stmt.value, ctx=ctx)
+ attr = None
+ # if hasattr(stmt, 'attr'):
+ if isinstance(stmt, ast.Attribute):
+ attr = stmt.attr
+ else:
+ # Slice could be a name or a constant; evaluate it
+ attr = self._eval_statement(stmt.slice, ctx=ctx)
+ # Check if we're blocking access to this attribute/method on this item type.
+ for typ, names in _BLOCKED_METHODS_OR_ATTRS.items():
+ if isinstance(item, typ) and isinstance(attr, str) and attr in names:
+ raise ValueError(f'Disallowed access to "{attr}" for type {typ}.')
+ try:
+ val = item[attr]
+ except (TypeError, IndexError, KeyError):
+ try:
+ val = getattr(item, attr)
+ except AttributeError:
+ # If we're a dict, then just return None instead of error; saves time.
+ if isinstance(item, dict):
+ # Any special cases in the _SPECIAL_FUNCTIONS
+ class_type = get_dict_value(item, "class_type")
+ if class_type in _SPECIAL_FUNCTIONS and attr in _SPECIAL_FUNCTIONS[class_type]:
+ val = _SPECIAL_FUNCTIONS[class_type][attr]
+ # If our previous statment was a Call, then send back a tuple of the callable and
+ # the evaluated item, and it will make the call; perhaps also adding other arguments
+ # only it knows about.
+ if isinstance(prev_stmt, ast.Call):
+ return (val, item)
+ val = val(item)
+ else:
+ val = None
+ else:
+ raise
+ return val
+
+ if isinstance(stmt, (ast.List, ast.Tuple)):
+ value = []
+ for elt in stmt.elts:
+ value.append(self._eval_statement(elt, ctx=ctx))
+ return tuple(value) if isinstance(stmt, ast.Tuple) else value
+
+ if isinstance(stmt, ast.Dict):
+ the_dict = {}
+ if stmt.keys:
+ if len(stmt.keys) != len(stmt.values):
+ raise ValueError('Expected same number of keys as values for dict.')
+ for i, k in enumerate(stmt.keys):
+ item_key = self._eval_statement(k, ctx=ctx)
+ item_value = self._eval_statement(stmt.values[i], ctx=ctx)
+ the_dict[item_key] = item_value
+ return the_dict
+
+ # f-strings: https://www.basicexamples.com/example/python/ast-JoinedStr
+ # Note, this will str() all evaluated items in the fstrings, and doesn't handle f-string
+ # directives, like padding, etc.
+ if isinstance(stmt, ast.JoinedStr):
+ vals = [str(self._eval_statement(v, ctx=ctx)) for v in stmt.values]
+ val = ''.join(vals)
+ return val
+
+ if isinstance(stmt, ast.Slice):
+ if not stmt.lower or not stmt.upper:
+ raise ValueError('Unhandled Slice w/o lower or upper.')
+ slice_lower = self._eval_statement(stmt.lower, ctx=ctx)
+ slice_upper = self._eval_statement(stmt.upper, ctx=ctx)
+ if stmt.step:
+ slice_step = self._eval_statement(stmt.step, ctx=ctx)
+ return slice(slice_lower, slice_upper, slice_step)
+ return slice(slice_lower, slice_upper)
+
+ if isinstance(stmt, ast.Name):
+ if stmt.id in ctx:
+ val = ctx[stmt.id]
+ return val
+ if stmt.id in _BUILT_INS:
+ val = _BUILT_INS[stmt.id]
+ return val
+ raise NameError(f"Name not found: {stmt.id}")
+
+ if isinstance(stmt, ast.For):
+ for_iter = self._eval_statement(stmt.iter, ctx=ctx)
+ for item in for_iter:
+ # Set the for var(s)
+ if isinstance(stmt.target, ast.Name):
+ ctx[stmt.target.id] = item
+ elif isinstance(stmt.target, ast.Tuple): # dict, like `for k, v in d.entries()`
+ for i, elt in enumerate(stmt.target.elts):
+ ctx[elt.id] = item[i]
+ bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+ breaked = False
+ for body in bodies:
+ # Catch any breaks or continues and handle inside the loop normally.
+ try:
+ value = self._eval_statement(body, ctx=ctx)
+ except (LoopBreak, LoopContinue) as e:
+ breaked = isinstance(e, LoopBreak)
+ break
+ if breaked:
+ break
+ return None
+
+ if isinstance(stmt, ast.While):
+ while self._eval_statement(stmt.test, ctx=ctx):
+ bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+ breaked = False
+ for body in bodies:
+ # Catch any breaks or continues and handle inside the loop normally.
+ try:
+ value = self._eval_statement(body, ctx=ctx)
+ except (LoopBreak, LoopContinue) as e:
+ breaked = isinstance(e, LoopBreak)
+ break
+ if breaked:
+ break
+ return None
+
+ if isinstance(stmt, ast.ListComp):
+ # Like: [v.lora for name, v in node(19).inputs.items() if name.startswith('lora_')]
+ # Like: [v.lower() for v in lora_list]
+ # Like: [v for v in l if v.startswith('B')]
+ # Like: [v.lower() for v in l if v.startswith('B') or v.startswith('F')]
+ # ---
+ # Like: [l for n in nodes(re('Loras')).values() if (l := n.loras)]
+ final_list = []
+
+ gen_ctx = {**ctx}
+
+ generators = [*stmt.generators]
+
+ def handle_gen(generators: list[ast.comprehension]):
+ gen = generators.pop(0)
+ if isinstance(gen.target, ast.Name):
+ gen_ctx[gen.target.id] = None
+ elif isinstance(gen.target, ast.Tuple): # dict, like `for k, v in d.entries()`
+ for elt in gen.target.elts:
+ gen_ctx[elt.id] = None
+ else:
+ raise ValueError('Na')
+
+ gen_iters = None
+ # A call, like my_dct.items(), or a named ctx list
+ if isinstance(gen.iter, ast.Call):
+ gen_iters = self._eval_statement(gen.iter, ctx=gen_ctx)
+ elif isinstance(gen.iter, (ast.Name, ast.Attribute, ast.List, ast.Tuple)):
+ gen_iters = self._eval_statement(gen.iter, ctx=gen_ctx)
+
+ if not isinstance(gen_iters, Iterable):
+ raise ValueError('No iteraors found for list comprehension')
+
+ for gen_iter in gen_iters:
+ if_ctx = {**gen_ctx}
+ if isinstance(gen.target, ast.Tuple): # dict, like `for k, v in d.entries()`
+ for i, elt in enumerate(gen.target.elts):
+ if_ctx[elt.id] = gen_iter[i]
+ else:
+ if_ctx[gen.target.id] = gen_iter
+ good = True
+ for ifcall in gen.ifs:
+ if not self._eval_statement(ifcall, ctx=if_ctx):
+ good = False
+ break
+ if not good:
+ continue
+ gen_ctx.update(if_ctx)
+ if len(generators):
+ handle_gen(generators)
+ else:
+ final_list.append(self._eval_statement(stmt.elt, gen_ctx))
+ generators.insert(0, gen)
+
+ handle_gen(generators)
+ return final_list
+
+ if isinstance(stmt, ast.Call):
+ call = None
+ args = []
+ kwargs = {}
+ if isinstance(stmt.func, ast.Attribute):
+ call = self._eval_statement(stmt.func, prev_stmt=stmt, ctx=ctx)
+ if isinstance(call, tuple):
+ args.append(call[1])
+ call = call[0]
+ if not call:
+ raise ValueError(f'No call for ast.Call {stmt.func}')
+
+ name = ''
+ if isinstance(stmt.func, ast.Name):
+ name = stmt.func.id
+ if name in _BUILT_INS:
+ call = _BUILT_INS[name]
+
+ if isinstance(call, str) and call.startswith(_BUILTIN_FN_PREFIX):
+ fn = _get_built_in_fn_by_key(call)
+ call = fn.call
+ if isinstance(call, str):
+ call = getattr(self, call)
+ num_args = len(stmt.args)
+ if num_args < fn.args[0] or (fn.args[1] is not None and num_args > fn.args[1]):
+ toErr = " or more" if fn.args[1] is None else f" to {fn.args[1]}"
+ raise SyntaxError(f"Invalid function call: {fn.name} requires {fn.args[0]}{toErr} args")
+
+ if not call:
+ raise ValueError(f'No call for ast.Call {name}')
+
+ for arg in stmt.args:
+ args.append(self._eval_statement(arg, ctx=ctx))
+ for kwarg in stmt.keywords:
+ kwargs[kwarg.arg] = self._eval_statement(kwarg.value, ctx=ctx)
+ return call(*args, **kwargs)
+
+ if isinstance(stmt, ast.Compare):
+ l = self._eval_statement(stmt.left, ctx=ctx)
+ r = self._eval_statement(stmt.comparators[0], ctx=ctx)
+ if isinstance(stmt.ops[0], ast.Eq):
+ return 1 if l == r else 0
+ if isinstance(stmt.ops[0], ast.NotEq):
+ return 1 if l != r else 0
+ if isinstance(stmt.ops[0], ast.Gt):
+ return 1 if l > r else 0
+ if isinstance(stmt.ops[0], ast.GtE):
+ return 1 if l >= r else 0
+ if isinstance(stmt.ops[0], ast.Lt):
+ return 1 if l < r else 0
+ if isinstance(stmt.ops[0], ast.LtE):
+ return 1 if l <= r else 0
+ if isinstance(stmt.ops[0], ast.In):
+ return 1 if l in r else 0
+ if isinstance(stmt.ops[0], ast.Is):
+ return 1 if l is r else 0
+ if isinstance(stmt.ops[0], ast.IsNot):
+ return 1 if l is not r else 0
+ raise NotImplementedError("Operator " + stmt.ops[0].__class__.__name__ + " not supported.")
+
+ if isinstance(stmt, (ast.If, ast.IfExp)):
+ value = self._eval_statement(stmt.test, ctx=ctx)
+ if value:
+ # ast.If is a list, ast.IfExp is an object.
+ bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+ for body in bodies:
+ value = self._eval_statement(body, ctx=ctx)
+ elif stmt.orelse:
+ # ast.If is a list, ast.IfExp is an object. TBH, I don't know why the If is a list, it's
+ # only ever one item AFAICT.
+ orelses = stmt.orelse if isinstance(stmt.orelse, list) else [stmt.orelse]
+ for orelse in orelses:
+ value = self._eval_statement(orelse, ctx=ctx)
+ return value
+
+ # Assign a variable and add it to our ctx.
+ if isinstance(stmt, (ast.Assign, ast.AugAssign)):
+ if isinstance(stmt, ast.AugAssign):
+ left = self._eval_statement(stmt.target, ctx=ctx)
+ right = self._eval_statement(stmt.value, ctx=ctx)
+ value = _OPERATORS[type(stmt.op)](left, right)
+ target = stmt.target
+ else:
+ value = self._eval_statement(stmt.value, ctx=ctx)
+ if len(stmt.targets) != 1:
+ raise ValueError('Expected length of assign targets to be 1')
+ target = stmt.targets[0]
+
+ if isinstance(target, ast.Tuple): # like `a, z = (1,2)` (ast.Assign only)
+ for i, elt in enumerate(target.elts):
+ ctx[elt.id] = value[i]
+ elif isinstance(target, ast.Name): # like `a = 1``
+ ctx[target.id] = value
+ elif isinstance(target, ast.Subscript) and isinstance(target.value, ast.Name): # `a[0] = 1`
+ ctx[target.value.id][self._eval_statement(target.slice, ctx=ctx)] = value
+ else:
+ raise ValueError('Unhandled target type for Assign.')
+ return value
+
+ # For assigning a var in a list comprehension.
+ # Like [name for node in node_list if (name := node.name)]
+ if isinstance(stmt, ast.NamedExpr):
+ value = self._eval_statement(stmt.value, ctx=ctx)
+ ctx[stmt.target.id] = value
+ return value
+
+ if isinstance(stmt, ast.Return):
+ if stmt.value is None:
+ value = None
+ else:
+ value = self._eval_statement(stmt.value, ctx=ctx)
+ # Mark that we have a return value, as we may be deeper in evaluation, like going through an
+ # if condition's body.
+ ctx['__returned__'] = value
+ return value
+
+ # Raise an error for break or continue, which should be caught and handled inside of loops,
+ # otherwise the error will be raised (which is desired when used outside of a loop).
+ if isinstance(stmt, ast.Break):
+ raise LoopBreak()
+ if isinstance(stmt, ast.Continue):
+ raise LoopContinue()
+
+ # Literally nothing.
+ if isinstance(stmt, ast.Pass):
+ return None
+
+ raise TypeError(stmt)
diff --git a/custom_nodes/rgthree-comfy/py/pyproject.py b/custom_nodes/rgthree-comfy/py/pyproject.py
new file mode 100644
index 0000000000000000000000000000000000000000..26eab343a142079580af83d990c8e0d2cd28057f
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/pyproject.py
@@ -0,0 +1,70 @@
+import os
+import re
+import json
+
+from .utils import set_dict_value
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+_FILE_PY_PROJECT = os.path.join(_THIS_DIR, '..', 'pyproject.toml')
+
+
+def read_pyproject():
+ """Reads the pyproject.toml file"""
+ data = {}
+ last_key = ''
+ lines = []
+ # I'd like to use tomllib/tomli, but I'd much rather not introduce dependencies since I've yet to
+ # need to and not everyone may have 3.11. We've got a controlled config file anyway.
+ with open(_FILE_PY_PROJECT, "r", encoding='utf-8') as f:
+ lines = f.readlines()
+ for line in lines:
+ line = line.strip()
+ if re.match(r'\[([^\]]+)\]$', line):
+ last_key = line[1:-1]
+ set_dict_value(data, last_key, data[last_key] if last_key in data else {})
+ continue
+ value_matches = re.match(r'^([^\s\=]+)\s*=\s*(.*)$', line)
+ if value_matches:
+ try:
+ set_dict_value(data, f'{last_key}.{value_matches[1]}', json.loads(value_matches[2]))
+ except json.decoder.JSONDecodeError:
+ # We don't handle multiline arrays or curly brackets; that's ok, we know the file.
+ pass
+
+ return data
+
+
+_DATA = read_pyproject()
+
+# We would want these to fail if they don't exist, so assume they do.
+VERSION: str = _DATA['project']['version']
+NAME: str = _DATA['project']['name']
+LOGO_URL: str = _DATA['tool']['comfy']['Icon']
+
+if not LOGO_URL.endswith('.svg'):
+ raise ValueError('Bad logo url.')
+
+LOGO_SVG = None
+async def get_logo_svg():
+ import aiohttp
+ global LOGO_SVG
+ if LOGO_SVG is not None:
+ return LOGO_SVG
+ # Fetch the logo so we have any updated markup.
+ try:
+ async with aiohttp.ClientSession(
+ trust_env=True, connector=aiohttp.TCPConnector(verify_ssl=True)
+ ) as session:
+ headers = {
+ "user-agent": f"rgthree-comfy/{VERSION}",
+ 'Cache-Control': 'no-cache',
+ 'Pragma': 'no-cache',
+ 'Expires': '0'
+ }
+ async with session.get(LOGO_URL, headers=headers) as resp:
+ LOGO_SVG = await resp.text()
+ LOGO_SVG = re.sub(r'(id="bg".*fill=)"[^\"]+"', r'\1"{bg}"', LOGO_SVG)
+ LOGO_SVG = re.sub(r'(id="fg".*fill=)"[^\"]+"', r'\1"{fg}"', LOGO_SVG)
+ except Exception:
+ LOGO_SVG = ''
+ return LOGO_SVG
diff --git a/custom_nodes/rgthree-comfy/py/sdxl_empty_latent_image.py b/custom_nodes/rgthree-comfy/py/sdxl_empty_latent_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..c367aaa6931b32060be2032c19a668e02469c941
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/sdxl_empty_latent_image.py
@@ -0,0 +1,63 @@
+from nodes import EmptyLatentImage
+from .constants import get_category, get_name
+
+
+class RgthreeSDXLEmptyLatentImage:
+
+ NAME = get_name('SDXL Empty Latent Image')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "dimensions": (
+ [
+ # 'Custom',
+ '1536 x 640 (landscape)',
+ '1344 x 768 (landscape)',
+ '1216 x 832 (landscape)',
+ '1152 x 896 (landscape)',
+ '1024 x 1024 (square)',
+ ' 896 x 1152 (portrait)',
+ ' 832 x 1216 (portrait)',
+ ' 768 x 1344 (portrait)',
+ ' 640 x 1536 (portrait)',
+ ],
+ {
+ "default": '1024 x 1024 (square)'
+ }),
+ "clip_scale": ("FLOAT", {
+ "default": 2.0,
+ "min": 1.0,
+ "max": 10.0,
+ "step": .5
+ }),
+ "batch_size": ("INT", {
+ "default": 1,
+ "min": 1,
+ "max": 64
+ }),
+ },
+ # "optional": {
+ # "custom_width": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 64}),
+ # "custom_height": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 64}),
+ # }
+ }
+
+ RETURN_TYPES = ("LATENT", "INT", "INT")
+ RETURN_NAMES = ("LATENT", "CLIP_WIDTH", "CLIP_HEIGHT")
+ FUNCTION = "generate"
+
+ def generate(self, dimensions, clip_scale, batch_size):
+ """Generates the latent and exposes the clip_width and clip_height"""
+ if True:
+ result = [x.strip() for x in dimensions.split('x')]
+ width = int(result[0])
+ height = int(result[1].split(' ')[0])
+ latent = EmptyLatentImage().generate(width, height, batch_size)[0]
+ return (
+ latent,
+ int(width * clip_scale),
+ int(height * clip_scale),
+ )
diff --git a/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_postive.py b/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_postive.py
new file mode 100644
index 0000000000000000000000000000000000000000..d070da03be21354517cc283eca199f0510b0e6f8
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_postive.py
@@ -0,0 +1,178 @@
+import os
+import re
+from nodes import MAX_RESOLUTION
+from comfy_extras.nodes_clip_sdxl import CLIPTextEncodeSDXL
+
+from .log import log_node_warn, log_node_info, log_node_success
+from .constants import get_category, get_name
+from .power_prompt_utils import get_and_strip_loras
+from nodes import LoraLoader, CLIPTextEncode
+import folder_paths
+
+NODE_NAME = get_name('SDXL Power Prompt - Positive')
+
+
+class RgthreeSDXLPowerPromptPositive:
+ """The Power Prompt for positive conditioning."""
+
+ NAME = NODE_NAME
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ # Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully,
+ # TODO: Rip out saved prompt input data
+ SAVED_PROMPTS_FILES=[]
+ SAVED_PROMPTS_CONTENT=[]
+ return {
+ 'required': {
+ 'prompt_g': ('STRING', {
+ 'multiline': True,
+ 'dynamicPrompts': True
+ }),
+ 'prompt_l': ('STRING', {
+ 'multiline': True,
+ 'dynamicPrompts': True
+ }),
+ },
+ 'optional': {
+ "opt_model": ("MODEL",),
+ "opt_clip": ("CLIP",),
+ "opt_clip_width": ("INT", {
+ "forceInput": True,
+ "default": 1024.0,
+ "min": 0,
+ "max": MAX_RESOLUTION
+ }),
+ "opt_clip_height": ("INT", {
+ "forceInput": True,
+ "default": 1024.0,
+ "min": 0,
+ "max": MAX_RESOLUTION
+ }),
+ 'insert_lora': (['CHOOSE', 'DISABLE LORAS'] +
+ [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('loras')],),
+ 'insert_embedding': ([
+ 'CHOOSE',
+ ] + [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('embeddings')],),
+ 'insert_saved': ([
+ 'CHOOSE',
+ ] + SAVED_PROMPTS_FILES,),
+ # We'll hide these in the UI for now.
+ "target_width": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "target_height": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "crop_width": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "crop_height": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ },
+ 'hidden': {
+ 'values_insert_saved': (['CHOOSE'] + SAVED_PROMPTS_CONTENT,),
+ }
+ }
+
+ RETURN_TYPES = ('CONDITIONING', 'MODEL', 'CLIP', 'STRING', 'STRING')
+ RETURN_NAMES = ('CONDITIONING', 'MODEL', 'CLIP', 'TEXT_G', 'TEXT_L')
+ FUNCTION = 'main'
+
+ def main(self,
+ prompt_g,
+ prompt_l,
+ opt_model=None,
+ opt_clip=None,
+ opt_clip_width=None,
+ opt_clip_height=None,
+ insert_lora=None,
+ insert_embedding=None,
+ insert_saved=None,
+ target_width=-1,
+ target_height=-1,
+ crop_width=-1,
+ crop_height=-1,
+ values_insert_saved=None):
+
+ if insert_lora == 'DISABLE LORAS':
+ prompt_g, loras_g, _skipped, _unfound = get_and_strip_loras(prompt_g,
+ True,
+ log_node=self.NAME)
+ prompt_l, loras_l, _skipped, _unfound = get_and_strip_loras(prompt_l,
+ True,
+ log_node=self.NAME)
+ loras = loras_g + loras_l
+ log_node_info(
+ NODE_NAME,
+ f'Disabling all found loras ({len(loras)}) and stripping lora tags for TEXT output.')
+ elif opt_model is not None and opt_clip is not None:
+ prompt_g, loras_g, _skipped, _unfound = get_and_strip_loras(prompt_g, log_node=self.NAME)
+ prompt_l, loras_l, _skipped, _unfound = get_and_strip_loras(prompt_l, log_node=self.NAME)
+ loras = loras_g + loras_l
+ if len(loras) > 0:
+ for lora in loras:
+ opt_model, opt_clip = LoraLoader().load_lora(opt_model, opt_clip, lora['lora'],
+ lora['strength'], lora['strength'])
+ log_node_success(NODE_NAME, f'Loaded "{lora["lora"]}" from prompt')
+ log_node_info(NODE_NAME, f'{len(loras)} Loras processed; stripping tags for TEXT output.')
+ elif ' 0 else opt_clip_width
+ target_height = target_height if target_height and target_height > 0 else opt_clip_height
+ crop_width = crop_width if crop_width and crop_width > 0 else 0
+ crop_height = crop_height if crop_height and crop_height > 0 else 0
+ try:
+ conditioning = CLIPTextEncodeSDXL().encode(opt_clip, opt_clip_width, opt_clip_height,
+ crop_width, crop_height, target_width,
+ target_height, prompt_g, prompt_l)[0]
+ except Exception:
+ do_regular_clip_text_encode = True
+ log_node_info(
+ self.NAME,
+ 'Exception while attempting to CLIPTextEncodeSDXL, will fall back to standard encoding.'
+ )
+ else:
+ log_node_info(
+ self.NAME,
+ 'CLIP supplied, but not CLIP_WIDTH and CLIP_HEIGHT. Text encoding will use standard ' +
+ 'encoding with prompt_g and prompt_l concatenated.')
+
+ if not do_regular_clip_text_encode:
+ conditioning = CLIPTextEncode().encode(
+ opt_clip, f'{prompt_g if prompt_g else ""}\n{prompt_l if prompt_l else ""}')[0]
+ return conditioning
diff --git a/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_simple.py b/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_simple.py
new file mode 100644
index 0000000000000000000000000000000000000000..9774d878359a52a313d7ec5f42a5c795989cc7cd
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/sdxl_power_prompt_simple.py
@@ -0,0 +1,106 @@
+"""A simpler SDXL Power Prompt that doesn't load Loras, like for negative."""
+import os
+import re
+import folder_paths
+from nodes import MAX_RESOLUTION, LoraLoader
+from comfy_extras.nodes_clip_sdxl import CLIPTextEncodeSDXL
+from .sdxl_power_prompt_postive import RgthreeSDXLPowerPromptPositive
+
+from .log import log_node_warn, log_node_info, log_node_success
+
+from .constants import get_category, get_name
+
+NODE_NAME = get_name('SDXL Power Prompt - Simple / Negative')
+
+
+class RgthreeSDXLPowerPromptSimple(RgthreeSDXLPowerPromptPositive):
+ """A simpler SDXL Power Prompt that doesn't handle Loras."""
+
+ NAME = NODE_NAME
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ # Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully,
+ # TODO: Rip out saved prompt input data
+ SAVED_PROMPTS_FILES=[]
+ SAVED_PROMPTS_CONTENT=[]
+ return {
+ 'required': {
+ 'prompt_g': ('STRING', {
+ 'multiline': True,
+ 'dynamicPrompts': True
+ }),
+ 'prompt_l': ('STRING', {
+ 'multiline': True,
+ 'dynamicPrompts': True
+ }),
+ },
+ 'optional': {
+ "opt_clip": ("CLIP",),
+ "opt_clip_width": ("INT", {
+ "forceInput": True,
+ "default": 1024.0,
+ "min": 0,
+ "max": MAX_RESOLUTION
+ }),
+ "opt_clip_height": ("INT", {
+ "forceInput": True,
+ "default": 1024.0,
+ "min": 0,
+ "max": MAX_RESOLUTION
+ }),
+ 'insert_embedding': ([
+ 'CHOOSE',
+ ] + [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('embeddings')],),
+ 'insert_saved': ([
+ 'CHOOSE',
+ ] + SAVED_PROMPTS_FILES,),
+ # We'll hide these in the UI for now.
+ "target_width": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "target_height": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "crop_width": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ "crop_height": ("INT", {
+ "default": -1,
+ "min": -1,
+ "max": MAX_RESOLUTION
+ }),
+ },
+ 'hidden': {
+ 'values_insert_saved': (['CHOOSE'] + SAVED_PROMPTS_CONTENT,),
+ }
+ }
+
+ RETURN_TYPES = ('CONDITIONING', 'STRING', 'STRING')
+ RETURN_NAMES = ('CONDITIONING', 'TEXT_G', 'TEXT_L')
+ FUNCTION = 'main'
+
+ def main(self,
+ prompt_g,
+ prompt_l,
+ opt_clip=None,
+ opt_clip_width=None,
+ opt_clip_height=None,
+ insert_embedding=None,
+ insert_saved=None,
+ target_width=-1,
+ target_height=-1,
+ crop_width=-1,
+ crop_height=-1,
+ values_insert_saved=None):
+
+ conditioning = self.get_conditioning(prompt_g, prompt_l, opt_clip, opt_clip_width,
+ opt_clip_height, target_width, target_height, crop_width, crop_height)
+ return (conditioning, prompt_g, prompt_l)
diff --git a/custom_nodes/rgthree-comfy/py/seed.py b/custom_nodes/rgthree-comfy/py/seed.py
new file mode 100644
index 0000000000000000000000000000000000000000..b470f213357e12567296c9d9d191174944c0451f
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/seed.py
@@ -0,0 +1,135 @@
+"""See node."""
+import random
+from datetime import datetime
+
+from .utils_graph import get_worflow_node
+
+from .constants import get_category, get_name
+from .log import log_node_warn, log_node_info
+
+# Some extension must be setting a seed as server-generated seeds were not random. We'll set a new
+# seed and use that state going forward.
+initial_random_state = random.getstate()
+random.seed(datetime.now().timestamp())
+rgthree_seed_random_state = random.getstate()
+random.setstate(initial_random_state)
+
+
+def new_random_seed():
+ """ Gets a new random seed from the rgthree_seed_random_state and resetting the previous state."""
+ global rgthree_seed_random_state
+ prev_random_state = random.getstate()
+ random.setstate(rgthree_seed_random_state)
+ seed = random.randint(1, 1125899906842624)
+ rgthree_seed_random_state = random.getstate()
+ random.setstate(prev_random_state)
+ return seed
+
+
+class RgthreeSeed:
+ """Seed node."""
+
+ NAME = get_name('Seed')
+ CATEGORY = get_category()
+
+ @classmethod
+ def INPUT_TYPES(cls): # pylint: disable = invalid-name, missing-function-docstring
+ return {
+ "required": {
+ "seed": ("INT", {
+ "default": 0,
+ "min": -1125899906842624,
+ "max": 1125899906842624
+ }),
+ },
+ "hidden": {
+ "prompt": "PROMPT",
+ "extra_pnginfo": "EXTRA_PNGINFO",
+ "unique_id": "UNIQUE_ID",
+ },
+ }
+
+ RETURN_TYPES = ("INT",)
+ RETURN_NAMES = ("SEED",)
+ FUNCTION = "main"
+
+ @classmethod
+ def IS_CHANGED(cls, seed, prompt=None, extra_pnginfo=None, unique_id=None):
+ """Forces a changed state if we happen to get a special seed, as if from the API directly."""
+ if seed in (-1, -2, -3):
+ # This isn't used, but a different value than previous will force it to be "changed"
+ return new_random_seed()
+ return seed
+
+ def main(self, seed=0, prompt=None, extra_pnginfo=None, unique_id=None):
+ """Returns the passed seed on execution."""
+
+ # We generate random seeds on the frontend in the seed node before sending the workflow in for
+ # many reasons. However, if we want to use this in an API call without changing the seed before
+ # sending, then users _could_ pass in "-1" and get a random seed used and added to the metadata.
+ # Though, this should likely be discouraged for several reasons (thus, a lot of logging).
+ if seed in (-1, -2, -3):
+ log_node_warn(
+ self.NAME,
+ f'Got "{seed}" as passed seed. ' +
+ 'This shouldn\'t happen when queueing from the ComfyUI frontend.',
+ msg_color="YELLOW"
+ )
+ if seed in (-2, -3):
+ log_node_warn(
+ self.NAME,
+ f'Cannot {"increment" if seed == -2 else "decrement"} seed from ' +
+ 'server, but will generate a new random seed.',
+ msg_color="YELLOW"
+ )
+
+ original_seed = seed
+ seed = new_random_seed()
+ log_node_info(self.NAME, f'Server-generated random seed {seed} and saving to workflow.')
+ log_node_warn(
+ self.NAME,
+ f'NOTE: Re-queues passing in "{seed}" and server-generated random seed won\'t be cached.',
+ msg_color="YELLOW"
+ )
+
+ if unique_id is None:
+ log_node_warn(
+ self.NAME, 'Cannot save server-generated seed to image metadata because ' +
+ 'the node\'s id was not provided.'
+ )
+ else:
+ if extra_pnginfo is None:
+ log_node_warn(
+ self.NAME, 'Cannot save server-generated seed to image workflow ' +
+ 'metadata because workflow was not provided.'
+ )
+ else:
+ log_node_info(self.NAME, f'Looking for Seed node with id "{unique_id}"')
+ workflow_node = get_worflow_node(extra_pnginfo, str(unique_id))
+ if workflow_node is None or 'widgets_values' not in workflow_node:
+ log_node_warn(
+ self.NAME, 'Cannot save server-generated seed to image workflow ' +
+ 'metadata because node was not found in the provided workflow.'
+ )
+ else:
+ for index, widget_value in enumerate(workflow_node['widgets_values']):
+ if widget_value == original_seed:
+ workflow_node['widgets_values'][index] = seed
+
+ if prompt is None:
+ log_node_warn(
+ self.NAME, 'Cannot save server-generated seed to image API prompt ' +
+ 'metadata because prompt was not provided.'
+ )
+ else:
+ prompt_node = prompt[str(unique_id)]
+ if prompt_node is None or 'inputs' not in prompt_node or 'seed' not in prompt_node[
+ 'inputs']:
+ log_node_warn(
+ self.NAME, 'Cannot save server-generated seed to image workflow ' +
+ 'metadata because node was not found in the provided workflow.'
+ )
+ else:
+ prompt_node['inputs']['seed'] = seed
+
+ return (seed,)
diff --git a/custom_nodes/rgthree-comfy/py/server/rgthree_server.py b/custom_nodes/rgthree-comfy/py/server/rgthree_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe42165e463429cd34a898b7a118ec7ebad03ded
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/server/rgthree_server.py
@@ -0,0 +1,48 @@
+import os
+from aiohttp import web
+from server import PromptServer
+
+from ..config import get_config_value
+from ..log import log
+from .utils_server import set_default_page_resources, set_default_page_routes, get_param
+from .routes_config import *
+from .routes_model_info import *
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DIR_WEB = os.path.abspath(f'{THIS_DIR}/../../web/')
+
+routes = PromptServer.instance.routes
+
+# Sometimes other pages (link_fixer, etc.) may want to import JS from the comfyui
+# directory. To allows TS to resolve like '../comfyui/file.js', we'll also resolve any module HTTP
+# to these routes.
+set_default_page_resources("comfyui", routes)
+set_default_page_resources("common", routes)
+set_default_page_resources("lib", routes)
+
+set_default_page_routes("link_fixer", routes)
+if get_config_value('unreleased.models_page.enabled') is True:
+ set_default_page_routes("models", routes)
+
+
+@routes.get('/rgthree/api/print')
+async def api_print(request):
+ """Logs a user message to the terminal."""
+
+ message_type = get_param(request, 'type')
+ if message_type == 'PRIMITIVE_REROUTE':
+ log(
+ "You are using rgthree-comfy reroutes with a ComfyUI Primitive node. Unfortunately, ComfyUI "
+ "has removed support for this. While rgthree-comfy has a best-effort support fallback for "
+ "now, it may no longer work as expected and is strongly recommended you either replace the "
+ "Reroute node using ComfyUI's reroute node, or refrain from using the Primitive node "
+ "(you can always use the rgthree-comfy \"Power Primitive\" for non-combo primitives).",
+ prefix="Reroute",
+ color="YELLOW",
+ id=message_type,
+ at_most_secs=20
+ )
+ else:
+ log("Unknown log type from api", prefix="rgthree-comfy",color ="YELLOW")
+
+ return web.json_response({})
diff --git a/custom_nodes/rgthree-comfy/py/server/routes_config.py b/custom_nodes/rgthree-comfy/py/server/routes_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..74e7e1e29688ad52c018906321af8e7dc1e67321
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/server/routes_config.py
@@ -0,0 +1,67 @@
+import json
+import re
+from aiohttp import web
+
+from server import PromptServer
+
+from ..pyproject import get_logo_svg
+from .utils_server import is_param_truthy, get_param
+from ..config import get_config, set_user_config, refresh_config
+
+routes = PromptServer.instance.routes
+
+
+@routes.get('/rgthree/config.js')
+def api_get_user_config_file(request):
+ """ Returns the user configuration as a javascript file. """
+ data_str = json.dumps(get_config(), sort_keys=True, indent=2, separators=(",", ": "))
+ text = f'export const rgthreeConfig = {data_str}'
+ return web.Response(text=text, content_type='application/javascript')
+
+
+@routes.get('/rgthree/api/config')
+def api_get_user_config(request):
+ """ Returns the user configuration. """
+ if is_param_truthy(request, 'refresh'):
+ refresh_config()
+ return web.json_response(get_config())
+
+
+@routes.post('/rgthree/api/config')
+async def api_set_user_config(request):
+ """ Returns the user configuration. """
+ post = await request.post()
+ data = json.loads(post.get("json"))
+ set_user_config(data)
+ return web.json_response({"status": "ok"})
+
+
+@routes.get('/rgthree/logo.svg')
+async def get_logo(request, as_markup=False):
+ """ Returns the rgthree logo with color config. """
+ bg = get_param(request, 'bg', 'transparent')
+ fg = get_param(request, 'fg', '#111111')
+ w = get_param(request, 'w')
+ h = get_param(request, 'h')
+ css_class = get_param(request, 'cssClass')
+ svg = await get_logo_svg()
+ resp = svg.format(bg=bg, fg=fg)
+ if w is not None:
+ resp = re.sub(r'(]*?)width="[^\"]+"', r'\1', resp)
+ if str(w).isnumeric():
+ resp = re.sub(r']*?)height="[^\"]+"', r'\1', resp)
+ if str(h).isnumeric():
+ resp = re.sub(r' 1 else '.'} "
+ "ComfyUI thinks they exist, but they were not found on the filesystem.",
+ prefix="Power Lora Loader",
+ color="YELLOW",
+ id=f'no_file_details_{model_type}',
+ at_most_secs=30
+ )
+ return web.json_response(response)
+
+ return web.json_response(list(files))
+
+
+@routes.get('/rgthree/api/{type}/info')
+async def api_get_models_info(request):
+ """Returns a list model info; either all or a specific ones if provided a 'files' param.
+
+ If a `light` param is specified and not falsy, no metadata will be fetched.
+ """
+ if _check_valid_model_type(request):
+ return _check_valid_model_type(request)
+
+ model_type = request.match_info['type']
+ files_param = get_param(request, 'files')
+ maybe_fetch_metadata = files_param is not None
+ if not is_param_falsy(request, 'light'):
+ maybe_fetch_metadata = False
+ api_response = await models_info_response(
+ request, model_type, maybe_fetch_metadata=maybe_fetch_metadata
+ )
+ return web.json_response(api_response)
+
+
+@routes.get('/rgthree/api/{type}/info/refresh')
+async def api_get_refresh_get_models_info(request):
+ """Refreshes model info; either all or specific ones if provided a 'files' param. """
+ if _check_valid_model_type(request):
+ return _check_valid_model_type(request)
+
+ model_type = request.match_info['type']
+ api_response = await models_info_response(
+ request, model_type, maybe_fetch_civitai=True, maybe_fetch_metadata=True
+ )
+ return web.json_response(api_response)
+
+
+@routes.get('/rgthree/api/{type}/info/clear')
+async def api_get_delete_model_info(request):
+ """Clears model info from the filesystem for the provided file."""
+ if _check_valid_model_type(request):
+ return _check_valid_model_type(request)
+
+ api_response = {'status': 200}
+ model_type = request.match_info['type']
+ files_param = get_param(request, 'files')
+ if files_param is not None:
+ files_param = files_param.split(',')
+ del_info = not is_param_falsy(request, 'del_info')
+ del_metadata = not is_param_falsy(request, 'del_metadata')
+ del_civitai = not is_param_falsy(request, 'del_civitai')
+ if not files_param:
+ api_response['status'] = '404'
+ api_response['error'] = f'No file provided. Please pass files=ALL to clear {model_type} info.'
+ else:
+ if len(files_param) == 1 and files_param[
+ 0] == "ALL": # Force the user to supply files=ALL to trigger all clearing.
+ files_param = folder_paths.get_filename_list(model_type)
+ for file_param in files_param:
+ await delete_model_info(
+ file_param,
+ model_type,
+ del_info=del_info,
+ del_metadata=del_metadata,
+ del_civitai=del_civitai
+ )
+ return web.json_response(api_response)
+
+
+@routes.post('/rgthree/api/{type}/info')
+async def api_post_save_model_data(request):
+ """Saves data to a model by name. """
+ if _check_valid_model_type(request):
+ return _check_valid_model_type(request)
+
+ model_type = request.match_info['type']
+ api_response = {'status': 200}
+ file_param = get_param(request, 'file')
+ if file_param is None:
+ api_response['status'] = '404'
+ api_response['error'] = 'No model found at path'
+ else:
+ post = await request.post()
+ await set_model_info_partial(file_param, model_type, json.loads(post.get("json")))
+ info_data = await get_model_info(file_param, model_type)
+ api_response['data'] = info_data
+ return web.json_response(api_response)
+
+
+@routes.get('/rgthree/api/{type}/img')
+async def api_get_models_info_img(request):
+ """ Returns an image response if one exists for the model. """
+ if _check_valid_model_type(request):
+ return _check_valid_model_type(request)
+
+ model_type = request.match_info['type']
+ file_param = get_param(request, 'file')
+ file_path = folder_paths.get_full_path(model_type, file_param)
+ if not path_exists(file_path):
+ file_path = abspath(file_path)
+ img_path = None
+ for ext in ['jpg', 'png', 'jpeg']:
+ try_path = f'{os.path.splitext(file_path)[0]}.{ext}'
+ if path_exists(try_path):
+ img_path = try_path
+ break
+
+ if not path_exists(img_path):
+ api_response = {}
+ api_response['status'] = '404'
+ api_response['error'] = 'No model found at path'
+ return web.json_response(api_response)
+
+ return web.FileResponse(img_path)
+
+
+async def models_info_response(
+ request, model_type, maybe_fetch_civitai=False, maybe_fetch_metadata=False
+):
+ """Gets model info for all or a single model type."""
+ api_response = {'status': 200, 'data': []}
+ light = not is_param_falsy(request, 'light')
+ files_param = get_param(request, 'files')
+ if files_param is not None:
+ files_param = files_param.split(',')
+ else:
+ files_param = folder_paths.get_filename_list(model_type)
+ for file_param in files_param:
+ info_data = await get_model_info(
+ file_param,
+ model_type,
+ maybe_fetch_civitai=maybe_fetch_civitai,
+ maybe_fetch_metadata=maybe_fetch_metadata,
+ light=light
+ )
+ api_response['data'].append(info_data)
+ return api_response
diff --git a/custom_nodes/rgthree-comfy/py/server/utils_info.py b/custom_nodes/rgthree-comfy/py/server/utils_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..4723a664540235fa04f18c1460c2eef6f8fc88f5
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/server/utils_info.py
@@ -0,0 +1,452 @@
+import hashlib
+import json
+import os
+import re
+from datetime import datetime
+
+import requests
+
+from server import PromptServer
+import folder_paths
+
+from ..utils import abspath, get_dict_value, load_json_file, file_exists, remove_path, save_json_file
+from ..utils_userdata import read_userdata_json, save_userdata_json, delete_userdata_file
+
+
+def _get_info_cache_file(data_type: str, file_hash: str):
+ return f'info/{file_hash}.{data_type}.json'
+
+
+async def delete_model_info(
+ file: str, model_type, del_info=True, del_metadata=True, del_civitai=True
+):
+ """Delete the info json, and the civitai & metadata caches."""
+ file_path = get_folder_path(file, model_type)
+ if file_path is None:
+ return
+ if del_info:
+ remove_path(get_info_file(file_path))
+ if del_civitai or del_metadata:
+ file_hash = _get_sha256_hash(file_path)
+ if del_civitai:
+ json_file_path = _get_info_cache_file(file_hash, 'civitai')
+ delete_userdata_file(json_file_path)
+ if del_metadata:
+ json_file_path = _get_info_cache_file(file_hash, 'metadata')
+ delete_userdata_file(json_file_path)
+
+
+def get_file_info(file: str, model_type):
+ """Gets basic file info, like created or modified date."""
+ file_path = get_folder_path(file, model_type)
+ if file_path is None:
+ return None
+ return {
+ 'file': file,
+ 'path': file_path,
+ 'modified': os.path.getmtime(file_path) * 1000, # millis
+ 'imageLocal': f'/rgthree/api/{model_type}/img?file={file}' if get_img_file(file_path) else None,
+ 'hasInfoFile': get_info_file(file_path) is not None,
+ }
+
+
+def get_info_file(file_path: str, force=False):
+ # Try to load a rgthree-info.json file next to the file.
+ info_path = f'{file_path}.rgthree-info.json'
+ return info_path if file_exists(info_path) or force else None
+
+
+def get_img_file(file_path: str, force=False):
+ for ext in ['jpg', 'png', 'jpeg', 'webp']:
+ try_path = f'{os.path.splitext(file_path)[0]}.{ext}'
+ if file_exists(try_path):
+ return try_path
+
+
+def get_model_info_file_data(file: str, model_type, default=None):
+ """Returns the data from the info file, or a default value if it doesn't exist."""
+ file_path = get_folder_path(file, model_type)
+ if file_path is None:
+ return default
+ return load_json_file(get_info_file(file_path), default=default)
+
+
+async def get_model_info(
+ file: str,
+ model_type,
+ default=None,
+ maybe_fetch_civitai=False,
+ force_fetch_civitai=False,
+ maybe_fetch_metadata=False,
+ force_fetch_metadata=False,
+ light=False
+):
+ """Compiles a model info given a stored file next to the model, and/or metadata/civitai."""
+
+ file_path = get_folder_path(file, model_type)
+ if file_path is None:
+ return default
+
+ should_save = False
+ # basic data
+ basic_data = get_file_info(file, model_type)
+ # Try to load a rgthree-info.json file next to the file.
+ info_data = get_model_info_file_data(file, model_type, default={})
+
+ for key in ['file', 'path', 'modified', 'imageLocal', 'hasInfoFile']:
+ if key in basic_data and basic_data[key] and (
+ key not in info_data or info_data[key] != basic_data[key]
+ ):
+ info_data[key] = basic_data[key]
+ should_save = True
+
+ # Check if we have an image next to the file and, if so, add it to the front of the images
+ # (if it isn't already).
+ img_next_to_file = basic_data['imageLocal']
+
+ if 'images' not in info_data:
+ info_data['images'] = []
+ should_save = True
+
+ if img_next_to_file:
+ if len(info_data['images']) == 0 or info_data['images'][0]['url'] != img_next_to_file:
+ info_data['images'].insert(0, {'url': img_next_to_file})
+ should_save = True
+
+ # If we just want light data then bail now with just existing data, plus file, path and img if
+ # next to the file.
+ if light and not maybe_fetch_metadata and not force_fetch_metadata and not maybe_fetch_civitai and not force_fetch_civitai:
+ return info_data
+
+ if 'raw' not in info_data:
+ info_data['raw'] = {}
+ should_save = True
+
+ should_save = _update_data(info_data) or should_save
+
+ should_fetch_civitai = force_fetch_civitai is True or (
+ maybe_fetch_civitai is True and 'civitai' not in info_data['raw']
+ )
+ should_fetch_metadata = force_fetch_metadata is True or (
+ maybe_fetch_metadata is True and 'metadata' not in info_data['raw']
+ )
+
+ if should_fetch_metadata:
+ data_meta = _get_model_metadata(file, model_type, default={}, refresh=force_fetch_metadata)
+ should_save = _merge_metadata(info_data, data_meta) or should_save
+
+ if should_fetch_civitai:
+ data_civitai = _get_model_civitai_data(
+ file, model_type, default={}, refresh=force_fetch_civitai
+ )
+ should_save = _merge_civitai_data(info_data, data_civitai) or should_save
+
+ if 'sha256' not in info_data:
+ file_hash = _get_sha256_hash(file_path)
+ if file_hash is not None:
+ info_data['sha256'] = file_hash
+ should_save = True
+
+ if should_save:
+ if 'trainedWords' in info_data:
+ # Sort by count; if it doesn't exist, then assume it's a top item from civitai or elsewhere.
+ info_data['trainedWords'] = sorted(
+ info_data['trainedWords'],
+ key=lambda w: w['count'] if 'count' in w else 99999,
+ reverse=True
+ )
+ save_model_info(file, info_data, model_type)
+
+ # If we're saving, then the UI is likely waiting to see if the refreshed data is coming in.
+ await PromptServer.instance.send(f"rgthree-refreshed-{model_type}-info", {"data": info_data})
+
+ return info_data
+
+
+def _update_data(info_data: dict) -> bool:
+ """Ports old data to new data if necessary."""
+ should_save = False
+ # If we have "triggerWords" then move them over to "trainedWords"
+ if 'triggerWords' in info_data and len(info_data['triggerWords']) > 0:
+ civitai_words = ','.join((
+ get_dict_value(info_data, 'raw.civitai.triggerWords', default=[]) +
+ get_dict_value(info_data, 'raw.civitai.trainedWords', default=[])
+ ))
+ if 'trainedWords' not in info_data:
+ info_data['trainedWords'] = []
+ for trigger_word in info_data['triggerWords']:
+ word_data = next((data for data in info_data['trainedWords'] if data['word'] == trigger_word),
+ None)
+ if word_data is None:
+ word_data = {'word': trigger_word}
+ info_data['trainedWords'].append(word_data)
+ if trigger_word in civitai_words:
+ word_data['civitai'] = True
+ else:
+ word_data['user'] = True
+
+ del info_data['triggerWords']
+ should_save = True
+ return should_save
+
+
+def _merge_metadata(info_data: dict, data_meta: dict) -> bool:
+ """Returns true if data was saved."""
+ should_save = False
+
+ base_model_file = get_dict_value(data_meta, 'ss_sd_model_name', None)
+ if base_model_file:
+ info_data['baseModelFile'] = base_model_file
+
+ # Loop over metadata tags
+ trained_words = {}
+ if 'ss_tag_frequency' in data_meta and isinstance(data_meta['ss_tag_frequency'], dict):
+ for bucket_value in data_meta['ss_tag_frequency'].values():
+ if isinstance(bucket_value, dict):
+ for tag, count in bucket_value.items():
+ if tag not in trained_words:
+ trained_words[tag] = {'word': tag, 'count': 0, 'metadata': True}
+ trained_words[tag]['count'] = trained_words[tag]['count'] + count
+
+ if 'trainedWords' not in info_data:
+ info_data['trainedWords'] = list(trained_words.values())
+ should_save = True
+ else:
+ # We can't merge, because the list may have other data, like it's part of civitaidata.
+ merged_dict = {}
+ for existing_word_data in info_data['trainedWords']:
+ merged_dict[existing_word_data['word']] = existing_word_data
+ for new_key, new_word_data in trained_words.items():
+ if new_key not in merged_dict:
+ merged_dict[new_key] = {}
+ merged_dict[new_key] = {**merged_dict[new_key], **new_word_data}
+ info_data['trainedWords'] = list(merged_dict.values())
+ should_save = True
+
+ # trained_words = list(trained_words.values())
+ # info_data['meta_trained_words'] = trained_words
+ info_data['raw']['metadata'] = data_meta
+ should_save = True
+
+ if 'sha256' not in info_data and '_sha256' in data_meta:
+ info_data['sha256'] = data_meta['_sha256']
+ should_save = True
+
+ return should_save
+
+
+def _merge_civitai_data(info_data: dict, data_civitai: dict) -> bool:
+ """Returns true if data was saved."""
+ should_save = False
+
+ if 'name' not in info_data:
+ info_data['name'] = get_dict_value(data_civitai, 'model.name', '')
+ should_save = True
+ version_name = get_dict_value(data_civitai, 'name')
+ if version_name is not None:
+ info_data['name'] += f' - {version_name}'
+
+ if 'type' not in info_data:
+ info_data['type'] = get_dict_value(data_civitai, 'model.type')
+ should_save = True
+ if 'baseModel' not in info_data:
+ info_data['baseModel'] = get_dict_value(data_civitai, 'baseModel')
+ should_save = True
+
+ # We always want to merge triggerword.
+ civitai_trigger = get_dict_value(data_civitai, 'triggerWords', default=[])
+ civitai_trained = get_dict_value(data_civitai, 'trainedWords', default=[])
+ civitai_words = ','.join(civitai_trigger + civitai_trained)
+ if civitai_words:
+ civitai_words = re.sub(r"\s*,\s*", ",", civitai_words)
+ civitai_words = re.sub(r",+", ",", civitai_words)
+ civitai_words = re.sub(r"^,", "", civitai_words)
+ civitai_words = re.sub(r",$", "", civitai_words)
+ if civitai_words:
+ civitai_words = civitai_words.split(',')
+ if 'trainedWords' not in info_data:
+ info_data['trainedWords'] = []
+ for trigger_word in civitai_words:
+ word_data = next(
+ (data for data in info_data['trainedWords'] if data['word'] == trigger_word), None
+ )
+ if word_data is None:
+ word_data = {'word': trigger_word}
+ info_data['trainedWords'].append(word_data)
+ word_data['civitai'] = True
+
+ if 'sha256' not in info_data:
+ info_data['sha256'] = data_civitai['_sha256']
+ should_save = True
+
+ if 'modelId' in data_civitai:
+ info_data['links'] = info_data['links'] if 'links' in info_data else []
+ civitai_link = f'https://civitai.com/models/{get_dict_value(data_civitai, "modelId")}'
+ if get_dict_value(data_civitai, "id"):
+ civitai_link += f'?modelVersionId={get_dict_value(data_civitai, "id")}'
+ info_data['links'].append(civitai_link)
+ info_data['links'].append(data_civitai['_civitai_api'])
+ should_save = True
+
+ # Take images from civitai
+ if 'images' in data_civitai:
+ info_data_image_urls = list(
+ map(lambda i: i['url'] if 'url' in i else None, info_data['images'])
+ )
+ for img in data_civitai['images']:
+ img_url = get_dict_value(img, 'url')
+ if img_url is not None and img_url not in info_data_image_urls:
+ img_id = os.path.splitext(os.path.basename(img_url))[0] if img_url is not None else None
+ img_data = {
+ 'url': img_url,
+ 'civitaiUrl': f'https://civitai.com/images/{img_id}' if img_id is not None else None,
+ 'width': get_dict_value(img, 'width'),
+ 'height': get_dict_value(img, 'height'),
+ 'type': get_dict_value(img, 'type'),
+ 'nsfwLevel': get_dict_value(img, 'nsfwLevel'),
+ 'seed': get_dict_value(img, 'meta.seed'),
+ 'positive': get_dict_value(img, 'meta.prompt'),
+ 'negative': get_dict_value(img, 'meta.negativePrompt'),
+ 'steps': get_dict_value(img, 'meta.steps'),
+ 'sampler': get_dict_value(img, 'meta.sampler'),
+ 'cfg': get_dict_value(img, 'meta.cfgScale'),
+ 'model': get_dict_value(img, 'meta.Model'),
+ 'resources': get_dict_value(img, 'meta.resources'),
+ }
+ info_data['images'].append(img_data)
+ should_save = True
+
+ # The raw data
+ if 'civitai' not in info_data['raw']:
+ info_data['raw']['civitai'] = data_civitai
+ should_save = True
+
+ return should_save
+
+
+def _get_model_civitai_data(file: str, model_type, default=None, refresh=False):
+ """Gets the civitai data, either cached from the user directory, or from civitai api."""
+ file_hash = _get_sha256_hash(get_folder_path(file, model_type))
+ if file_hash is None:
+ return None
+
+ json_file_path = _get_info_cache_file(file_hash, 'civitai')
+
+ api_url = f'https://civitai.com/api/v1/model-versions/by-hash/{file_hash}'
+ file_data = read_userdata_json(json_file_path)
+ if file_data is None or refresh is True:
+ try:
+ response = requests.get(api_url, timeout=5000)
+ data = response.json()
+ save_userdata_json(
+ json_file_path, {
+ 'url': api_url,
+ 'timestamp': datetime.now().timestamp(),
+ 'response': data
+ }
+ )
+ file_data = read_userdata_json(json_file_path)
+ except requests.exceptions.RequestException as e: # This is the correct syntax
+ print(e)
+ response = file_data['response'] if file_data is not None and 'response' in file_data else None
+ if response is not None:
+ response['_sha256'] = file_hash
+ response['_civitai_api'] = api_url
+ return response if response is not None else default
+
+
+def _get_model_metadata(file: str, model_type, default=None, refresh=False):
+ """Gets the metadata from the file itself."""
+ file_path = get_folder_path(file, model_type)
+ file_hash = _get_sha256_hash(file_path)
+ if file_hash is None:
+ return default
+
+ json_file_path = _get_info_cache_file(file_hash, 'metadata')
+
+ file_data = read_userdata_json(json_file_path)
+ if file_data is None or refresh is True:
+ data = _read_file_metadata_from_header(file_path)
+ if data is not None:
+ file_data = {'url': file, 'timestamp': datetime.now().timestamp(), 'response': data}
+ save_userdata_json(json_file_path, file_data)
+ response = file_data['response'] if file_data is not None and 'response' in file_data else None
+ if response is not None:
+ response['_sha256'] = file_hash
+ return response if response is not None else default
+
+
+def _read_file_metadata_from_header(file_path: str) -> dict:
+ """Reads the file's header and returns a JSON dict metdata if available."""
+ data = None
+ try:
+ if file_path.endswith('.safetensors'):
+ with open(file_path, "rb") as file:
+ # https://github.com/huggingface/safetensors#format
+ # 8 bytes: N, an unsigned little-endian 64-bit integer, containing the size of the header
+ header_size = int.from_bytes(file.read(8), "little", signed=False)
+
+ if header_size <= 0:
+ raise BufferError("Invalid header size")
+
+ header = file.read(header_size)
+ if header is None:
+ raise BufferError("Invalid header")
+
+ header_json = json.loads(header)
+ data = header_json["__metadata__"] if "__metadata__" in header_json else None
+
+ if data is not None:
+ for key, value in data.items():
+ if isinstance(value, str) and value.startswith('{') and value.endswith('}'):
+ try:
+ value_as_json = json.loads(value)
+ data[key] = value_as_json
+ except Exception:
+ print(f'metdata for field {key} did not parse as json')
+ except requests.exceptions.RequestException as e:
+ print(e)
+ data = None
+
+ return data
+
+
+def get_folder_path(file: str, model_type) -> str | None:
+ """Gets the file path ensuring it exists."""
+ file_path = folder_paths.get_full_path(model_type, file)
+ if not file_exists(file_path):
+ file_path = abspath(file_path)
+ if not file_exists(file_path):
+ file_path = None
+ return file_path
+
+
+def _get_sha256_hash(file_path: str | None):
+ """Returns the hash for the file."""
+ if not file_path or not file_exists(file_path):
+ return None
+ BUF_SIZE = 1024 * 128 # lets read stuff in 64kb chunks!
+ file_hash = None
+ sha256_hash = hashlib.sha256()
+ with open(file_path, "rb") as f:
+ # Read and update hash string value in blocks of BUF_SIZE
+ for byte_block in iter(lambda: f.read(BUF_SIZE), b""):
+ sha256_hash.update(byte_block)
+ file_hash = sha256_hash.hexdigest()
+ return file_hash
+
+
+async def set_model_info_partial(file: str, model_type: str, info_data_partial):
+ """Sets partial data into the existing model info data."""
+ info_data = await get_model_info(file, model_type, default={})
+ info_data = {**info_data, **info_data_partial}
+ save_model_info(file, info_data, model_type)
+
+
+def save_model_info(file: str, info_data, model_type):
+ """Saves the model info alongside the model itself."""
+ file_path = get_folder_path(file, model_type)
+ if file_path is None:
+ return
+ info_path = get_info_file(file_path, force=True)
+ save_json_file(info_path, info_data)
diff --git a/custom_nodes/rgthree-comfy/py/server/utils_server.py b/custom_nodes/rgthree-comfy/py/server/utils_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2fa5d741964a767daf45ed7918c7b371348d222
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/server/utils_server.py
@@ -0,0 +1,65 @@
+import os
+from aiohttp import web
+
+from ..utils import sub_abspath
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DIR_WEB = os.path.abspath(f'{THIS_DIR}/../../web/')
+
+
+def get_param(request, param, default=None):
+ """Gets a param from a request."""
+ return request.rel_url.query[param] if param in request.rel_url.query else default
+
+
+def is_param_falsy(request, param):
+ """Determines if a param is explicitly 0 or false."""
+ val = get_param(request, param)
+ return val is not None and (val == "0" or val.upper() == "FALSE")
+
+
+def is_param_truthy(request, param):
+ """Determines if a param is explicitly 0 or false."""
+ val = get_param(request, param)
+ return val is not None and not is_param_falsy(request, param)
+
+
+def set_default_page_resources(path, routes):
+ """Sets up routes for handling static files under a path."""
+
+ @routes.get(f'/rgthree/{path}/{{file}}')
+ async def get_resource(request):
+ """Returns a resource file."""
+ filepath = request.match_info['file']
+ abspath = sub_abspath(os.path.join(DIR_WEB, path), filepath)
+ if abspath is None:
+ return web.HTTPNotFound()
+ return web.FileResponse(abspath)
+
+ @routes.get(f'/rgthree/{path}/{{subdir}}/{{file}}')
+ async def get_resource_subdir(request):
+ """Returns a resource file."""
+ filepath = os.path.join(request.match_info['subdir'], request.match_info['file'])
+ abspath = sub_abspath(os.path.join(DIR_WEB, path), filepath)
+ if abspath is None:
+ return web.HTTPNotFound()
+ return web.FileResponse(abspath)
+
+
+def set_default_page_routes(path, routes):
+ """ Sets default path handling for a hosted rgthree page. """
+
+ @routes.get(f'/rgthree/{path}')
+ async def get_path_redir(request):
+ """ Redirects to the path adding a trailing slash. """
+ raise web.HTTPFound(f'{request.path}/')
+
+ @routes.get(f'/rgthree/{path}/')
+ async def get_path_index(request):
+ """ Handles the page's index loading. """
+ html = ''
+ with open(os.path.join(DIR_WEB, path, 'index.html'), 'r', encoding='UTF-8') as file:
+ html = file.read()
+ return web.Response(text=html, content_type='text/html')
+
+ set_default_page_resources(path, routes)
diff --git a/custom_nodes/rgthree-comfy/py/utils.py b/custom_nodes/rgthree-comfy/py/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e86949e904e12c53bb1c02750f16776028edce82
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/utils.py
@@ -0,0 +1,177 @@
+import json
+import os
+import re
+
+from typing import Union
+
+
+class AnyType(str):
+ """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
+
+ def __ne__(self, __value: object) -> bool:
+ return False
+
+
+class FlexibleOptionalInputType(dict):
+ """A special class to make flexible nodes that pass data to our python handlers.
+
+ Enables both flexible/dynamic input types (like for Any Switch) or a dynamic number of inputs
+ (like for Any Switch, Context Switch, Context Merge, Power Lora Loader, etc).
+
+ Initially, ComfyUI only needed to return True for `__contains__` below, which told ComfyUI that
+ our node will handle the input, regardless of what it is.
+
+ However, after https://github.com/comfyanonymous/ComfyUI/pull/2666 ComdyUI's execution changed
+ also checking the data for the key; specifcially, the type which is the first tuple entry. This
+ type is supplied to our FlexibleOptionalInputType and returned for any non-data key. This can be a
+ real type, or use the AnyType for additional flexibility.
+ """
+
+ def __init__(self, type, data: Union[dict, None] = None):
+ """Initializes the FlexibleOptionalInputType.
+
+ Args:
+ type: The flexible type to use when ComfyUI retrieves an unknown key (via `__getitem__`).
+ data: An optional dict to use as the basis. This is stored both in a `data` attribute, so we
+ can look it up without hitting our overrides, as well as iterated over and adding its key
+ and values to our `self` keys. This way, when looked at, we will appear to represent this
+ data. When used in an "optional" INPUT_TYPES, these are the starting optional node types.
+ """
+ self.type = type
+ self.data = data
+ if self.data is not None:
+ for k, v in self.data.items():
+ self[k] = v
+
+ def __getitem__(self, key):
+ # If we have this key in the initial data, then return it. Otherwise return the tuple with our
+ # flexible type.
+ if self.data is not None and key in self.data:
+ val = self.data[key]
+ return val
+ return (self.type,)
+
+ def __contains__(self, key):
+ """Always contain a key, and we'll always return the tuple above when asked for it."""
+ return True
+
+
+any_type = AnyType("*")
+
+
+def is_dict_value_falsy(data: dict, dict_key: str):
+ """Checks if a dict value is falsy."""
+ val = get_dict_value(data, dict_key)
+ return not val
+
+
+def get_dict_value(data: dict, dict_key: str, default=None):
+ """Gets a deeply nested value given a dot-delimited key."""
+ keys = dict_key.split('.')
+ key = keys.pop(0) if len(keys) > 0 else None
+ found = data[key] if key in data else None
+ if found is not None and len(keys) > 0:
+ return get_dict_value(found, '.'.join(keys), default)
+ return found if found is not None else default
+
+
+def set_dict_value(data: dict, dict_key: str, value, create_missing_objects=True):
+ """Sets a deeply nested value given a dot-delimited key."""
+ keys = dict_key.split('.')
+ key = keys.pop(0) if len(keys) > 0 else None
+ if key not in data:
+ if create_missing_objects is False:
+ return data
+ data[key] = {}
+ if len(keys) == 0:
+ data[key] = value
+ else:
+ set_dict_value(data[key], '.'.join(keys), value, create_missing_objects)
+
+ return data
+
+
+def dict_has_key(data: dict, dict_key):
+ """Checks if a dict has a deeply nested dot-delimited key."""
+ keys = dict_key.split('.')
+ key = keys.pop(0) if len(keys) > 0 else None
+ if key is None or key not in data:
+ return False
+ if len(keys) == 0:
+ return True
+ return dict_has_key(data[key], '.'.join(keys))
+
+
+def load_json_file(file: str, default=None):
+ """Reads a json file and returns the json dict, stripping out "//" comments first."""
+ if path_exists(file):
+ with open(file, 'r', encoding='UTF-8') as file:
+ config = file.read()
+ try:
+ return json.loads(config)
+ except json.decoder.JSONDecodeError:
+ try:
+ config = re.sub(r"^\s*//\s.*", "", config, flags=re.MULTILINE)
+ return json.loads(config)
+ except json.decoder.JSONDecodeError:
+ try:
+ config = re.sub(r"(?:^|\s)//.*", "", config, flags=re.MULTILINE)
+ return json.loads(config)
+ except json.decoder.JSONDecodeError:
+ pass
+ return default
+
+
+def save_json_file(file_path: str, data: dict):
+ """Saves a json file."""
+ os.makedirs(os.path.dirname(file_path), exist_ok=True)
+ with open(file_path, 'w+', encoding='UTF-8') as file:
+ json.dump(data, file, sort_keys=False, indent=2, separators=(",", ": "))
+
+
+def path_exists(path):
+ """Checks if a path exists, accepting None type."""
+ if path is not None:
+ return os.path.exists(path)
+ return False
+
+
+def file_exists(path):
+ """Checks if a file exists, accepting None type."""
+ if path is not None:
+ return os.path.isfile(path)
+ return False
+
+
+def remove_path(path):
+ """Removes a path, if it exists."""
+ if path_exists(path):
+ os.remove(path)
+ return True
+ return False
+
+def abspath(file_path: str):
+ """Resolves the abspath of a file, resolving symlinks and user dirs."""
+ abs_path = os.path.abspath(file_path) if file_path else file_path
+ if abs_path and not path_exists(abs_path):
+ maybe_path = os.path.abspath(os.path.realpath(os.path.expanduser(file_path)))
+ abs_path = maybe_path if path_exists(maybe_path) else abs_path
+ return abs_path
+
+def sub_abspath(parent_dir: str, rel_path: str):
+ """Resolves the abspath under a parent directory ensuring it exists and is contained within."""
+ rel_path = os.path.join(parent_dir, rel_path)
+ abs_path = abspath(rel_path)
+ if not path_exists(abs_path) or not abs_path.startswith(parent_dir):
+ return None
+ return abs_path
+
+class ByPassTypeTuple(tuple):
+ """A special class that will return additional "AnyType" strings beyond defined values.
+ Credit to Trung0246
+ """
+
+ def __getitem__(self, index):
+ if index > len(self) - 1:
+ return AnyType("*")
+ return super().__getitem__(index)
diff --git a/custom_nodes/rgthree-comfy/py/utils_graph.py b/custom_nodes/rgthree-comfy/py/utils_graph.py
new file mode 100644
index 0000000000000000000000000000000000000000..0982a55cbc105b297c970770227d7da9be1f7abf
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/utils_graph.py
@@ -0,0 +1,20 @@
+from .utils import get_dict_value
+
+
+def get_worflow_node(extra_pnginfo, node_id: str, default=None):
+ # First, break out of any subgraphs
+ node_ids = str(node_id).split(':')
+ workflow_nodes = get_dict_value(extra_pnginfo, 'workflow.nodes', default=[])
+ workflow_subgraphs = get_dict_value(extra_pnginfo, 'workflow.definitions.subgraphs', default=[])
+ nodes_list = workflow_nodes
+ found = None
+ for individual_node_id in node_ids:
+ found = next((n for n in nodes_list if str(n['id']) == individual_node_id), None)
+ if isinstance(found, dict) and 'type' in found:
+ # Are we a subgraph? Right now, subgraph types are a UUID that exists as an id in the
+ # aubgraphs list. But, rather than check if we're a UUID, let's just check if it exists
+ # anyway, that when if (when) Comfy changes the id structure we'll keep working.
+ subgraph = next((n for n in workflow_subgraphs if str(n['id']) == found['type']), None)
+ if isinstance(subgraph, dict) and 'nodes' in subgraph:
+ nodes_list = subgraph['nodes']
+ return found if found is not None else default
diff --git a/custom_nodes/rgthree-comfy/py/utils_userdata.py b/custom_nodes/rgthree-comfy/py/utils_userdata.py
new file mode 100644
index 0000000000000000000000000000000000000000..b10b757ab503908fb03ae6df97ef775809a3f40d
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/py/utils_userdata.py
@@ -0,0 +1,50 @@
+import os
+
+from .utils import load_json_file, path_exists, save_json_file
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+USERDATA = os.path.join(THIS_DIR, '..', 'userdata')
+
+
+def read_userdata_file(rel_path: str):
+ """Reads a file from the userdata directory."""
+ file_path = clean_path(rel_path)
+ if path_exists(file_path):
+ with open(file_path, 'r', encoding='UTF-8') as file:
+ return file.read()
+ return None
+
+
+def save_userdata_file(rel_path: str, content: str):
+ """Saves a file from the userdata directory."""
+ file_path = clean_path(rel_path)
+ with open(file_path, 'w+', encoding='UTF-8') as file:
+ file.write(content)
+
+
+def delete_userdata_file(rel_path: str):
+ """Deletes a file from the userdata directory."""
+ file_path = clean_path(rel_path)
+ if os.path.isfile(file_path):
+ os.remove(file_path)
+
+
+def read_userdata_json(rel_path: str):
+ """Reads a json file from the userdata directory."""
+ file_path = clean_path(rel_path)
+ return load_json_file(file_path)
+
+
+def save_userdata_json(rel_path: str, data: dict):
+ """Saves a json file from the userdata directory."""
+ file_path = clean_path(rel_path)
+ return save_json_file(file_path, data)
+
+
+def clean_path(rel_path: str):
+ """Cleans a relative path by splitting on forward slash and os.path.joining."""
+ cleaned = USERDATA
+ paths = rel_path.split('/')
+ for path in paths:
+ cleaned = os.path.join(cleaned, path)
+ return cleaned
diff --git a/custom_nodes/rgthree-comfy/pyproject.toml b/custom_nodes/rgthree-comfy/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..35d16ec6b5465f7ad207bf94d445ec206035d53a
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "rgthree-comfy"
+description = "Making ComfyUI more comfortable."
+version = "1.0.2605082257"
+license = { file = "LICENSE" }
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/rgthree/rgthree-comfy"
+
+[tool.comfy]
+PublisherId = "rgthree"
+DisplayName = "rgthree-comfy"
+Icon = "https://comfy.rgthree.com/media/rgthree.svg"
diff --git a/custom_nodes/rgthree-comfy/requirements.txt b/custom_nodes/rgthree-comfy/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/custom_nodes/rgthree-comfy/rgthree_config.json.default b/custom_nodes/rgthree-comfy/rgthree_config.json.default
new file mode 100644
index 0000000000000000000000000000000000000000..e8da96f086e4055f8965ea9710c3d2b3da17cb08
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/rgthree_config.json.default
@@ -0,0 +1,68 @@
+// COPY THIS FILE BEFORE MAKING CHANGES TO: rgthree_config.json
+{
+ "log_level": "WARN",
+ "features": {
+ "show_alerts_for_corrupt_workflows": false,
+ "monitor_for_corrupt_links": false,
+ "menu_queue_selected_nodes": true,
+ "menu_auto_nest": {
+ "subdirs": null,
+ "threshold": 20
+ },
+ "menu_bookmarks": {
+ "enabled": true
+ },
+ "group_header_fast_toggle": {
+ "enabled": null,
+ "toggles": ["queue", "bypass", "mute"],
+ "show": "hover"
+ },
+ "progress_bar": {
+ "enabled": true,
+ "height": 16,
+ "position": "top"
+ },
+ "comfy_top_bar_menu": {
+ "enabled": true,
+ "button_bookmarks": {
+ "enabled": true
+ }
+ },
+ // Allows for dragging and dropping a workflow (image, json) onto an individual node to import
+ // that specific node's widgets if it also exists in the dropped workflow (same id, type).
+ "import_individual_nodes": {
+ "enabled": null
+ },
+ // Enables invokeExtensionsAsync for rgthree-nodes allowing other extensions to hook into the
+ // nodes like the default ComfyNodes. This was not possible before Apr 2024, so it's a config
+ // entry in case it causes issues. This is only for the nodeCreated event/function as of now.
+ "invoke_extensions_async": {
+ "node_created": true
+ }
+ },
+ "nodes": {
+ "reroute": {
+ "default_width": 40,
+ "default_height": 30,
+ "default_resizable": false,
+ "default_layout": ["Left", "Right"],
+ "fast_reroute": {
+ "enabled": true,
+ "key_create_while_dragging_link" : "Shift + R",
+ "key_rotate": "Shift + A",
+ "key_resize": "Shift + X",
+ "key_move": "Shift + Z",
+ "key_connections_input": "Shift + S",
+ "key_connections_output": "Shift + D"
+ }
+ },
+ "power_lora_loader": {
+ "show_info_badge": true
+ }
+ },
+ "announcements": {
+ "comfy-nodes-20": {
+ "incompatible": true
+ }
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/any_switch.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/any_switch.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e72642b60436236eccd3177cb8e2573f00ac33c
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/any_switch.ts
@@ -0,0 +1,103 @@
+import type {
+ ComfyApp,
+ INodeInputSlot,
+ INodeOutputSlot,
+ LGraphNode,
+ LLink,
+} from "@comfyorg/frontend";
+import type {ComfyNodeDef} from "typings/comfy.js";
+
+import {app} from "scripts/app.js";
+import {IoDirection, addConnectionLayoutSupport, followConnectionUntilType} from "./utils.js";
+import {RgthreeBaseServerNode} from "./base_node.js";
+import {NodeTypesString} from "./constants.js";
+import {removeUnusedInputsFromEnd} from "./utils_inputs_outputs.js";
+import {debounce} from "rgthree/common/shared_utils.js";
+
+class RgthreeAnySwitch extends RgthreeBaseServerNode {
+ static override title = NodeTypesString.ANY_SWITCH;
+ static override type = NodeTypesString.ANY_SWITCH;
+ static comfyClass = NodeTypesString.ANY_SWITCH;
+
+ private stabilizeBound = this.stabilize.bind(this);
+ private nodeType: string | string[] | null = null;
+
+ constructor(title = RgthreeAnySwitch.title) {
+ super(title);
+ // Adding five. Note, configure will add as many as was in the stored workflow automatically.
+ this.addAnyInput(5);
+ }
+
+ override onConnectionsChange(
+ type: number,
+ slotIndex: number,
+ isConnected: boolean,
+ linkInfo: LLink,
+ ioSlot: INodeOutputSlot | INodeInputSlot,
+ ) {
+ super.onConnectionsChange?.(type, slotIndex, isConnected, linkInfo, ioSlot);
+ this.scheduleStabilize();
+ }
+
+ onConnectionsChainChange() {
+ this.scheduleStabilize();
+ }
+
+ scheduleStabilize(ms = 64) {
+ return debounce(this.stabilizeBound, ms);
+ }
+
+ private addAnyInput(num = 1) {
+ for (let i = 0; i < num; i++) {
+ this.addInput(
+ `any_${String(this.inputs.length + 1).padStart(2, "0")}`,
+ (this.nodeType || "*") as string,
+ );
+ }
+ }
+
+ stabilize() {
+ // First, clean up the dynamic number of inputs.
+ removeUnusedInputsFromEnd(this, 4);
+ this.addAnyInput();
+
+ // We prefer the inputs, then the output.
+ let connectedType = followConnectionUntilType(this, IoDirection.INPUT, undefined, true);
+ if (!connectedType) {
+ connectedType = followConnectionUntilType(this, IoDirection.OUTPUT, undefined, true);
+ }
+ // TODO: What this doesn't do is broadcast to other nodes when its type changes. Reroute node
+ // does, but, for now, if this was connected to another Any Switch, say, the second one wouldn't
+ // change its type when the first does. The user would need to change the connections.
+ this.nodeType = connectedType?.type || "*";
+ for (const input of this.inputs) {
+ input.type = this.nodeType as string; // So, types can indeed be arrays,,
+ }
+ for (const output of this.outputs) {
+ output.type = this.nodeType as string; // So, types can indeed be arrays,,
+ output.label =
+ output.type === "RGTHREE_CONTEXT"
+ ? "CONTEXT"
+ : Array.isArray(this.nodeType) || this.nodeType.includes(",")
+ ? connectedType?.label || String(this.nodeType)
+ : String(this.nodeType);
+ }
+ }
+
+ static override setUp(comfyClass: typeof LGraphNode, nodeData: ComfyNodeDef) {
+ RgthreeBaseServerNode.registerForOverride(comfyClass, nodeData, RgthreeAnySwitch);
+ addConnectionLayoutSupport(RgthreeAnySwitch, app, [
+ ["Left", "Right"],
+ ["Right", "Left"],
+ ]);
+ }
+}
+
+app.registerExtension({
+ name: "rgthree.AnySwitch",
+ async beforeRegisterNodeDef(nodeType: typeof LGraphNode, nodeData: any, app: ComfyApp) {
+ if (nodeData.name === "Any Switch (rgthree)") {
+ RgthreeAnySwitch.setUp(nodeType, nodeData);
+ }
+ },
+});
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/base_any_input_connected_node.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/base_any_input_connected_node.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d54279a949528162111c57c0c732943cb53f30fc
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/base_any_input_connected_node.ts
@@ -0,0 +1,354 @@
+import type {
+ Vector2,
+ LLink,
+ INodeInputSlot,
+ INodeOutputSlot,
+ LGraphNode as TLGraphNode,
+ ISlotType,
+ ConnectByTypeOptions,
+ TWidgetType,
+ IWidgetOptions,
+ IWidget,
+ IBaseWidget,
+ WidgetTypeMap,
+} from "@comfyorg/frontend";
+
+import {app} from "scripts/app.js";
+import {RgthreeBaseVirtualNode} from "./base_node.js";
+import {rgthree} from "./rgthree.js";
+import {
+ PassThroughFollowing,
+ addConnectionLayoutSupport,
+ addMenuItem,
+ getConnectedInputNodes,
+ getConnectedInputNodesAndFilterPassThroughs,
+ getConnectedOutputNodes,
+ getConnectedOutputNodesAndFilterPassThroughs,
+} from "./utils.js";
+
+/**
+ * A Virtual Node that allows any node's output to connect to it.
+ */
+export class BaseAnyInputConnectedNode extends RgthreeBaseVirtualNode {
+ override isVirtualNode = true;
+
+ /**
+ * Whether inputs show the immediate nodes, or follow and show connected nodes through
+ * passthrough nodes.
+ */
+ readonly inputsPassThroughFollowing: PassThroughFollowing = PassThroughFollowing.NONE;
+
+ debouncerTempWidth: number = 0;
+ schedulePromise: Promise | null = null;
+
+ constructor(title = BaseAnyInputConnectedNode.title) {
+ super(title);
+ }
+
+ override onConstructed() {
+ this.addInput("", "*");
+ return super.onConstructed();
+ }
+
+ override clone() {
+ const cloned = super.clone()!;
+ // Copying to clipboard (and also, creating node templates) work by cloning nodes and, for some
+ // reason, it manually manipulates the cloned data. So, we want to keep the present input slots
+ // so if it's pasted/templatized the data is correct. Otherwise, clear the inputs and so the new
+ // node is ready to go, fresh.
+ if (!rgthree.canvasCurrentlyCopyingToClipboardWithMultipleNodes) {
+ while (cloned.inputs.length > 1) {
+ cloned.removeInput(cloned.inputs.length - 1);
+ }
+ if (cloned.inputs[0]) {
+ cloned.inputs[0].label = "";
+ }
+ }
+ return cloned;
+ }
+
+ /**
+ * Schedules a promise to run a stabilization, debouncing duplicate requests.
+ */
+ scheduleStabilizeWidgets(ms = 100) {
+ if (!this.schedulePromise) {
+ this.schedulePromise = new Promise((resolve) => {
+ setTimeout(() => {
+ this.schedulePromise = null;
+ this.doStablization();
+ resolve();
+ }, ms);
+ });
+ }
+ return this.schedulePromise;
+ }
+
+ /**
+ * Ensures we have at least one empty input at the end, returns true if changes were made, or false
+ * if no changes were needed.
+ */
+ private stabilizeInputsOutputs(): boolean {
+ let changed = false;
+ const hasEmptyInput = !this.inputs[this.inputs.length - 1]?.link;
+ if (!hasEmptyInput) {
+ this.addInput("", "*");
+ changed = true;
+ }
+ for (let index = this.inputs.length - 2; index >= 0; index--) {
+ const input = this.inputs[index]!;
+ if (!input.link) {
+ this.removeInput(index);
+ changed = true;
+ } else {
+ const node = getConnectedInputNodesAndFilterPassThroughs(
+ this,
+ this,
+ index,
+ this.inputsPassThroughFollowing,
+ )[0];
+ const newName = node?.title || "";
+ if (input.name !== newName) {
+ input.name = node?.title || "";
+ changed = true;
+ }
+ }
+ }
+ return changed;
+ }
+
+ /**
+ * Stabilizes the node's inputs and widgets.
+ */
+ private doStablization() {
+ if (!this.graph) {
+ return;
+ }
+ let dirty = false;
+
+ // When we add/remove widgets, litegraph is going to mess up the size, so we
+ // store it so we can retrieve it in computeSize. Hacky..
+ (this as any)._tempWidth = this.size[0];
+
+ dirty = this.stabilizeInputsOutputs();
+ const linkedNodes = getConnectedInputNodesAndFilterPassThroughs(this);
+ dirty = this.handleLinkedNodesStabilization(linkedNodes) || dirty;
+
+ // Only mark dirty if something's changed.
+ if (dirty) {
+ this.graph.setDirtyCanvas(true, true);
+ }
+
+ // Schedule another stabilization in the future.
+ this.scheduleStabilizeWidgets(500);
+ }
+
+ /**
+ * Handles stabilization of linked nodes. To be overridden. Should return true if changes were
+ * made, or false if no changes were needed.
+ */
+ handleLinkedNodesStabilization(linkedNodes: TLGraphNode[]): boolean {
+ linkedNodes; // No-op, but makes overridding in VSCode cleaner.
+ throw new Error("handleLinkedNodesStabilization should be overridden.");
+ }
+
+ onConnectionsChainChange() {
+ this.scheduleStabilizeWidgets();
+ }
+
+ override onConnectionsChange(
+ type: number,
+ index: number,
+ connected: boolean,
+ linkInfo: LLink,
+ ioSlot: INodeOutputSlot | INodeInputSlot,
+ ) {
+ super.onConnectionsChange &&
+ super.onConnectionsChange(type, index, connected, linkInfo, ioSlot);
+ if (!linkInfo) return;
+ // Follow outputs to see if we need to trigger an onConnectionChange.
+ const connectedNodes = getConnectedOutputNodesAndFilterPassThroughs(this);
+ for (const node of connectedNodes) {
+ if ((node as BaseAnyInputConnectedNode).onConnectionsChainChange) {
+ (node as BaseAnyInputConnectedNode).onConnectionsChainChange();
+ }
+ }
+ this.scheduleStabilizeWidgets();
+ }
+
+ override removeInput(slot: number) {
+ (this as any)._tempWidth = this.size[0];
+ return super.removeInput(slot);
+ }
+
+ override addInput>(
+ name: string,
+ type: ISlotType,
+ extra_info?: TProperties | undefined,
+ ): INodeInputSlot & TProperties {
+ (this as any)._tempWidth = this.size[0];
+ return super.addInput(name, type, extra_info);
+ }
+
+ override addWidget(
+ type: Type,
+ name: string,
+ value: TValue,
+ callback: IBaseWidget["callback"] | string | null,
+ options?: IWidgetOptions | string,
+ ):
+ | IBaseWidget>
+ | WidgetTypeMap[Type] {
+ (this as any)._tempWidth = this.size[0];
+ return super.addWidget(type, name, value, callback, options);
+ }
+
+ override removeWidget(widget: IBaseWidget | IWidget | number | undefined): void {
+ (this as any)._tempWidth = this.size[0];
+ super.removeWidget(widget);
+ }
+
+ override computeSize(out: Vector2) {
+ let size = super.computeSize(out);
+ if ((this as any)._tempWidth) {
+ size[0] = (this as any)._tempWidth;
+ // We sometimes get repeated calls to compute size, so debounce before clearing.
+ this.debouncerTempWidth && clearTimeout(this.debouncerTempWidth);
+ this.debouncerTempWidth = setTimeout(() => {
+ (this as any)._tempWidth = null;
+ }, 32);
+ }
+ // If we're collapsed, then subtract the total calculated height of the other input slots.
+ if (this.properties["collapse_connections"]) {
+ const rows = Math.max(this.inputs?.length || 0, this.outputs?.length || 0, 1) - 1;
+ size[1] = size[1] - rows * LiteGraph.NODE_SLOT_HEIGHT;
+ }
+ setTimeout(() => {
+ this.graph?.setDirtyCanvas(true, true);
+ }, 16);
+ return size;
+ }
+
+ /**
+ * When we connect our output, check our inputs and make sure we're not trying to connect a loop.
+ */
+ override onConnectOutput(
+ outputIndex: number,
+ inputType: string | -1,
+ inputSlot: INodeInputSlot,
+ inputNode: TLGraphNode,
+ inputIndex: number,
+ ): boolean {
+ let canConnect = true;
+ if (super.onConnectOutput) {
+ canConnect = super.onConnectOutput(outputIndex, inputType, inputSlot, inputNode, inputIndex);
+ }
+ if (canConnect) {
+ const nodes = getConnectedInputNodes(this); // We want passthrough nodes, since they will loop.
+ if (nodes.includes(inputNode)) {
+ alert(
+ `Whoa, whoa, whoa. You've just tried to create a connection that loops back on itself, ` +
+ `a situation that could create a time paradox, the results of which could cause a ` +
+ `chain reaction that would unravel the very fabric of the space time continuum, ` +
+ `and destroy the entire universe!`,
+ );
+ canConnect = false;
+ }
+ }
+ return canConnect;
+ }
+
+ override onConnectInput(
+ inputIndex: number,
+ outputType: string | -1,
+ outputSlot: INodeOutputSlot,
+ outputNode: TLGraphNode,
+ outputIndex: number,
+ ): boolean {
+ let canConnect = true;
+ if (super.onConnectInput) {
+ canConnect = super.onConnectInput(
+ inputIndex,
+ outputType,
+ outputSlot,
+ outputNode,
+ outputIndex,
+ );
+ }
+ if (canConnect) {
+ const nodes = getConnectedOutputNodes(this); // We want passthrough nodes, since they will loop.
+ if (nodes.includes(outputNode)) {
+ alert(
+ `Whoa, whoa, whoa. You've just tried to create a connection that loops back on itself, ` +
+ `a situation that could create a time paradox, the results of which could cause a ` +
+ `chain reaction that would unravel the very fabric of the space time continuum, ` +
+ `and destroy the entire universe!`,
+ );
+ canConnect = false;
+ }
+ }
+ return canConnect;
+ }
+
+ /**
+ * If something is dropped on us, just add it to the bottom. onConnectInput should already cancel
+ * if it's disallowed.
+ */
+ override connectByTypeOutput(
+ slot: number | string,
+ sourceNode: TLGraphNode,
+ sourceSlotType: ISlotType,
+ optsIn?: ConnectByTypeOptions,
+ ): LLink | null {
+ const lastInput = this.inputs[this.inputs.length - 1];
+ if (!lastInput?.link && lastInput?.type === "*") {
+ var sourceSlot = sourceNode.findOutputSlotByType(sourceSlotType, false, true);
+ return sourceNode.connect(sourceSlot, this, slot);
+ }
+ return super.connectByTypeOutput(slot, sourceNode, sourceSlotType, optsIn);
+ }
+
+ static override setUp() {
+ super.setUp();
+ addConnectionLayoutSupport(this, app, [
+ ["Left", "Right"],
+ ["Right", "Left"],
+ ]);
+ addMenuItem(this, app, {
+ name: (node) =>
+ `${node.properties?.["collapse_connections"] ? "Show" : "Collapse"} Connections`,
+ property: "collapse_connections",
+ prepareValue: (_value, node) => !node.properties?.["collapse_connections"],
+ callback: (_node) => {
+ app.canvas.getCurrentGraph()?.setDirtyCanvas(true, true);
+ },
+ });
+ }
+}
+
+// Ok, hack time! LGraphNode's connectByType is powerful, but for our nodes, that have multiple "*"
+// input types, it seems it just takes the first one, and disconnects it. I'd rather we don't do
+// that and instead take the next free one. If that doesn't work, then we'll give it to the old
+// method.
+const oldLGraphNodeConnectByType = LGraphNode.prototype.connectByType;
+LGraphNode.prototype.connectByType = function connectByType(
+ slot: number | string,
+ targetNode: TLGraphNode,
+ targetSlotType: ISlotType,
+ optsIn?: ConnectByTypeOptions,
+): LLink | null {
+ // If we're dropping on a node, and the last input is free and an "*" type, then connect there
+ // first...
+ if (targetNode.inputs) {
+ for (const [index, input] of targetNode.inputs.entries()) {
+ if (!input.link && input.type === "*") {
+ this.connect(slot, targetNode, index);
+ return null;
+ }
+ }
+ }
+ return (
+ (oldLGraphNodeConnectByType &&
+ oldLGraphNodeConnectByType.call(this, slot, targetNode, targetSlotType, optsIn)) ||
+ null
+ );
+};
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/base_node.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be4e1be533355e24b47acb73cb5d03b988532150
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node.ts
@@ -0,0 +1,504 @@
+import type {
+ IWidget,
+ LGraphCanvas,
+ IContextMenuValue,
+ IFoundSlot,
+ LGraphEventMode,
+ LGraphNodeConstructor,
+ ISerialisedNode,
+ IBaseWidget,
+} from "@comfyorg/frontend";
+import type {ComfyNodeDef} from "typings/comfy.js";
+import type {RgthreeBaseServerNodeConstructor} from "typings/rgthree.js";
+
+import {app} from "scripts/app.js";
+import {ComfyWidgets} from "scripts/widgets.js";
+import {SERVICE as KEY_EVENT_SERVICE} from "./services/key_events_services.js";
+import {LogLevel, rgthree} from "./rgthree.js";
+import {addHelpMenuItem} from "./utils.js";
+import {RgthreeHelpDialog} from "rgthree/common/dialog.js";
+import {
+ importIndividualNodesInnerOnDragDrop,
+ importIndividualNodesInnerOnDragOver,
+} from "./feature_import_individual_nodes.js";
+import {defineProperty, moveArrayItem} from "rgthree/common/shared_utils.js";
+
+/**
+ * A base node with standard methods, directly extending the LGraphNode.
+ * This can be used for ui-nodes and a further base for server nodes.
+ */
+export abstract class RgthreeBaseNode extends LGraphNode {
+ /**
+ * Action strings that can be exposed and triggered from other nodes, like Fast Actions Button.
+ */
+ static exposedActions: string[] = [];
+
+ static override title: string = "__NEED_CLASS_TITLE__";
+ static override type: string = "__NEED_CLASS_TYPE__";
+ static override category = "rgthree";
+ static _category = "rgthree"; // `category` seems to get reset by comfy, so reset to this after.
+
+ /** Our constructor ensures there's a widget array, so we get rid of the nullability. */
+ override widgets!: IWidget[];
+
+ /**
+ * The comfyClass is property ComfyUI and extensions may care about, even through it is only for
+ * server nodes. RgthreeBaseServerNode below overrides this with the expected value and we just
+ * set it here so extensions that are none the wiser don't break on some unchecked string method
+ * call on an undefined calue.
+ */
+ override comfyClass: string = "__NEED_COMFY_CLASS__";
+
+ /** Used by the ComfyUI-Manager badge. */
+ readonly nickname = "rgthree";
+ /** Are we a virtual node? */
+ override readonly isVirtualNode: boolean = false;
+ /** Are we able to be dropped on (if config is enabled too). */
+ isDropEnabled = false;
+ /** A state member determining if we're currently removed. */
+ removed = false;
+ /** A state member determining if we're currently "configuring."" */
+ configuring = false;
+ /** A temporary width value that can be used to ensure compute size operates correctly. */
+ _tempWidth = 0;
+
+ /** Private Mode member so we can override the setter/getter and call an `onModeChange`. */
+ private rgthree_mode?: LGraphEventMode;
+
+ /** An internal bool set when `onConstructed` is run. */
+ private __constructed__ = false;
+ /** The help dialog. */
+ private helpDialog: RgthreeHelpDialog | null = null;
+
+ constructor(title = RgthreeBaseNode.title, skipOnConstructedCall = true) {
+ super(title);
+ if (title == "__NEED_CLASS_TITLE__") {
+ throw new Error("RgthreeBaseNode needs overrides.");
+ }
+ // Ensure these exist since some other extensions will break in their onNodeCreated.
+ this.widgets = this.widgets || [];
+ this.properties = this.properties || {};
+
+ // Some checks we want to do after we're constructed, looking that data is set correctly and
+ // that our base's `onConstructed` was called (if not, set a DEV warning).
+ setTimeout(() => {
+ // Check we have a comfyClass defined.
+ if (this.comfyClass == "__NEED_COMFY_CLASS__") {
+ throw new Error("RgthreeBaseNode needs a comfy class override.");
+ }
+ if (this.constructor.type == "__NEED_CLASS_TYPE__") {
+ throw new Error("RgthreeBaseNode needs overrides.");
+ }
+ // Ensure we've called onConstructed before we got here.
+ this.checkAndRunOnConstructed();
+ });
+
+ defineProperty(this, "mode", {
+ get: () => {
+ return this.rgthree_mode;
+ },
+ set: (mode: LGraphEventMode) => {
+ if (this.rgthree_mode != mode) {
+ const oldMode = this.rgthree_mode;
+ this.rgthree_mode = mode;
+ this.onModeChange(oldMode, mode);
+ }
+ },
+ });
+ }
+
+ private checkAndRunOnConstructed() {
+ if (!this.__constructed__) {
+ this.onConstructed();
+ const [n, v] = rgthree.logger.logParts(
+ LogLevel.DEV,
+ `[RgthreeBaseNode] Child class did not call onConstructed for "${this.type}.`,
+ );
+ console[n]?.(...v);
+ }
+ return this.__constructed__;
+ }
+
+ override onDragOver(e: DragEvent): boolean {
+ if (!this.isDropEnabled) return false;
+ return importIndividualNodesInnerOnDragOver(this, e);
+ }
+
+ override async onDragDrop(e: DragEvent): Promise {
+ if (!this.isDropEnabled) return false;
+ return importIndividualNodesInnerOnDragDrop(this, e);
+ }
+
+ /**
+ * When a node is finished with construction, we must call this. Failure to do so will result in
+ * an error message from the timeout in this base class. This is broken out and becomes the
+ * responsibility of the child class because
+ */
+ onConstructed() {
+ if (this.__constructed__) return false;
+ // This is kinda a hack, but if this.type is still null, then set it to undefined to match.
+ this.type = this.type ?? undefined;
+ this.__constructed__ = true;
+ rgthree.invokeExtensionsAsync("nodeCreated", this);
+ return this.__constructed__;
+ }
+
+ override configure(info: ISerialisedNode): void {
+ this.configuring = true;
+ super.configure(info);
+ // Fix https://github.com/comfyanonymous/ComfyUI/issues/1448 locally.
+ // Can removed when fixed and adopted.
+ for (const w of this.widgets || []) {
+ w.last_y = w.last_y || 0;
+ }
+ this.configuring = false;
+ }
+
+ /**
+ * Override clone for, at the least, deep-copying properties.
+ */
+ override clone() {
+ const cloned = super.clone()!;
+ // This is wild, but LiteGraph doesn't deep clone data, so we will. We'll use structured clone,
+ // which most browsers in 2022 support, but but we'll check.
+ if (cloned?.properties && !!window.structuredClone) {
+ cloned.properties = structuredClone(cloned.properties);
+ }
+ // [🤮] https://github.com/Comfy-Org/ComfyUI_frontend/issues/5037
+ // ComfyUI started throwing errors when some of our nodes wanted to remove inputs when cloning
+ // (like our dynamic inputs) because the disconnect method that's automatically called assumes
+ // there should be a graph. For now, I _think_ we can simply assign the current graph to avoid
+ // the error, which would then be overwritten when placed...
+ cloned.graph = this.graph;
+ return cloned;
+ }
+
+ /** When a mode change, we want all connected nodes to match. */
+ onModeChange(from: LGraphEventMode | undefined, to: LGraphEventMode) {
+ // Override
+ }
+
+ /**
+ * Given a string, do something. At the least, handle any `exposedActions` that may be called and
+ * passed into from other nodes, like Fast Actions Button
+ */
+ async handleAction(action: string) {
+ action; // No-op. Should be overridden but OK if not.
+ }
+
+ /**
+ * This didn't exist in LiteGraph/Comfy, but now it's added. Ours was a bit more flexible, though.
+ */
+ override removeWidget(widget: IBaseWidget | IWidget | number | undefined): void {
+ if (typeof widget === "number") {
+ widget = this.widgets[widget];
+ }
+ if (!widget) return;
+
+ // Comfy added their own removeWidget, but it's not fully rolled out to stable, so keep our
+ // original implementation.
+ // TODO: Actually, scratch that. The ComfyUI impl doesn't call widtget.onRemove?.() and so
+ // we shouldn't switch to it yet. See: https://github.com/Comfy-Org/ComfyUI_frontend/issues/5090
+ const canUseComfyUIRemoveWidget = false;
+ if (canUseComfyUIRemoveWidget && typeof super.removeWidget === 'function') {
+ super.removeWidget(widget as IBaseWidget);
+ } else {
+ const index = this.widgets.indexOf(widget as IWidget);
+ if (index > -1) {
+ this.widgets.splice(index, 1);
+ }
+ widget.onRemove?.();
+ }
+ }
+
+ /**
+ * Replaces an existing widget.
+ */
+ replaceWidget(widgetOrSlot: IWidget | number | undefined, newWidget: IWidget) {
+ let index = null;
+ if (widgetOrSlot) {
+ index = typeof widgetOrSlot === "number" ? widgetOrSlot : this.widgets.indexOf(widgetOrSlot);
+ this.removeWidget(this.widgets[index]!);
+ }
+ index = index != null ? index : this.widgets.length - 1;
+ if (this.widgets.includes(newWidget)) {
+ moveArrayItem(this.widgets, newWidget, index);
+ } else {
+ this.widgets.splice(index, 0, newWidget);
+ }
+ }
+
+ /**
+ * A default version of the logive when a node does not set `getSlotMenuOptions`. This is
+ * necessary because child nodes may want to define getSlotMenuOptions but LiteGraph then won't do
+ * it's default logic. This bakes it so child nodes can call this instead (and this doesn't set
+ * getSlotMenuOptions for all child nodes in case it doesn't exist).
+ */
+ defaultGetSlotMenuOptions(slot: IFoundSlot): IContextMenuValue[] {
+ const menu_info: IContextMenuValue[] = [];
+ if (slot?.output?.links?.length) {
+ menu_info.push({content: "Disconnect Links", slot});
+ }
+ let inputOrOutput = slot.input || slot.output;
+ if (inputOrOutput) {
+ if (inputOrOutput.removable) {
+ menu_info.push(
+ inputOrOutput.locked ? {content: "Cannot remove"} : {content: "Remove Slot", slot},
+ );
+ }
+ if (!inputOrOutput.nameLocked) {
+ menu_info.push({content: "Rename Slot", slot});
+ }
+ }
+ return menu_info;
+ }
+
+ override onRemoved(): void {
+ super.onRemoved?.();
+ this.removed = true;
+ }
+
+ static setUp(...args: any[]) {
+ // No-op.
+ }
+
+ /**
+ * A function to provide help text to be overridden.
+ */
+ getHelp() {
+ return "";
+ }
+
+ showHelp() {
+ const help = this.getHelp() || (this.constructor as any).help;
+ if (help) {
+ this.helpDialog = new RgthreeHelpDialog(this, help).show();
+ this.helpDialog.addEventListener("close", (e) => {
+ this.helpDialog = null;
+ });
+ }
+ }
+
+ override onKeyDown(event: KeyboardEvent): void {
+ KEY_EVENT_SERVICE.handleKeyDownOrUp(event);
+ if (event.key == "?" && !this.helpDialog) {
+ this.showHelp();
+ }
+ }
+
+ override onKeyUp(event: KeyboardEvent): void {
+ KEY_EVENT_SERVICE.handleKeyDownOrUp(event);
+ }
+
+ override getExtraMenuOptions(
+ canvas: LGraphCanvas,
+ options: (IContextMenuValue | null)[],
+ ): (IContextMenuValue | null)[] {
+ // Some other extensions override getExtraMenuOptions on the nodeType as it comes through from
+ // the server, so we can call out to that if we don't have our own.
+ if (super.getExtraMenuOptions) {
+ super.getExtraMenuOptions?.apply(this, [canvas, options]);
+ } else if (this.constructor.nodeType?.prototype?.getExtraMenuOptions) {
+ this.constructor.nodeType?.prototype?.getExtraMenuOptions?.apply(this, [canvas, options]);
+ }
+ // If we have help content, then add a menu item.
+ const help = this.getHelp() || (this.constructor as any).help;
+ if (help) {
+ addHelpMenuItem(this, help, options);
+ }
+ return [];
+ }
+}
+
+/**
+ * A virtual node. Right now, this is just a wrapper for RgthreeBaseNode (which was the initial
+ * base virtual node).
+ */
+export class RgthreeBaseVirtualNode extends RgthreeBaseNode {
+ override isVirtualNode = true;
+
+ constructor(title = RgthreeBaseNode.title) {
+ super(title, false);
+ }
+
+ static override setUp() {
+ if (!this.type) {
+ throw new Error(`Missing type for RgthreeBaseVirtualNode: ${this.title}`);
+ }
+ LiteGraph.registerNodeType(this.type, this);
+ if (this._category) {
+ this.category = this._category;
+ }
+ }
+}
+
+/**
+ * A base node with standard methods, extending the LGraphNode.
+ * This is somewhat experimental, but if comfyui is going to keep breaking widgets and inputs, it
+ * seems safer than NOT overriding.
+ */
+export class RgthreeBaseServerNode extends RgthreeBaseNode {
+ static nodeType: LGraphNodeConstructor | null = null;
+ static nodeData: ComfyNodeDef | null = null;
+
+ // Drop is enabled by default for server nodes.
+ override isDropEnabled = true;
+
+ constructor(title: string) {
+ super(title, true);
+ this.serialize_widgets = true;
+ this.setupFromServerNodeData();
+ this.onConstructed();
+ }
+
+ getWidgets() {
+ return ComfyWidgets;
+ }
+
+ /**
+ * This takes the server data and builds out the inputs, outputs and widgets. It's similar to the
+ * ComfyNode constructor in registerNodes in ComfyUI's app.js, but is more stable and thus
+ * shouldn't break as often when it modifyies widgets and types.
+ */
+ async setupFromServerNodeData() {
+ const nodeData = (this.constructor as any).nodeData;
+ if (!nodeData) {
+ throw Error("No node data");
+ }
+
+ // Necessary for serialization so Comfy backend can check types.
+ // Serialized as `class_type`. See app.js#graphToPrompt
+ this.comfyClass = nodeData.name;
+
+ let inputs = nodeData["input"]["required"];
+ if (nodeData["input"]["optional"] != undefined) {
+ inputs = Object.assign({}, inputs, nodeData["input"]["optional"]);
+ }
+
+ const WIDGETS = this.getWidgets();
+
+ const config: {minWidth: number; minHeight: number; widget?: null | {options: any}} = {
+ minWidth: 1,
+ minHeight: 1,
+ widget: null,
+ };
+ for (const inputName in inputs) {
+ const inputData = inputs[inputName];
+ const type = inputData[0];
+ // If we're forcing the input, just do it now and forget all that widget stuff.
+ // This is one of the differences from ComfyNode and provides smoother experience for inputs
+ // that are going to remain inputs anyway.
+ // Also, it fixes https://github.com/comfyanonymous/ComfyUI/issues/1404 (for rgthree nodes)
+ if (inputData[1]?.forceInput) {
+ this.addInput(inputName, type);
+ } else {
+ let widgetCreated = true;
+ if (Array.isArray(type)) {
+ // Enums
+ Object.assign(config, WIDGETS.COMBO(this, inputName, inputData, app) || {});
+ } else if (`${type}:${inputName}` in WIDGETS) {
+ // Support custom widgets by Type:Name
+ Object.assign(
+ config,
+ WIDGETS[`${type}:${inputName}`]!(this, inputName, inputData, app) || {},
+ );
+ } else if (type in WIDGETS) {
+ // Standard type widgets
+ Object.assign(config, WIDGETS[type]!(this, inputName, inputData, app) || {});
+ } else {
+ // Node connection inputs
+ this.addInput(inputName, type);
+ widgetCreated = false;
+ }
+
+ // Don't actually need this right now, but ported it over from ComfyWidget.
+ if (widgetCreated && inputData[1]?.forceInput && config?.widget) {
+ if (!config.widget.options) config.widget.options = {};
+ config.widget.options.forceInput = inputData[1].forceInput;
+ }
+ if (widgetCreated && inputData[1]?.defaultInput && config?.widget) {
+ if (!config.widget.options) config.widget.options = {};
+ config.widget.options.defaultInput = inputData[1].defaultInput;
+ }
+ }
+ }
+
+ for (const o in nodeData["output"]) {
+ let output = nodeData["output"][o];
+ if (output instanceof Array) output = "COMBO";
+ const outputName = nodeData["output_name"][o] || output;
+ const outputShape = nodeData["output_is_list"][o]
+ ? LiteGraph.GRID_SHAPE
+ : LiteGraph.CIRCLE_SHAPE;
+ this.addOutput(outputName, output, {shape: outputShape});
+ }
+
+ const s = this.computeSize();
+ // Sometime around v1.12.6 this broke as `minWidth` and `minHeight` were being explicitly set
+ // to `undefined` in the above Object.assign call (specifically for `WIDGETS[INT]`. We can avoid
+ // that by ensureing we're at a number in that case.
+ // See https://github.com/Comfy-Org/ComfyUI_frontend/issues/3045
+ s[0] = Math.max(config.minWidth ?? 1, s[0] * 1.5);
+ s[1] = Math.max(config.minHeight ?? 1, s[1]);
+ this.size = s;
+ this.serialize_widgets = true;
+ }
+
+ static __registeredForOverride__: boolean = false;
+ static registerForOverride(
+ comfyClass: typeof LGraphNode,
+ nodeData: ComfyNodeDef,
+ rgthreeClass: RgthreeBaseServerNodeConstructor,
+ ) {
+ if (OVERRIDDEN_SERVER_NODES.has(comfyClass)) {
+ throw Error(
+ `Already have a class to override ${
+ comfyClass.type || comfyClass.name || comfyClass.title
+ }`,
+ );
+ }
+ OVERRIDDEN_SERVER_NODES.set(comfyClass, rgthreeClass);
+ // Mark the rgthreeClass as `__registeredForOverride__` because ComfyUI will repeatedly call
+ // this and certain setups will only want to setup once (like adding context menus, etc).
+ if (!rgthreeClass.__registeredForOverride__) {
+ rgthreeClass.__registeredForOverride__ = true;
+ rgthreeClass.nodeType = comfyClass;
+ rgthreeClass.nodeData = nodeData;
+ rgthreeClass.onRegisteredForOverride(comfyClass, rgthreeClass);
+ }
+ }
+
+ static onRegisteredForOverride(comfyClass: any, rgthreeClass: any) {
+ // To be overridden
+ }
+}
+
+/**
+ * Keeps track of the rgthree-comfy nodes that come from the server (and want to be ComfyNodes) that
+ * we override into a own, more flexible and cleaner nodes.
+ */
+const OVERRIDDEN_SERVER_NODES = new Map();
+
+const oldregisterNodeType = LiteGraph.registerNodeType;
+/**
+ * ComfyUI calls registerNodeType with its ComfyNode, but we don't trust that will remain stable, so
+ * we need to identify it, intercept it, and supply our own class for the node.
+ */
+LiteGraph.registerNodeType = async function (nodeId: string, baseClass: any) {
+ const clazz = OVERRIDDEN_SERVER_NODES.get(baseClass) || baseClass;
+ if (clazz !== baseClass) {
+ const classLabel = clazz.type || clazz.name || clazz.title;
+ const [n, v] = rgthree.logger.logParts(
+ LogLevel.DEBUG,
+ `${nodeId}: replacing default ComfyNode implementation with custom ${classLabel} class.`,
+ );
+ console[n]?.(...v);
+ // Note, we don't currently call our rgthree.invokeExtensionsAsync w/ beforeRegisterNodeDef as
+ // this runs right after that. However, this does mean that extensions cannot actually change
+ // anything about overriden server rgthree nodes in their beforeRegisterNodeDef (as when comfy
+ // calls it, it's for the wrong ComfyNode class). Calling it here, however, would re-run
+ // everything causing more issues than not. If we wanted to support beforeRegisterNodeDef then
+ // it would mean rewriting ComfyUI's registerNodeDef which, frankly, is not worth it.
+ }
+ return oldregisterNodeType.call(LiteGraph, nodeId, clazz);
+};
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_collector.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_collector.ts
new file mode 100644
index 0000000000000000000000000000000000000000..30076301e30ee179ebd566bfd6e6b4f3ac54c122
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_collector.ts
@@ -0,0 +1,99 @@
+import type {INodeOutputSlot, LGraphNode} from "@comfyorg/frontend";
+
+import {rgthree} from "./rgthree.js";
+import {BaseAnyInputConnectedNode} from "./base_any_input_connected_node.js";
+import {
+ PassThroughFollowing,
+ getConnectedInputNodes,
+ getConnectedInputNodesAndFilterPassThroughs,
+ shouldPassThrough,
+} from "./utils.js";
+
+/**
+ * Base collector node that monitors changing inputs and outputs.
+ */
+export class BaseCollectorNode extends BaseAnyInputConnectedNode {
+ /**
+ * We only want to show nodes through re_route nodes, other pass through nodes show each input.
+ */
+ override readonly inputsPassThroughFollowing: PassThroughFollowing =
+ PassThroughFollowing.REROUTE_ONLY;
+
+ readonly logger = rgthree.newLogSession("[BaseCollectorNode]");
+
+ constructor(title?: string) {
+ super(title);
+ }
+
+ override clone() {
+ const cloned = super.clone()!;
+ return cloned;
+ }
+
+ override handleLinkedNodesStabilization(linkedNodes: LGraphNode[]) {
+ return false; // No-op, no widgets.
+ }
+
+ /**
+ * When we connect an input, check to see if it's already connected and cancel it.
+ */
+ override onConnectInput(
+ inputIndex: number,
+ outputType: string | -1,
+ outputSlot: INodeOutputSlot,
+ outputNode: LGraphNode,
+ outputIndex: number,
+ ): boolean {
+ let canConnect = super.onConnectInput(
+ inputIndex,
+ outputType,
+ outputSlot,
+ outputNode,
+ outputIndex,
+ );
+ if (canConnect) {
+ const allConnectedNodes = getConnectedInputNodes(this); // We want passthrough nodes, since they will loop.
+ const nodesAlreadyInSlot = getConnectedInputNodes(this, undefined, inputIndex);
+ if (allConnectedNodes.includes(outputNode)) {
+ // If we're connecting to the same slot, then allow it by replacing the one we have.
+ // const slotsOriginNode = getOriginNodeByLink(this.inputs[inputIndex]?.link);
+ const [n, v] = this.logger.debugParts(
+ `${outputNode.title} is already connected to ${this.title}.`,
+ );
+ console[n]?.(...v);
+ if (nodesAlreadyInSlot.includes(outputNode)) {
+ const [n, v] = this.logger.debugParts(
+ `... but letting it slide since it's for the same slot.`,
+ );
+ console[n]?.(...v);
+ } else {
+ canConnect = false;
+ }
+ }
+ if (canConnect && shouldPassThrough(outputNode, PassThroughFollowing.REROUTE_ONLY)) {
+ const connectedNode = getConnectedInputNodesAndFilterPassThroughs(
+ outputNode,
+ undefined,
+ undefined,
+ PassThroughFollowing.REROUTE_ONLY,
+ )[0];
+ if (connectedNode && allConnectedNodes.includes(connectedNode)) {
+ // If we're connecting to the same slot, then allow it by replacing the one we have.
+ const [n, v] = this.logger.debugParts(
+ `${connectedNode.title} is already connected to ${this.title}.`,
+ );
+ console[n]?.(...v);
+ if (nodesAlreadyInSlot.includes(connectedNode)) {
+ const [n, v] = this.logger.debugParts(
+ `... but letting it slide since it's for the same slot.`,
+ );
+ console[n]?.(...v);
+ } else {
+ canConnect = false;
+ }
+ }
+ }
+ }
+ return canConnect;
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_mode_changer.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_mode_changer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae1afeafd900c6143a696c5612fc63edf59327d3
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/base_node_mode_changer.ts
@@ -0,0 +1,106 @@
+import type {LGraphNode, IWidget} from "@comfyorg/frontend";
+
+import {BaseAnyInputConnectedNode} from "./base_any_input_connected_node.js";
+import {changeModeOfNodes, PassThroughFollowing} from "./utils.js";
+import {wait} from "rgthree/common/shared_utils.js";
+
+export class BaseNodeModeChanger extends BaseAnyInputConnectedNode {
+ override readonly inputsPassThroughFollowing: PassThroughFollowing = PassThroughFollowing.ALL;
+
+ static collapsible = false;
+ override isVirtualNode = true;
+
+ // These Must be overriden
+ readonly modeOn: number = -1;
+ readonly modeOff: number = -1;
+
+ static "@toggleRestriction" = {
+ type: "combo",
+ values: ["default", "max one", "always one"],
+ };
+
+ constructor(title?: string) {
+ super(title);
+ this.properties["toggleRestriction"] = "default";
+ }
+
+ override onConstructed(): boolean {
+ wait(10).then(() => {
+ if (this.modeOn < 0 || this.modeOff < 0) {
+ throw new Error("modeOn and modeOff must be overridden.");
+ }
+ });
+ this.addOutput("OPT_CONNECTION", "*");
+ return super.onConstructed();
+ }
+
+ override handleLinkedNodesStabilization(linkedNodes: LGraphNode[]) {
+ let changed = false;
+ for (const [index, node] of linkedNodes.entries()) {
+ let widget: IWidget | undefined = this.widgets && this.widgets[index];
+ if (!widget) {
+ // When we add a widget, litegraph is going to mess up the size, so we
+ // store it so we can retrieve it in computeSize. Hacky..
+ (this as any)._tempWidth = this.size[0];
+ widget = this.addWidget("toggle", "", false, "", {on: "yes", off: "no"}) as IWidget;
+ changed = true;
+ }
+ if (node) {
+ changed = this.setWidget(widget, node) || changed;
+ }
+ }
+ if (this.widgets && this.widgets.length > linkedNodes.length) {
+ this.widgets.length = linkedNodes.length;
+ changed = true;
+ }
+ return changed;
+ }
+
+ private setWidget(widget: IWidget, linkedNode: LGraphNode, forceValue?: boolean) {
+ let changed = false;
+ const value = forceValue == null ? linkedNode.mode === this.modeOn : forceValue;
+ let name = `Enable ${linkedNode.title}`;
+ // Need to set initally
+ if (widget.name !== name) {
+ widget.name = `Enable ${linkedNode.title}`;
+ widget.options = {on: "yes", off: "no"};
+ widget.value = value;
+ (widget as any).doModeChange = (forceValue?: boolean, skipOtherNodeCheck?: boolean) => {
+ let newValue = forceValue == null ? linkedNode.mode === this.modeOff : forceValue;
+ if (skipOtherNodeCheck !== true) {
+ if (newValue && (this.properties?.["toggleRestriction"] as string)?.includes(" one")) {
+ for (const widget of this.widgets) {
+ (widget as any).doModeChange(false, true);
+ }
+ } else if (!newValue && this.properties?.["toggleRestriction"] === "always one") {
+ newValue = this.widgets.every((w) => !w.value || w === widget);
+ }
+ }
+ changeModeOfNodes(linkedNode, (newValue ? this.modeOn : this.modeOff))
+ widget.value = newValue;
+ };
+ widget.callback = () => {
+ (widget as any).doModeChange();
+ };
+ changed = true;
+ }
+ if (forceValue != null) {
+ const newMode = (forceValue ? this.modeOn : this.modeOff) as 1 | 2 | 3 | 4;
+ if (linkedNode.mode !== newMode) {
+ changeModeOfNodes(linkedNode, newMode);
+ changed = true;
+ }
+ }
+ return changed;
+ }
+
+ forceWidgetOff(widget: IWidget, skipOtherNodeCheck?: boolean) {
+ (widget as any).doModeChange(false, skipOtherNodeCheck);
+ }
+ forceWidgetOn(widget: IWidget, skipOtherNodeCheck?: boolean) {
+ (widget as any).doModeChange(true, skipOtherNodeCheck);
+ }
+ forceWidgetToggle(widget: IWidget, skipOtherNodeCheck?: boolean) {
+ (widget as any).doModeChange(!widget.value, skipOtherNodeCheck);
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/base_power_prompt.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/base_power_prompt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..02a161b7e88be4f6184578578b14d0f0c869373d
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/base_power_prompt.ts
@@ -0,0 +1,366 @@
+import type {
+ LLink,
+ LGraphNode,
+ INodeOutputSlot,
+ INodeInputSlot,
+ ISerialisedNode,
+ IComboWidget,
+ IBaseWidget,
+} from "@comfyorg/frontend";
+import type {ComfyNodeDef} from "typings/comfy.js";
+
+import {api} from "scripts/api.js";
+import {wait} from "rgthree/common/shared_utils.js";
+import {rgthree} from "./rgthree.js";
+
+/** Wraps a node instance keeping closure without mucking the finicky types. */
+export class PowerPrompt {
+ readonly isSimple: boolean;
+ readonly node: LGraphNode;
+ readonly promptEl: HTMLTextAreaElement;
+ nodeData: ComfyNodeDef;
+ readonly combos: {[key: string]: IComboWidget} = {};
+ readonly combosValues: {[key: string]: string[]} = {};
+ boundOnFreshNodeDefs!: (event: CustomEvent) => void;
+
+ private configuring = false;
+
+ constructor(node: LGraphNode, nodeData: ComfyNodeDef) {
+ this.node = node;
+ this.node.properties = this.node.properties || {};
+
+ this.node.properties["combos_filter"] = "";
+
+ this.nodeData = nodeData;
+ this.isSimple = this.nodeData.name.includes("Simple");
+
+ this.promptEl = (node.widgets![0]! as any).inputEl;
+ this.addAndHandleKeyboardLoraEditWeight();
+
+ this.patchNodeRefresh();
+
+ const oldConfigure = this.node.configure;
+ this.node.configure = (info: ISerialisedNode) => {
+ this.configuring = true;
+ oldConfigure?.apply(this.node, [info]);
+ this.configuring = false;
+ };
+
+ const oldOnConnectionsChange = this.node.onConnectionsChange;
+ this.node.onConnectionsChange = (
+ type: number,
+ slotIndex: number,
+ isConnected: boolean,
+ link_info: LLink,
+ _ioSlot: INodeOutputSlot | INodeInputSlot,
+ ) => {
+ oldOnConnectionsChange?.apply(this.node, [type, slotIndex, isConnected, link_info, _ioSlot]);
+ this.onNodeConnectionsChange(type, slotIndex, isConnected, link_info, _ioSlot);
+ };
+
+ const oldOnConnectInput = this.node.onConnectInput;
+ this.node.onConnectInput = (
+ inputIndex: number,
+ outputType: INodeOutputSlot["type"],
+ outputSlot: INodeOutputSlot,
+ outputNode: LGraphNode,
+ outputIndex: number,
+ ) => {
+ let canConnect = true;
+ if (oldOnConnectInput) {
+ canConnect = oldOnConnectInput.apply(this.node, [
+ inputIndex,
+ outputType,
+ outputSlot,
+ outputNode,
+ outputIndex,
+ ]);
+ }
+ return (
+ this.configuring ||
+ !!rgthree.loadingApiJson ||
+ (canConnect && !this.node.inputs[inputIndex]!.disabled)
+ );
+ };
+
+ const oldOnConnectOutput = this.node.onConnectOutput;
+ this.node.onConnectOutput = (
+ outputIndex: number,
+ inputType: INodeInputSlot["type"],
+ inputSlot: INodeInputSlot,
+ inputNode: LGraphNode,
+ inputIndex: number,
+ ) => {
+ let canConnect = true;
+ if (oldOnConnectOutput) {
+ canConnect = oldOnConnectOutput?.apply(this.node, [
+ outputIndex,
+ inputType,
+ inputSlot,
+ inputNode,
+ inputIndex,
+ ]);
+ }
+ return (
+ this.configuring ||
+ !!rgthree.loadingApiJson ||
+ (canConnect && !this.node.outputs[outputIndex]!.disabled)
+ );
+ };
+
+ const onPropertyChanged = this.node.onPropertyChanged;
+ this.node.onPropertyChanged = (property: string, value: any, prevValue: any) => {
+ const v = onPropertyChanged && onPropertyChanged.call(this.node, property, value, prevValue);
+ if (property === "combos_filter") {
+ this.refreshCombos(this.nodeData);
+ }
+ return v ?? true;
+ };
+
+ // Strip all widgets but prompt (we'll re-add them in refreshCombos)
+ // this.node.widgets.splice(1);
+ for (let i = this.node.widgets!.length - 1; i >= 0; i--) {
+ if (this.shouldRemoveServerWidget(this.node.widgets![i]!)) {
+ this.node.widgets!.splice(i, 1);
+ }
+ }
+
+ this.refreshCombos(nodeData);
+ setTimeout(() => {
+ this.stabilizeInputsOutputs();
+ }, 32);
+ }
+
+ /**
+ * Cleans up optional out puts when we don't have the optional input. Purely a vanity function.
+ */
+ onNodeConnectionsChange(
+ _type: number,
+ _slotIndex: number,
+ _isConnected: boolean,
+ _linkInfo: LLink,
+ _ioSlot: INodeOutputSlot | INodeInputSlot,
+ ) {
+ this.stabilizeInputsOutputs();
+ }
+
+ private stabilizeInputsOutputs() {
+ // If we are currently "configuring" then skip this stabilization. The connected nodes may
+ // not yet be configured.
+ if (this.configuring || rgthree.loadingApiJson) {
+ return;
+ }
+ // If our first input is connected, then we can show the proper output.
+ const clipLinked = this.node.inputs.some((i) => i.name.includes("clip") && !!i.link);
+ const modelLinked = this.node.inputs.some((i) => i.name.includes("model") && !!i.link);
+ for (const output of this.node.outputs) {
+ const type = (output.type as string).toLowerCase();
+ if (type.includes("model")) {
+ output.disabled = !modelLinked;
+ } else if (type.includes("conditioning")) {
+ output.disabled = !clipLinked;
+ } else if (type.includes("clip")) {
+ output.disabled = !clipLinked;
+ } else if (type.includes("string")) {
+ // Our text prompt is always enabled, but let's color it so it stands out
+ // if the others are disabled. #7F7 is Litegraph's default.
+ output.color_off = "#7F7";
+ output.color_on = "#7F7";
+ }
+ if (output.disabled) {
+ // this.node.disconnectOutput(index);
+ }
+ }
+ }
+
+ onFreshNodeDefs(event: CustomEvent) {
+ this.refreshCombos(event.detail[this.nodeData.name]);
+ }
+
+ shouldRemoveServerWidget(widget: IBaseWidget) {
+ return (
+ widget.name?.startsWith("insert_") ||
+ widget.name?.startsWith("target_") ||
+ widget.name?.startsWith("crop_") ||
+ widget.name?.startsWith("values_")
+ );
+ }
+
+ refreshCombos(nodeData: ComfyNodeDef) {
+ this.nodeData = nodeData;
+ let filter: RegExp | null = null;
+ if ((this.node.properties["combos_filter"] as string)?.trim()) {
+ try {
+ filter = new RegExp((this.node.properties["combos_filter"] as string).trim(), "i");
+ } catch (e) {
+ console.error(`Could not parse "${filter}" for Regular Expression`, e);
+ filter = null;
+ }
+ }
+
+ // Add the combo for hidden inputs of nodeData
+ let data = Object.assign(
+ {},
+ this.nodeData.input?.optional || {},
+ this.nodeData.input?.hidden || {},
+ );
+
+ for (const [key, value] of Object.entries(data)) {
+ //Object.entries(this.nodeData.input?.hidden || {})) {
+ if (Array.isArray(value[0])) {
+ let values = value[0] as string[];
+ if (key.startsWith("insert")) {
+ values = filter
+ ? values.filter(
+ (v, i) => i < 1 || (i == 1 && v.match(/^disable\s[a-z]/i)) || filter?.test(v),
+ )
+ : values;
+ const shouldShow =
+ values.length > 2 || (values.length > 1 && !values[1]!.match(/^disable\s[a-z]/i));
+ if (shouldShow) {
+ if (!this.combos[key]) {
+ this.combos[key] = this.node.addWidget(
+ "combo",
+ key,
+ values[0]!,
+ (selected) => {
+ if (selected !== values[0] && !selected.match(/^disable\s[a-z]/i)) {
+ // We wait a frame because if we use a keydown event to call, it'll wipe out
+ // the selection.
+ wait().then(() => {
+ if (key.includes("embedding")) {
+ this.insertSelectionText(`embedding:${selected}`);
+ } else if (key.includes("saved")) {
+ this.insertSelectionText(
+ this.combosValues[`values_${key}`]![values.indexOf(selected)]!,
+ );
+ } else if (key.includes("lora")) {
+ this.insertSelectionText(``);
+ }
+ this.combos[key]!.value = values[0]!;
+ });
+ }
+ },
+ {
+ values,
+ serialize: true, // Don't include this in prompt.
+ },
+ ) as IComboWidget;
+ (this.combos[key]! as any).oldComputeSize = this.combos[key]!.computeSize;
+ let node = this.node;
+ this.combos[key]!.computeSize = function (width: number) {
+ const size = (this as any).oldComputeSize?.(width) || [
+ width,
+ LiteGraph.NODE_WIDGET_HEIGHT,
+ ];
+ if (this === node.widgets![node.widgets!.length - 1]) {
+ size[1] += 10;
+ }
+ return size;
+ };
+ }
+ this.combos[key]!.options!.values = values;
+ this.combos[key]!.value = values[0]!;
+ } else if (!shouldShow && this.combos[key]) {
+ this.node.widgets!.splice(this.node.widgets!.indexOf(this.combos[key]!), 1);
+ delete this.combos[key];
+ }
+ } else if (key.startsWith("values")) {
+ this.combosValues[key] = values;
+ }
+ }
+ }
+ }
+
+ insertSelectionText(text: string) {
+ if (!this.promptEl) {
+ console.error("Asked to insert text, but no textbox found.");
+ return;
+ }
+ let prompt = this.promptEl.value;
+ // Use selectionEnd as the split; if we have highlighted text, then we likely don't want to
+ // overwrite it (we could have just deleted it more easily).
+ let first = prompt.substring(0, this.promptEl.selectionEnd).replace(/ +$/, "");
+ first = first + (["\n"].includes(first[first.length - 1]!) ? "" : first.length ? " " : "");
+ let second = prompt.substring(this.promptEl.selectionEnd).replace(/^ +/, "");
+ second = (["\n"].includes(second[0]!) ? "" : second.length ? " " : "") + second;
+ this.promptEl.value = first + text + second;
+ this.promptEl.focus();
+ this.promptEl.selectionStart = first.length;
+ this.promptEl.selectionEnd = first.length + text.length;
+ }
+
+ /**
+ * Adds a keydown event listener to our prompt so we can see if we're using the
+ * ctrl/cmd + up/down arrows shortcut. This kind of competes with the core extension
+ * "Comfy.EditAttention" but since that only handles parenthesis and listens on window, we should
+ * be able to intercept and cancel the bubble if we're doing the same action within the lora tag.
+ */
+ addAndHandleKeyboardLoraEditWeight() {
+ this.promptEl.addEventListener("keydown", (event: KeyboardEvent) => {
+ // If we're not doing a ctrl/cmd + arrow key, then bail.
+ if (!(event.key === "ArrowUp" || event.key === "ArrowDown")) return;
+ if (!event.ctrlKey && !event.metaKey) return;
+ // Unfortunately, we can't see Comfy.EditAttention delta in settings, so we hardcode to 0.01.
+ // We can acutally do better too, let's make it .1 by default, and .01 if also holding shift.
+ const delta = event.shiftKey ? 0.01 : 0.1;
+
+ let start = this.promptEl.selectionStart;
+ let end = this.promptEl.selectionEnd;
+ let fullText = this.promptEl.value;
+ let selectedText = fullText.substring(start, end);
+
+ // We don't care about fully rewriting Comfy.EditAttention, we just want to see if our
+ // selected text is a lora, which will always start with "") {
+ start -= 2;
+ end -= 2;
+ }
+ if (fullText[end - 1] == "<") {
+ start += 2;
+ end += 2;
+ }
+ while (!stopOn.includes(fullText[start]!) && start > 0) {
+ start--;
+ }
+ while (!stopOn.includes(fullText[end - 1]!) && end < fullText.length) {
+ end++;
+ }
+ selectedText = fullText.substring(start, end);
+ }
+
+ // Bail if this isn't a lora.
+ if (!selectedText.startsWith("")) {
+ return;
+ }
+
+ let weight = Number(selectedText.match(/:(-?\d*(\.\d*)?)>$/)?.[1]) ?? 1;
+ weight += event.key === "ArrowUp" ? delta : -delta;
+ const updatedText = selectedText.replace(/(:-?\d*(\.\d*)?)?>$/, `:${weight.toFixed(2)}>`);
+
+ // Handle the new value and cancel the bubble so Comfy.EditAttention doesn't also try.
+ this.promptEl.setRangeText(updatedText, start, end, "select");
+ event.preventDefault();
+ event.stopPropagation();
+ });
+ }
+
+ /**
+ * Patches over api.getNodeDefs in comfy's api.js to fire a custom event that we can listen to
+ * here and manually refresh our combos when a request comes in to fetch the node data; which
+ * only happens once at startup (but before custom nodes js runs), and then after clicking
+ * the "Refresh" button in the floating menu, which is what we care about.
+ */
+ patchNodeRefresh() {
+ this.boundOnFreshNodeDefs = this.onFreshNodeDefs.bind(this);
+ api.addEventListener("fresh-node-defs", this.boundOnFreshNodeDefs as EventListener);
+ const oldNodeRemoved = this.node.onRemoved;
+ this.node.onRemoved = () => {
+ oldNodeRemoved?.call(this.node);
+ api.removeEventListener("fresh-node-defs", this.boundOnFreshNodeDefs as EventListener);
+ };
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/bookmark.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/bookmark.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8eb742302b56d958b35e0c3e30c2e48b9c1f5188
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/bookmark.ts
@@ -0,0 +1,163 @@
+import type {
+ LGraph,
+ LGraphCanvas,
+ LGraphNode,
+ Point,
+ CanvasMouseEvent,
+ Subgraph,
+} from "@comfyorg/frontend";
+
+import {app} from "scripts/app.js";
+import {RgthreeBaseVirtualNode} from "./base_node.js";
+import {SERVICE as KEY_EVENT_SERVICE} from "./services/key_events_services.js";
+import {SERVICE as BOOKMARKS_SERVICE} from "./services/bookmarks_services.js";
+import {NodeTypesString} from "./constants.js";
+import {getClosestOrSelf, query} from "rgthree/common/utils_dom.js";
+import {wait} from "rgthree/common/shared_utils.js";
+import {findFromNodeForSubgraph} from "./utils.js";
+
+/**
+ * A bookmark node. Can be placed anywhere in the workflow, and given a shortcut key that will
+ * navigate to that node, with it in the top-left corner.
+ */
+export class Bookmark extends RgthreeBaseVirtualNode {
+ static override type = NodeTypesString.BOOKMARK;
+ static override title = NodeTypesString.BOOKMARK;
+ override comfyClass = NodeTypesString.BOOKMARK;
+
+ // Really silly, but Litegraph assumes we have at least one input/output... so we need to
+ // counteract it's computeSize calculation by offsetting the start.
+ static slot_start_y = -20;
+
+ // LiteGraph adds mroe spacing than we want when calculating a nodes' `_collapsed_width`, so we'll
+ // override it with a setter and re-set it measured exactly as we want.
+ ___collapsed_width: number = 0;
+
+ override isVirtualNode = true;
+ override serialize_widgets = true;
+
+ //@ts-ignore - TS Doesn't like us overriding a property with accessors but, too bad.
+ override get _collapsed_width() {
+ return this.___collapsed_width;
+ }
+
+ override set _collapsed_width(width: number) {
+ const canvas = app.canvas as LGraphCanvas;
+ const ctx = canvas.canvas.getContext("2d")!;
+ const oldFont = ctx.font;
+ ctx.font = canvas.title_text_font;
+ this.___collapsed_width = 40 + ctx.measureText(this.title).width;
+ ctx.font = oldFont;
+ }
+
+ readonly keypressBound;
+
+ constructor(title = Bookmark.title) {
+ super(title);
+ const nextShortcutChar = BOOKMARKS_SERVICE.getNextShortcut();
+ this.addWidget(
+ "text",
+ "shortcut_key",
+ nextShortcutChar,
+ (value: string, ...args) => {
+ value = value.trim()[0] || "1";
+ },
+ {
+ y: 8,
+ },
+ );
+ this.addWidget("number", "zoom", 1, (value: number) => {}, {
+ y: 8 + LiteGraph.NODE_WIDGET_HEIGHT + 4,
+ max: 2,
+ min: 0.5,
+ precision: 2,
+ });
+ this.keypressBound = this.onKeypress.bind(this);
+ this.title = "🔖";
+ this.onConstructed();
+ }
+
+ // override computeSize(out?: Vector2 | undefined): Vector2 {
+ // super.computeSize(out);
+ // const minHeight = (this.widgets?.length || 0) * (LiteGraph.NODE_WIDGET_HEIGHT + 4) + 16;
+ // this.size[1] = Math.max(minHeight, this.size[1]);
+ // }
+
+ get shortcutKey(): string {
+ return (this.widgets[0]?.value as string)?.toLocaleLowerCase() ?? "";
+ }
+
+ override onAdded(graph: LGraph): void {
+ KEY_EVENT_SERVICE.addEventListener("keydown", this.keypressBound as EventListener);
+ }
+
+ override onRemoved(): void {
+ KEY_EVENT_SERVICE.removeEventListener("keydown", this.keypressBound as EventListener);
+ }
+
+ onKeypress(event: CustomEvent<{originalEvent: KeyboardEvent}>) {
+ const originalEvent = event.detail.originalEvent;
+ const target = (originalEvent.target as HTMLElement)!;
+ if (getClosestOrSelf(target, 'input,textarea,[contenteditable="true"]')) {
+ return;
+ }
+
+ // Only the shortcut keys are held down, optionally including "shift".
+ if (KEY_EVENT_SERVICE.areOnlyKeysDown(this.widgets[0]!.value as string, true)) {
+ this.canvasToBookmark();
+ originalEvent.preventDefault();
+ originalEvent.stopPropagation();
+ }
+ }
+
+ /**
+ * Called from LiteGraph's `processMouseDown` after it would invoke the input box for the
+ * shortcut_key, so we check if it exists and then add our own event listener so we can track the
+ * keys down for the user. Note, blocks drag if the return is truthy.
+ */
+ override onMouseDown(event: CanvasMouseEvent, pos: Point, graphCanvas: LGraphCanvas): boolean {
+ const input = query(".graphdialog > input.value");
+ if (input && input.value === this.widgets[0]?.value) {
+ input.addEventListener("keydown", (e) => {
+ // ComfyUI swallows keydown on inputs, so we need to call out to rgthree to use downkeys.
+ KEY_EVENT_SERVICE.handleKeyDownOrUp(e);
+ e.preventDefault();
+ e.stopPropagation();
+ input.value = Object.keys(KEY_EVENT_SERVICE.downKeys).join(" + ");
+ });
+ }
+ return false;
+ }
+
+ async canvasToBookmark() {
+ const canvas = app.canvas as LGraphCanvas;
+ if (this.graph !== app.canvas.getCurrentGraph()) {
+ const subgraph = this.graph as Subgraph;
+ // At some point, ComfyUI made a second param for openSubgraph which appears to be the node
+ // that id double-clicked on to open the subgraph. We don't have that in the bookmark, so
+ // we'll look for it. Note, that when opening the root graph, this will be null (since there's
+ // no such node). It seems to still navigate fine, though there's a console error about
+ // proxyWidgets or something..
+ const fromNode = findFromNodeForSubgraph(subgraph.id);
+ canvas.openSubgraph(subgraph, fromNode!);
+ await wait(16);
+ }
+ // ComfyUI seemed to break us again, but couldn't repro. No reason to not check, I guess.
+ // https://github.com/rgthree/rgthree-comfy/issues/71
+ if (canvas?.ds?.offset) {
+ canvas.ds.offset[0] = -this.pos[0] + 16;
+ canvas.ds.offset[1] = -this.pos[1] + 40;
+ }
+ if (canvas?.ds?.scale != null) {
+ canvas.ds.scale = Number(this.widgets[1]!.value || 1);
+ }
+ canvas.setDirty(true, true);
+ }
+}
+
+app.registerExtension({
+ name: "rgthree.Bookmark",
+ registerCustomNodes() {
+ Bookmark.setUp();
+ },
+});
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/bypasser.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/bypasser.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0cfb51f83a0ed7f221cc9e66392d9b58f2c6e331
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/bypasser.ts
@@ -0,0 +1,52 @@
+import type {LGraphNode} from "@comfyorg/frontend";
+
+import {app} from "scripts/app.js";
+import {BaseNodeModeChanger} from "./base_node_mode_changer.js";
+import {NodeTypesString} from "./constants.js";
+
+const MODE_BYPASS = 4;
+const MODE_ALWAYS = 0;
+
+class BypasserNode extends BaseNodeModeChanger {
+ static override exposedActions = ["Bypass all", "Enable all", "Toggle all"];
+
+ static override type = NodeTypesString.FAST_BYPASSER;
+ static override title = NodeTypesString.FAST_BYPASSER;
+ override comfyClass = NodeTypesString.FAST_BYPASSER;
+
+ override readonly modeOn = MODE_ALWAYS;
+ override readonly modeOff = MODE_BYPASS;
+
+ constructor(title = BypasserNode.title) {
+ super(title);
+ this.onConstructed();
+ }
+
+ override async handleAction(action: string) {
+ if (action === "Bypass all") {
+ for (const widget of this.widgets || []) {
+ this.forceWidgetOff(widget, true);
+ }
+ } else if (action === "Enable all") {
+ for (const widget of this.widgets || []) {
+ this.forceWidgetOn(widget, true);
+ }
+ } else if (action === "Toggle all") {
+ for (const widget of this.widgets || []) {
+ this.forceWidgetToggle(widget, true);
+ }
+ }
+ }
+}
+
+app.registerExtension({
+ name: "rgthree.Bypasser",
+ registerCustomNodes() {
+ BypasserNode.setUp();
+ },
+ loadedGraphNode(node: LGraphNode) {
+ if (node.type == BypasserNode.title) {
+ (node as any)._tempWidth = node.size[0];
+ }
+ },
+});
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/comfy_ui_bar.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/comfy_ui_bar.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af79cc9571286a4601d5db77e6f28ef9e2df3071
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/comfy_ui_bar.ts
@@ -0,0 +1,264 @@
+import {app} from "scripts/app.js";
+import {iconGear, iconStarFilled, logoRgthreeAsync} from "rgthree/common/media/svgs.js";
+import {$el, empty} from "rgthree/common/utils_dom.js";
+import {SERVICE as BOOKMARKS_SERVICE} from "./services/bookmarks_services.js";
+import {SERVICE as CONFIG_SERVICE} from "./services/config_service.js";
+import {RgthreeConfigDialog} from "./config.js";
+import {wait} from "rgthree/common/shared_utils.js";
+
+let rgthreeButtonGroup: RgthreeComfyButtonGroup | null = null;
+
+function addRgthreeTopBarButtons() {
+ if (!CONFIG_SERVICE.getFeatureValue("comfy_top_bar_menu.enabled")) {
+ if (rgthreeButtonGroup?.element?.parentElement) {
+ rgthreeButtonGroup.element.parentElement.removeChild(rgthreeButtonGroup.element);
+ }
+ return;
+ } else if (rgthreeButtonGroup) {
+ app.menu?.settingsGroup.element.before(rgthreeButtonGroup.element);
+ return;
+ }
+
+ const buttons = [];
+
+ const rgthreeButton = new RgthreeComfyButton({
+ icon: "",
+ tooltip: "rgthree-comfy",
+ primary: true,
+ // content: 'rgthree-comfy',
+ // app,
+ enabled: true,
+ classList: "comfyui-button comfyui-menu-mobile-collapse primary",
+ });
+ buttons.push(rgthreeButton);
+ logoRgthreeAsync().then((t) => {
+ rgthreeButton.setIcon(t);
+ });
+
+ rgthreeButton.withPopup(
+ new RgthreeComfyPopup(
+ {target: rgthreeButton.element},
+ $el("menu.rgthree-menu.rgthree-top-menu", {
+ children: [
+ $el("li", {
+ child: $el("button.rgthree-button-reset", {
+ html: iconGear + "Settings (rgthree-comfy)",
+ onclick: () => new RgthreeConfigDialog().show(),
+ }),
+ }),
+ $el("li", {
+ child: $el("button.rgthree-button-reset", {
+ html: iconStarFilled + "Star on Github",
+ onclick: () => window.open("https://github.com/rgthree/rgthree-comfy", "_blank"),
+ }),
+ }),
+ ],
+ }),
+ ),
+ "click",
+ );
+
+ if (CONFIG_SERVICE.getFeatureValue("comfy_top_bar_menu.button_bookmarks.enabled")) {
+ const bookmarksListEl = $el("menu.rgthree-menu.rgthree-top-menu");
+ bookmarksListEl.appendChild(
+ $el("li.rgthree-message", {
+ child: $el("span", {text: "No bookmarks in current workflow."}),
+ }),
+ );
+ const bookmarksButton = new RgthreeComfyButton({
+ icon: "bookmark",
+ tooltip: "Workflow Bookmarks (rgthree-comfy)",
+ // app,
+ });
+ const bookmarksPopup = new RgthreeComfyPopup(
+ {target: bookmarksButton.element, modal: false},
+ bookmarksListEl,
+ );
+ bookmarksPopup.onOpen(() => {
+ const bookmarks = BOOKMARKS_SERVICE.getCurrentBookmarks();
+ empty(bookmarksListEl);
+ if (bookmarks.length) {
+ for (const b of bookmarks) {
+ bookmarksListEl.appendChild(
+ $el("li", {
+ child: $el("button.rgthree-button-reset", {
+ text: `[${b.shortcutKey}] ${b.title}`,
+ onclick: () => {
+ b.canvasToBookmark();
+ },
+ }),
+ }),
+ );
+ }
+ } else {
+ bookmarksListEl.appendChild(
+ $el("li.rgthree-message", {
+ child: $el("span", {text: "No bookmarks in current workflow."}),
+ }),
+ );
+ }
+ // bookmarksPopup.update();
+ });
+ bookmarksButton.withPopup(bookmarksPopup, "hover");
+ buttons.push(bookmarksButton);
+ }
+
+ rgthreeButtonGroup = new RgthreeComfyButtonGroup(...buttons);
+ app.menu?.settingsGroup.element.before(rgthreeButtonGroup.element);
+}
+
+app.registerExtension({
+ name: "rgthree.TopMenu",
+ async setup() {
+ addRgthreeTopBarButtons();
+
+ CONFIG_SERVICE.addEventListener("config-change", ((e: CustomEvent) => {
+ if (e.detail?.key?.includes("features.comfy_top_bar_menu")) {
+ addRgthreeTopBarButtons();
+ }
+ }) as EventListener);
+ },
+});
+
+// The following are rough hacks since ComfyUI took away their button/buttongroup/popup
+// functionality. TODO: Find a better spot to add rgthree controls to the UI, I suppose.
+
+class RgthreeComfyButtonGroup {
+ element = $el("div.rgthree-comfybar-top-button-group");
+ buttons: RgthreeComfyButton[];
+
+ constructor(...buttons: RgthreeComfyButton[]) {
+ this.buttons = buttons;
+ this.update();
+ }
+
+ insert(button: RgthreeComfyButton, index: number) {
+ this.buttons.splice(index, 0, button);
+ this.update();
+ }
+
+ append(button: RgthreeComfyButton) {
+ this.buttons.push(button);
+ this.update();
+ }
+
+ remove(indexOrButton: RgthreeComfyButton | number) {
+ if (typeof indexOrButton !== "number") {
+ indexOrButton = this.buttons.indexOf(indexOrButton);
+ }
+ if (indexOrButton > -1) {
+ const btn = this.buttons.splice(indexOrButton, 1);
+ this.update();
+ return btn;
+ }
+ return null;
+ }
+
+ update() {
+ this.element.replaceChildren(...this.buttons.map((b) => b["element"] ?? b));
+ }
+}
+
+interface RgthreeComfyButtonOptions {
+ icon?: string;
+ primary?: boolean;
+ overIcon?: string;
+ iconSize?: number;
+ content?: string | HTMLElement;
+ tooltip?: string;
+ enabled?: boolean;
+ action?: (e: Event, btn: RgthreeComfyButton) => void;
+ classList?: string;
+ visibilitySetting?: {id: string; showValue: any};
+ // app?: ComfyApp;
+}
+
+class RgthreeComfyButton {
+ element = $el("button.rgthree-comfybar-top-button.rgthree-button-reset.rgthree-button");
+ iconElement = $el("span.rgthree-button-icon");
+ constructor(opts: RgthreeComfyButtonOptions) {
+ opts.icon && this.setIcon(opts.icon);
+ opts.tooltip && this.element.setAttribute("title", opts.tooltip);
+ opts.primary && this.element.classList.add("-primary");
+ }
+
+ setIcon(iconOrMarkup: string) {
+ const markup = iconOrMarkup.startsWith("<")
+ ? iconOrMarkup
+ : ``;
+ this.iconElement.innerHTML = markup;
+ if (!this.iconElement.parentElement) {
+ this.element.appendChild(this.iconElement);
+ }
+ }
+
+ withPopup(popup: RgthreeComfyPopup, trigger: "click" | "hover") {
+ if (trigger === "click") {
+ this.element.addEventListener("click", () => {
+ popup.open();
+ });
+ }
+ if (trigger === "hover") {
+ this.element.addEventListener("pointerenter", () => {
+ popup.open();
+ });
+ }
+ }
+}
+
+interface RgthreeComfyPopupOptions {
+ target: HTMLElement;
+ classList?: string;
+ modal?: boolean;
+}
+
+class RgthreeComfyPopup {
+ element: HTMLElement;
+ target?: HTMLElement;
+ onOpenFn: (() => Promise | void) | null = null;
+ opts: RgthreeComfyPopupOptions;
+
+ onWindowClickBound = this.onWindowClick.bind(this);
+
+ constructor(opts: RgthreeComfyPopupOptions, element: HTMLElement) {
+ this.element = element;
+ this.opts = opts;
+ opts.target && (this.target = opts.target);
+ opts.modal && this.element.classList.add("-modal");
+ }
+
+ async open() {
+ if (!this.target) {
+ throw new Error("No target for RgthreeComfyPopup");
+ }
+ if (this.onOpenFn) {
+ await this.onOpenFn();
+ }
+ await wait(16);
+ const rect = this.target.getBoundingClientRect();
+ this.element.setAttribute("state", "measuring");
+ document.body.appendChild(this.element);
+ this.element.style.position = "fixed";
+ this.element.style.left = `${rect.left}px`;
+ this.element.style.top = `${rect.top + rect.height}px`;
+ this.element.setAttribute("state", "open");
+ if (this.opts.modal) {
+ document.body.classList.add("rgthree-modal-menu-open");
+ }
+ window.addEventListener("click", this.onWindowClickBound);
+ }
+
+ close() {
+ this.element.remove();
+ document.body.classList.remove("rgthree-modal-menu-open");
+ window.removeEventListener("click", this.onWindowClickBound);
+ }
+
+ onOpen(fn: (() => void) | null) {
+ this.onOpenFn = fn;
+ }
+
+ onWindowClick() {
+ this.close();
+ }
+}
diff --git a/custom_nodes/rgthree-comfy/src_web/comfyui/config.ts b/custom_nodes/rgthree-comfy/src_web/comfyui/config.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6593d0fe85bdc675217a62e55b8dd82f6988af04
--- /dev/null
+++ b/custom_nodes/rgthree-comfy/src_web/comfyui/config.ts
@@ -0,0 +1,416 @@
+import {app} from "scripts/app.js";
+import { RgthreeDialog, RgthreeDialogOptions } from "rgthree/common/dialog.js";
+import { createElement as $el, queryAll as $$ } from "rgthree/common/utils_dom.js";
+import { checkmark, logoRgthree } from "rgthree/common/media/svgs.js";
+import { LogLevel, rgthree } from "./rgthree.js";
+import { SERVICE as CONFIG_SERVICE } from "./services/config_service.js";
+
+/** Types of config used as a hint for the form handling. */
+enum ConfigType {
+ UNKNOWN,
+ BOOLEAN,
+ STRING,
+ NUMBER,
+ ARRAY,
+}
+
+enum ConfigInputType {
+ UNKNOWN,
+ CHECKLIST, // Which is a multiselect array.
+}
+
+const TYPE_TO_STRING = {
+ [ConfigType.UNKNOWN]: "unknown",
+ [ConfigType.BOOLEAN]: "boolean",
+ [ConfigType.STRING]: "string",
+ [ConfigType.NUMBER]: "number",
+ [ConfigType.ARRAY]: "array",
+};
+
+type ConfigurationSchema = {
+ key: string;
+ type: ConfigType;
+ label: string;
+ inputType?: ConfigInputType,
+ options?: string[] | number[] | ConfigurationSchemaOption[];
+ description?: string;
+ subconfig?: ConfigurationSchema[];
+ isDevOnly?: boolean;
+ onSave?: (value: any) => void;
+};
+
+type ConfigurationSchemaOption = { value: any; label: string };
+
+/**
+ * A static schema of sorts to layout options found in the config.
+ */
+const CONFIGURABLE: { [key: string]: ConfigurationSchema[] } = {
+ features: [
+ {
+ key: "features.progress_bar.enabled",
+ type: ConfigType.BOOLEAN,
+ label: "Prompt Progress Bar",
+ description: `Shows a minimal progress bar for nodes and steps at the top of the app.`,
+ subconfig: [
+ {
+ key: "features.progress_bar.height",
+ type: ConfigType.NUMBER,
+ label: "Height of the bar",
+ },
+ {
+ key: "features.progress_bar.position",
+ type: ConfigType.STRING,
+ label: "Position at top or bottom of window",
+ options: ["top", "bottom"],
+ },
+ ],
+ },
+ {
+ key: "features.import_individual_nodes.enabled",
+ type: ConfigType.BOOLEAN,
+ label: "Import Individual Nodes Widgets",
+ description:
+ "Dragging & Dropping a similar image/JSON workflow onto (most) current workflow nodes" +
+ "will allow you to import that workflow's node's widgets when it has the same " +
+ "id and type. This is useful when you have several images and you'd like to import just " +
+ "one part of a previous iteration, like a seed, or prompt.",
+ },
+ ],
+ menus: [
+ {
+ key: "features.comfy_top_bar_menu.enabled",
+ type: ConfigType.BOOLEAN,
+ label: "Enable Top Bar Menu",
+ description:
+ "Have quick access from ComfyUI's new top bar to rgthree-comfy bookmarks, settings " +
+ "(and more to come).",
+ },
+ {
+ key: "features.menu_queue_selected_nodes",
+ type: ConfigType.BOOLEAN,
+ label: "Show 'Queue Selected Output Nodes'",
+ description:
+ "Will show a menu item in the right-click context menus to queue (only) the selected " +
+ "output nodes.",
+ },
+ {
+ key: "features.menu_auto_nest.subdirs",
+ type: ConfigType.BOOLEAN,
+ label: "Auto Nest Subdirectories in Menus",
+ description:
+ "When a large, flat list of values contain sub-directories, auto nest them. (Like, for " +
+ "a large list of checkpoints).",
+ subconfig: [
+ {
+ key: "features.menu_auto_nest.threshold",
+ type: ConfigType.NUMBER,
+ label: "Number of items needed to trigger nesting.",
+ },
+ ],
+ },
+ {
+ key: "features.menu_bookmarks.enabled",
+ type: ConfigType.BOOLEAN,
+ label: "Show Bookmarks in context menu",
+ description: "Will list bookmarks in the rgthree-comfy right-click context menu.",
+ },
+ ],
+ groups: [
+ {
+ key: "features.group_header_fast_toggle.enabled",
+ type: ConfigType.BOOLEAN,
+ label: "Show fast toggles in Group Headers",
+ description: "Show quick toggles in Groups' Headers to quickly mute, bypass or queue.",
+ subconfig: [
+ {
+ key: "features.group_header_fast_toggle.toggles",
+ type: ConfigType.ARRAY,
+ label: "Which toggles to show.",
+ inputType: ConfigInputType.CHECKLIST,
+ options: [
+ { value: "queue", label: "queue" },
+ { value: "bypass", label: "bypass" },
+ { value: "mute", label: "mute" },
+ ],
+ },
+ {
+ key: "features.group_header_fast_toggle.show",
+ type: ConfigType.STRING,
+ label: "When to show them.",
+ options: [
+ { value: "hover", label: "on hover" },
+ { value: "always", label: "always" },
+ ],
+ },
+ ],
+ },
+ ],
+ power_lora_loader: [
+ {
+ key: "nodes.power_lora_loader.show_info_badge",
+ type: ConfigType.BOOLEAN,
+ label: "Show info badge/button",
+ description: "Show an info badge/button on each lora row to signal and open lora details.",
+ },
+ ],
+ advanced: [
+ {
+ key: "features.show_alerts_for_corrupt_workflows",
+ type: ConfigType.BOOLEAN,
+ label: "Detect Corrupt Workflows",
+ description:
+ "Will show a message at the top of the screen when loading a workflow that has " +
+ "corrupt linking data.",
+ },
+ {
+ key: "log_level",
+ type: ConfigType.STRING,
+ label: "Log level for browser dev console.",
+ description:
+ "Further down the list, the more verbose logs to the console will be. For instance, " +
+ "selecting 'IMPORTANT' means only important message will be logged to the browser " +
+ "console, while selecting 'WARN' will log all messages at or higher than WARN, including " +
+ "'ERROR' and 'IMPORTANT' etc.",
+ options: ["IMPORTANT", "ERROR", "WARN", "INFO", "DEBUG", "DEV"],
+ isDevOnly: true,
+ onSave: function (value: LogLevel) {
+ rgthree.setLogLevel(value);
+ },
+ },
+ {
+ key: "features.invoke_extensions_async.node_created",
+ type: ConfigType.BOOLEAN,
+ label: "Allow other extensions to call nodeCreated on rgthree-nodes.",
+ isDevOnly: true,
+ description:
+ "Do not disable unless you are having trouble (and then file an issue at rgthree-comfy)." +
+ "Prior to Apr 2024 it was not possible for other extensions to invoke their nodeCreated " +
+ "event on some rgthree-comfy nodes. Now it's possible and this option is only here in " +
+ "for easy if something is wrong.",
+ },
+ ],
+};
+
+/**
+ * Creates a new fieldrow for main or sub configuration items.
+ */
+function fieldrow(item: ConfigurationSchema) {
+ const initialValue = CONFIG_SERVICE.getConfigValue(item.key);
+ const container = $el(`div.fieldrow.-type-${TYPE_TO_STRING[item.type]}`, {
+ dataset: {
+ name: item.key,
+ initial: initialValue,
+ type: item.type,
+ },
+ });
+
+ $el(`label[for="${item.key}"]`, {
+ children: [
+ $el(`span[text="${item.label}"]`),
+ item.description ? $el("small", { html: item.description }) : null,
+ ],
+ parent: container,
+ });
+
+ let input;
+ if (item.options?.length) {
+ if (item.inputType === ConfigInputType.CHECKLIST) {
+ const initialValueList = initialValue || [];
+ input = $el(`fieldset.rgthree-checklist-group[id="${item.key}"]`, {
+ parent: container,
+ children: item.options.map((o) => {
+ const label = (o as ConfigurationSchemaOption).label || String(o);
+ const value = (o as ConfigurationSchemaOption).value || o;
+ const id = `${item.key}_${value}`;
+ return $el(`span.rgthree-checklist-item`, {
+ children: [
+ $el(`input[type="checkbox"][value="${value}"]`, {
+ id,
+ checked: initialValueList.includes(value),
+ }),
+ $el(`label`, {
+ for: id,
+ text: label,
+ })
+ ]
+ });
+ }),
+ });
+ } else {
+ input = $el(`select[id="${item.key}"]`, {
+ parent: container,
+ children: item.options.map((o) => {
+ const label = (o as ConfigurationSchemaOption).label || String(o);
+ const value = (o as ConfigurationSchemaOption).value || o;
+ const valueSerialized = JSON.stringify({ value: value });
+ return $el(`option[value="${valueSerialized}"]`, {
+ text: label,
+ selected: valueSerialized === JSON.stringify({ value: initialValue }),
+ });
+ }),
+ });
+ }
+ } else if (item.type === ConfigType.BOOLEAN) {
+ container.classList.toggle("-checked", !!initialValue);
+ input = $el(`input[type="checkbox"][id="${item.key}"]`, {
+ parent: container,
+ checked: initialValue,
+ });
+ } else {
+ input = $el(`input[id="${item.key}"]`, {
+ parent: container,
+ value: initialValue,
+ });
+ }
+ $el("div.fieldrow-value", { children: [input], parent: container });
+ return container;
+}
+
+/**
+ * A dialog to edit rgthree-comfy settings and config.
+ */
+export class RgthreeConfigDialog extends RgthreeDialog {
+ constructor() {
+ const content = $el("div");
+
+ content.appendChild(RgthreeConfigDialog.buildFieldset(CONFIGURABLE["features"]!, "Features"));
+ content.appendChild(RgthreeConfigDialog.buildFieldset(CONFIGURABLE["menus"]!, "Menus"));
+ content.appendChild(RgthreeConfigDialog.buildFieldset(CONFIGURABLE["groups"]!, "Groups"));
+ content.appendChild(RgthreeConfigDialog.buildFieldset(CONFIGURABLE["power_lora_loader"]!, "Power Lora Loader"));
+ content.appendChild(RgthreeConfigDialog.buildFieldset(CONFIGURABLE["advanced"]!, "Advanced"));
+
+ content.addEventListener("input", (e) => {
+ const changed = this.getChangedFormData();
+ ($$(".save-button", this.element)[0] as HTMLButtonElement).disabled =
+ !Object.keys(changed).length;
+ });
+ content.addEventListener("change", (e) => {
+ const changed = this.getChangedFormData();
+ ($$(".save-button", this.element)[0] as HTMLButtonElement).disabled =
+ !Object.keys(changed).length;
+ });
+
+ const dialogOptions: RgthreeDialogOptions = {
+ class: "-iconed -settings",
+ title: logoRgthree + `
` + } +