feat: update version to 0.8.12 and enhance release notes in README

Dev

LICENSE

@@ -1,21 +1,674 @@
-MIT License
+GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-Copyright (c) 2023 Will Miao
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-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:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-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. 
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    ComfyUI Lora Manager - A ComfyUI custom node for managing models
+    Copyright (C) 2025  Will Miao
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    ComfyUI Lora Manager  Copyright (C) 2025  Will Miao
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -14,12 +14,49 @@ A comprehensive toolset that streamlines organizing, downloading, and applying L
 Watch this quick tutorial to learn how to use the new one-click LoRA integration feature:
 
 [![One-Click LoRA Integration Tutorial](https://img.youtube.com/vi/qS95OjX3e70/0.jpg)](https://youtu.be/qS95OjX3e70)
-[![LoRA Manager v0.8.0 - New Recipe Feature & Bulk Operations](https://img.youtube.com/vi/noN7f_ER7yo/0.jpg)](https://youtu.be/noN7f_ER7yo)
+[![LoRA Manager v0.8.10 - Checkpoint Management, Standalone Mode, and New Features!](https://img.youtube.com/vi/VKvTlCB78h4/0.jpg)](https://youtu.be/VKvTlCB78h4)
 
 ---
 
 ## Release Notes
 
+### v0.8.12
+* **Enhanced Model Discovery** - Added alphabetical navigation bar to LoRAs page for faster browsing through large collections
+* **Optimized Example Images** - Improved download logic to automatically refresh stale metadata before fetching example images
+* **Model Exclusion System** - New right-click option to exclude specific LoRAs or checkpoints from management
+* **Improved Showcase Experience** - Enhanced interaction in LoRA and checkpoint showcase areas for better usability
+
+### v0.8.11
+* **Offline Image Support** - Added functionality to download and save all model example images locally, ensuring access even when offline or if images are removed from CivitAI or the site is down
+* **Resilient Download System** - Implemented pause/resume capability with checkpoint recovery that persists through restarts or unexpected exits
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
+### v0.8.10
+* **Standalone Mode** - Run LoRA Manager independently from ComfyUI for a lightweight experience that works even with other stable diffusion interfaces
+* **Portable Edition** - New one-click portable version for easy startup and updates in standalone mode
+* **Enhanced Metadata Collection** - Added support for SamplerCustomAdvanced node in the metadata collector module
+* **Improved UI Organization** - Optimized Lora Loader node height to display up to 5 LoRAs at once with scrolling capability for larger collections
+
+### v0.8.9
+* **Favorites System** - New functionality to bookmark your favorite LoRAs and checkpoints for quick access and better organization
+* **Enhanced UI Controls** - Increased model card button sizes for improved usability and easier interaction
+* **Smoother Page Transitions** - Optimized interface switching between pages, eliminating flash issues particularly noticeable in dark theme
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
+### v0.8.8
+* **Real-time TriggerWord Updates** - Enhanced TriggerWord Toggle node to instantly update when connected Lora Loader or Lora Stacker nodes change, without requiring workflow execution
+* **Optimized Metadata Recovery** - Improved utilization of existing .civitai.info files for faster initialization and preservation of metadata from models deleted from CivitAI
+* **Migration Acceleration** - Further speed improvements for users transitioning from A1111/Forge environments
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
+### v0.8.7
+* **Enhanced Context Menu** - Added comprehensive context menu functionality to Recipes and Checkpoints pages for improved workflow
+* **Interactive LoRA Strength Control** - Implemented drag functionality in LoRA Loader for intuitive strength adjustment
+* **Metadata Collector Overhaul** - Rebuilt metadata collection system with optimized architecture for better performance
+* **Improved Save Image Node** - Enhanced metadata capture and image saving performance with the new metadata collector
+* **Streamlined Recipe Saving** - Optimized Save Recipe functionality to work independently without requiring Preview Image nodes
+* **Bug Fixes & Stability** - Resolved various issues to enhance overall reliability and performance
+
 ### v0.8.6 Major Update
 * **Checkpoint Management** - Added comprehensive management for model checkpoints including scanning, searching, filtering, and deletion
 * **Enhanced Metadata Support** - New capabilities for retrieving and managing checkpoint metadata with improved operations
@@ -120,19 +157,26 @@ Watch this quick tutorial to learn how to use the new one-click LoRA integration
 
 ## Installation
 
-### Option 1: **ComfyUI Manager** (Recommended)
+### Option 1: **ComfyUI Manager** (Recommended for ComfyUI users)
 
 1. Open **ComfyUI**.
 2. Go to **Manager > Custom Node Manager**.
 3. Search for `lora-manager`.
 4. Click **Install**.
 
-### Option 2: **Manual Installation**
+### Option 2: **Portable Standalone Edition** (No ComfyUI required)
+
+1. Download the [Portable Package](https://github.com/willmiao/ComfyUI-Lora-Manager/releases/download/v0.8.10/lora_manager_portable.7z)
+2. Copy the provided `settings.json.example` file to create a new file named `settings.json` in `comfyui-lora-manager` folder
+3. Edit `settings.json` to include your correct model folder paths and CivitAI API key
+4. Run run.bat
+
+### Option 3: **Manual Installation**
 
 ```bash
 git clone https://github.com/willmiao/ComfyUI-Lora-Manager.git
 cd ComfyUI-Lora-Manager
-pip install requirements.txt
+pip install -r requirements.txt
 ```
 
 ## Usage
@@ -153,29 +197,100 @@ pip install requirements.txt
    - Paste into the Lora Loader node's text input
    - The node will automatically apply preset strength and trigger words
 
+### Filename Format Patterns for Save Image Node
+
+The Save Image Node supports dynamic filename generation using pattern codes. You can customize how your images are named using the following format patterns:
+
+#### Available Pattern Codes
+
+- `%seed%` - Inserts the generation seed number
+- `%width%` - Inserts the image width
+- `%height%` - Inserts the image height
+- `%pprompt:N%` - Inserts the positive prompt (limited to N characters)
+- `%nprompt:N%` - Inserts the negative prompt (limited to N characters)
+- `%model:N%` - Inserts the model/checkpoint name (limited to N characters)
+- `%date%` - Inserts current date/time as "yyyyMMddhhmmss"
+- `%date:FORMAT%` - Inserts date using custom format with:
+  - `yyyy` - 4-digit year
+  - `yy` - 2-digit year
+  - `MM` - 2-digit month
+  - `dd` - 2-digit day
+  - `hh` - 2-digit hour
+  - `mm` - 2-digit minute
+  - `ss` - 2-digit second
+
+#### Examples
+
+- `image_%seed%` → `image_1234567890`
+- `gen_%width%x%height%` → `gen_512x768`
+- `%model:10%_%seed%` → `dreamshape_1234567890`
+- `%date:yyyy-MM-dd%` → `2025-04-28`
+- `%pprompt:20%_%seed%` → `beautiful landscape_1234567890`
+- `%model%_%date:yyMMdd%_%seed%` → `dreamshaper_v8_250428_1234567890`
+
+You can combine multiple patterns to create detailed, organized filenames for your generated images.
+
+### Standalone Mode
+
+You can now run LoRA Manager independently from ComfyUI:
+
+1. **For ComfyUI users**:
+   - Launch ComfyUI with LoRA Manager at least once to initialize the necessary path information in the `settings.json` file.
+   - Make sure dependencies are installed: `pip install -r requirements.txt`
+   - From your ComfyUI root directory, run:
+     ```bash
+     python custom_nodes\comfyui-lora-manager\standalone.py
+     ```
+   - Access the interface at: `http://localhost:8188/loras`
+   - You can specify a different host or port with arguments:
+     ```bash
+     python custom_nodes\comfyui-lora-manager\standalone.py --host 127.0.0.1 --port 9000
+     ```
+
+2. **For non-ComfyUI users**:
+   - Copy the provided `settings.json.example` file to create a new file named `settings.json`
+   - Edit `settings.json` to include your correct model folder paths and CivitAI API key
+   - Install required dependencies: `pip install -r requirements.txt`
+   - Run standalone mode:
+     ```bash
+     python standalone.py
+     ```
+   - Access the interface through your browser at: `http://localhost:8188/loras`
+
+This standalone mode provides a lightweight option for managing your model and recipe collection without needing to run the full ComfyUI environment, making it useful even for users who primarily use other stable diffusion interfaces.
+
+---
+
+## Contributing
+
+Thank you for your interest in contributing to ComfyUI LoRA Manager! As this project is currently in its early stages and undergoing rapid development and refactoring, we are temporarily not accepting pull requests.
+
+However, your feedback and ideas are extremely valuable to us:
+- Please feel free to open issues for any bugs you encounter
+- Submit feature requests through GitHub issues
+- Share your suggestions for improvements
+
+We appreciate your understanding and look forward to potentially accepting code contributions once the project architecture stabilizes.
+
 ---
 
 ## Credits
 
 This project has been inspired by and benefited from other excellent ComfyUI extensions:
 
-- [ComfyUI-SaveImageWithMetaData](https://github.com/Comfy-Community/ComfyUI-SaveImageWithMetaData) - For the image metadata functionality
+- [ComfyUI-SaveImageWithMetaData](https://github.com/nkchocoai/ComfyUI-SaveImageWithMetaData) - For the image metadata functionality
 - [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) - For the lora loader functionality
 
 ---
 
-## Contributing
-
-If you have suggestions, bug reports, or improvements, feel free to open an issue or contribute directly to the codebase. Pull requests are always welcome!
-
----
-
 ## ☕ Support
 
 If you find this project helpful, consider supporting its development:
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/pixelpawsai)
 
+WeChat: [Click to view QR code](https://raw.githubusercontent.com/willmiao/ComfyUI-Lora-Manager/main/static/images/wechat-qr.webp)
+
 ## 💬 Community
 
 Join our Discord community for support, discussions, and updates:

__init__.py

@@ -3,16 +3,23 @@ from .py.nodes.lora_loader import LoraManagerLoader
 from .py.nodes.trigger_word_toggle import TriggerWordToggle
 from .py.nodes.lora_stacker import LoraStacker
 from .py.nodes.save_image import SaveImage
+from .py.nodes.debug_metadata import DebugMetadata
+# Import metadata collector to install hooks on startup
+from .py.metadata_collector import init as init_metadata_collector
 
 NODE_CLASS_MAPPINGS = {
     LoraManagerLoader.NAME: LoraManagerLoader,
     TriggerWordToggle.NAME: TriggerWordToggle,
     LoraStacker.NAME: LoraStacker,
-    SaveImage.NAME: SaveImage
+    SaveImage.NAME: SaveImage,
+    DebugMetadata.NAME: DebugMetadata
 }
 
 WEB_DIRECTORY = "./web/comfyui"
 
+# Initialize metadata collector
+init_metadata_collector()
+
 # Register routes on import
 LoraManager.add_routes()
 __all__ = ['NODE_CLASS_MAPPINGS', 'WEB_DIRECTORY']

py/config.py

@@ -3,6 +3,11 @@ import platform
 import folder_paths # type: ignore
 from typing import List
 import logging
+import sys
+import json
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
 
 logger = logging.getLogger(__name__)
 
@@ -18,9 +23,46 @@ class Config:
         self._route_mappings = {}
         self.loras_roots = self._init_lora_paths()
         self.checkpoints_roots = self._init_checkpoint_paths()
-        self.temp_directory = folder_paths.get_temp_directory()
         # 在初始化时扫描符号链接
         self._scan_symbolic_links()
+        
+        if not standalone_mode:
+            # Save the paths to settings.json when running in ComfyUI mode
+            self.save_folder_paths_to_settings()
+
+    def save_folder_paths_to_settings(self):
+        """Save folder paths to settings.json for standalone mode to use later"""
+        try:
+            # Check if we're running in ComfyUI mode (not standalone)
+            if hasattr(folder_paths, "get_folder_paths") and not isinstance(folder_paths, type):
+                # Get all relevant paths
+                lora_paths = folder_paths.get_folder_paths("loras")
+                checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
+                diffuser_paths = folder_paths.get_folder_paths("diffusers")
+                unet_paths = folder_paths.get_folder_paths("unet")
+                
+                # Load existing settings
+                settings_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'settings.json')
+                settings = {}
+                if os.path.exists(settings_path):
+                    with open(settings_path, 'r', encoding='utf-8') as f:
+                        settings = json.load(f)
+                
+                # Update settings with paths
+                settings['folder_paths'] = {
+                    'loras': lora_paths,
+                    'checkpoints': checkpoint_paths,
+                    'diffusers': diffuser_paths,
+                    'unet': unet_paths
+                }
+                
+                # Save settings
+                with open(settings_path, 'w', encoding='utf-8') as f:
+                    json.dump(settings, f, indent=2)
+                
+                logger.info("Saved folder paths to settings.json")
+        except Exception as e:
+            logger.warning(f"Failed to save folder paths: {e}")
 
     def _is_link(self, path: str) -> bool:
         try:
@@ -103,50 +145,66 @@ class Config:
 
     def _init_lora_paths(self) -> List[str]:
         """Initialize and validate LoRA paths from ComfyUI settings"""
-        paths = sorted(set(path.replace(os.sep, "/") 
-                for path in folder_paths.get_folder_paths("loras") 
-                if os.path.exists(path)), key=lambda p: p.lower())
-        print("Found LoRA roots:", "\n - " + "\n - ".join(paths))
-        
-        if not paths:
-            raise ValueError("No valid loras folders found in ComfyUI configuration")
-        
-        # 初始化路径映射
-        for path in paths:
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            if real_path != path:
-                self.add_path_mapping(path, real_path)
-        
-        return paths
+        try:
+            raw_paths = folder_paths.get_folder_paths("loras")
+            
+            # Normalize and resolve symlinks, store mapping from resolved -> original
+            path_map = {}
+            for path in raw_paths:
+                if os.path.exists(path):
+                    real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
+                    path_map[real_path] = path_map.get(real_path, path.replace(os.sep, "/"))  # preserve first seen
+            
+            # Now sort and use only the deduplicated real paths
+            unique_paths = sorted(path_map.values(), key=lambda p: p.lower())
+            logger.info("Found LoRA roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            
+            if not unique_paths:
+                logger.warning("No valid loras folders found in ComfyUI configuration")
+                return []
+            
+            for original_path in unique_paths:
+                real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+                if real_path != original_path:
+                    self.add_path_mapping(original_path, real_path)
+            
+            return unique_paths
+        except Exception as e:
+            logger.warning(f"Error initializing LoRA paths: {e}")
+            return []
 
     def _init_checkpoint_paths(self) -> List[str]:
         """Initialize and validate checkpoint paths from ComfyUI settings"""
-        # Get checkpoint paths from folder_paths
-        checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
-        diffusion_paths = folder_paths.get_folder_paths("diffusers")
-        unet_paths = folder_paths.get_folder_paths("unet")
-        
-        # Combine all checkpoint-related paths
-        all_paths = checkpoint_paths + diffusion_paths + unet_paths
-        
-        # Filter and normalize paths
-        paths = sorted(set(path.replace(os.sep, "/") 
-                for path in all_paths 
-                if os.path.exists(path)), key=lambda p: p.lower())
-        
-        print("Found checkpoint roots:", paths)
-        
-        if not paths:
-            logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+        try:
+            # Get checkpoint paths from folder_paths
+            checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
+            diffusion_paths = folder_paths.get_folder_paths("diffusers")
+            unet_paths = folder_paths.get_folder_paths("unet")
+            
+            # Combine all checkpoint-related paths
+            all_paths = checkpoint_paths + diffusion_paths + unet_paths
+            
+            # Filter and normalize paths
+            paths = sorted(set(path.replace(os.sep, "/") 
+                    for path in all_paths 
+                    if os.path.exists(path)), key=lambda p: p.lower())
+            
+            logger.info("Found checkpoint roots:" + ("\n - " + "\n - ".join(paths) if paths else "[]"))
+            
+            if not paths:
+                logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+                return []
+            
+            # 初始化路径映射，与 LoRA 路径处理方式相同
+            for path in paths:
+                real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
+                if real_path != path:
+                    self.add_path_mapping(path, real_path)
+            
+            return paths
+        except Exception as e:
+            logger.warning(f"Error initializing checkpoint paths: {e}")
             return []
-        
-        # 初始化路径映射，与 LoRA 路径处理方式相同
-        for path in paths:
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            if real_path != path:
-                self.add_path_mapping(path, real_path)
-        
-        return paths
 
     def get_preview_static_url(self, preview_path: str) -> str:
         """Convert local preview path to static URL"""

py/lora_manager.py

@@ -5,11 +5,19 @@ from .routes.lora_routes import LoraRoutes
 from .routes.api_routes import ApiRoutes
 from .routes.recipe_routes import RecipeRoutes
 from .routes.checkpoints_routes import CheckpointsRoutes
+from .routes.update_routes import UpdateRoutes
+from .routes.misc_routes import MiscRoutes
 from .services.service_registry import ServiceRegistry
+from .services.settings_manager import settings
 import logging
+import sys
+import os
 
 logger = logging.getLogger(__name__)
 
+# Check if we're in standalone mode
+STANDALONE_MODE = 'nodes' not in sys.modules
+
 class LoraManager:
     """Main entry point for LoRA Manager plugin"""
     
@@ -18,8 +26,18 @@ class LoraManager:
         """Initialize and register all routes"""
         app = PromptServer.instance.app
 
+        # Configure aiohttp access logger to be less verbose
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+
         added_targets = set()  # Track already added target paths
         
+        # Add static route for example images if the path exists in settings
+        example_images_path = settings.get('example_images_path')
+        logger.info(f"Example images path: {example_images_path}")
+        if example_images_path and os.path.exists(example_images_path):
+            app.router.add_static('/example_images_static', example_images_path)
+            logger.info(f"Added static route for example images: /example_images_static -> {example_images_path}")
+        
         # Add static routes for each lora root
         for idx, root in enumerate(config.loras_roots, start=1):
             preview_path = f'/loras_static/root{idx}/preview'
@@ -92,6 +110,8 @@ class LoraManager:
         checkpoints_routes.setup_routes(app)
         ApiRoutes.setup_routes(app)
         RecipeRoutes.setup_routes(app)
+        UpdateRoutes.setup_routes(app)  
+        MiscRoutes.setup_routes(app)  # Register miscellaneous routes
         
         # Schedule service initialization 
         app.on_startup.append(lambda app: cls._initialize_services())
@@ -104,7 +124,8 @@ class LoraManager:
     async def _initialize_services(cls):
         """Initialize all services using the ServiceRegistry"""
         try:
-            logger.info("LoRA Manager: Initializing services via ServiceRegistry")
+            # Ensure aiohttp access logger is configured with reduced verbosity
+            logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
             
             # Initialize CivitaiClient first to ensure it's ready for other services
             civitai_client = await ServiceRegistry.get_civitai_client()
@@ -115,12 +136,12 @@ class LoraManager:
             
             # Start monitors
             lora_monitor.start()
-            logger.info("Lora monitor started")
+            logger.debug("Lora monitor started")
             
             # Make sure checkpoint monitor has paths before starting
             await checkpoint_monitor.initialize_paths()
             checkpoint_monitor.start()
-            logger.info("Checkpoint monitor started")
+            logger.debug("Checkpoint monitor started")
 
             # Register DownloadManager with ServiceRegistry
             download_manager = await ServiceRegistry.get_download_manager()
@@ -135,6 +156,12 @@ class LoraManager:
             # Initialize recipe scanner if needed
             recipe_scanner = await ServiceRegistry.get_recipe_scanner()
             
+            # Initialize metadata collector if not in standalone mode
+            if not STANDALONE_MODE:
+                from .metadata_collector import init as init_metadata
+                init_metadata()
+                logger.debug("Metadata collector initialized")
+            
             # Create low-priority initialization tasks
             asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init')
             asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init')

py/metadata_collector/__init__.py

@@ -0,0 +1,32 @@
+import os
+import importlib
+import sys
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
+if not standalone_mode:
+    from .metadata_hook import MetadataHook
+    from .metadata_registry import MetadataRegistry
+
+    def init():
+        # Install hooks to collect metadata during execution
+        MetadataHook.install()
+        
+        # Initialize registry
+        registry = MetadataRegistry()
+        
+        print("ComfyUI Metadata Collector initialized")
+        
+    def get_metadata(prompt_id=None):
+        """Helper function to get metadata from the registry"""
+        registry = MetadataRegistry()
+        return registry.get_metadata(prompt_id)
+else:
+    # Standalone mode - provide dummy implementations
+    def init():
+        print("ComfyUI Metadata Collector disabled in standalone mode")
+        
+    def get_metadata(prompt_id=None):
+        """Dummy implementation for standalone mode"""
+        return {}

py/metadata_collector/constants.py

@@ -0,0 +1,14 @@
+"""Constants used by the metadata collector"""
+
+# Metadata collection constants
+
+# Metadata categories
+MODELS = "models"
+PROMPTS = "prompts"
+SAMPLING = "sampling"
+LORAS = "loras"
+SIZE = "size"
+IMAGES = "images"
+
+# Complete list of categories to track
+METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]

py/metadata_collector/metadata_hook.py

@@ -0,0 +1,123 @@
+import sys
+import inspect
+from .metadata_registry import MetadataRegistry
+
+class MetadataHook:
+    """Install hooks for metadata collection"""
+    
+    @staticmethod
+    def install():
+        """Install hooks to collect metadata during execution"""
+        try:
+            # Import ComfyUI's execution module
+            execution = None
+            try:
+                # Try direct import first
+                import execution # type: ignore
+            except ImportError:
+                # Try to locate from system modules
+                for module_name in sys.modules:
+                    if module_name.endswith('.execution'):
+                        execution = sys.modules[module_name]
+                        break
+                    
+            # If we can't find the execution module, we can't install hooks
+            if execution is None:
+                print("Could not locate ComfyUI execution module, metadata collection disabled")
+                return
+            
+            # Store the original _map_node_over_list function
+            original_map_node_over_list = execution._map_node_over_list
+            
+            # Define the wrapped _map_node_over_list function
+            def map_node_over_list_with_metadata(obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None):
+                # Only collect metadata when calling the main function of nodes
+                if func == obj.FUNCTION and hasattr(obj, '__class__'):
+                    try:
+                        # Get the current prompt_id from the registry
+                        registry = MetadataRegistry()
+                        prompt_id = registry.current_prompt_id
+                        
+                        if prompt_id is not None:
+                            # Get node class type
+                            class_type = obj.__class__.__name__
+                            
+                            # Unique ID might be available through the obj if it has a unique_id field
+                            node_id = getattr(obj, 'unique_id', None)
+                            if node_id is None and pre_execute_cb:
+                                # Try to extract node_id through reflection on GraphBuilder.set_default_prefix
+                                frame = inspect.currentframe()
+                                while frame:
+                                    if 'unique_id' in frame.f_locals:
+                                        node_id = frame.f_locals['unique_id']
+                                        break
+                                    frame = frame.f_back
+                            
+                            # Record inputs before execution
+                            if node_id is not None:
+                                registry.record_node_execution(node_id, class_type, input_data_all, None)
+                    except Exception as e:
+                        print(f"Error collecting metadata (pre-execution): {str(e)}")
+                
+                # Execute the original function
+                results = original_map_node_over_list(obj, input_data_all, func, allow_interrupt, execution_block_cb, pre_execute_cb)
+                
+                # After execution, collect outputs for relevant nodes
+                if func == obj.FUNCTION and hasattr(obj, '__class__'):
+                    try:
+                        # Get the current prompt_id from the registry
+                        registry = MetadataRegistry()
+                        prompt_id = registry.current_prompt_id
+                        
+                        if prompt_id is not None:
+                            # Get node class type
+                            class_type = obj.__class__.__name__
+                            
+                            # Unique ID might be available through the obj if it has a unique_id field
+                            node_id = getattr(obj, 'unique_id', None)
+                            if node_id is None and pre_execute_cb:
+                                # Try to extract node_id through reflection
+                                frame = inspect.currentframe()
+                                while frame:
+                                    if 'unique_id' in frame.f_locals:
+                                        node_id = frame.f_locals['unique_id']
+                                        break
+                                    frame = frame.f_back
+                            
+                            # Record outputs after execution
+                            if node_id is not None:
+                                registry.update_node_execution(node_id, class_type, results)
+                    except Exception as e:
+                        print(f"Error collecting metadata (post-execution): {str(e)}")
+                
+                return results
+                
+            # Also hook the execute function to track the current prompt_id
+            original_execute = execution.execute
+            
+            def execute_with_prompt_tracking(*args, **kwargs):
+                if len(args) >= 7:  # Check if we have enough arguments
+                    server, prompt, caches, node_id, extra_data, executed, prompt_id = args[:7]
+                    registry = MetadataRegistry()
+                    
+                    # Start collection if this is a new prompt
+                    if not registry.current_prompt_id or registry.current_prompt_id != prompt_id:
+                        registry.start_collection(prompt_id)
+                        
+                    # Store the dynprompt reference for node lookups
+                    if hasattr(prompt, 'original_prompt'):
+                        registry.set_current_prompt(prompt)
+                
+                # Execute the original function
+                return original_execute(*args, **kwargs)
+                
+            # Replace the functions
+            execution._map_node_over_list = map_node_over_list_with_metadata
+            execution.execute = execute_with_prompt_tracking
+            # Make map_node_over_list public to avoid it being hidden by hooks
+            execution.map_node_over_list = original_map_node_over_list
+            
+            print("Metadata collection hooks installed for runtime values")
+            
+        except Exception as e:
+            print(f"Error installing metadata hooks: {str(e)}")

py/metadata_collector/metadata_processor.py

@@ -0,0 +1,278 @@
+import json
+import sys
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
+from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE
+
+class MetadataProcessor:
+    """Process and format collected metadata"""
+    
+    @staticmethod
+    def find_primary_sampler(metadata):
+        """Find the primary KSampler node (with highest denoise value)"""
+        primary_sampler = None
+        primary_sampler_id = None
+        max_denoise = -1  # Track the highest denoise value
+        
+        # First, check for SamplerCustomAdvanced
+        prompt = metadata.get("current_prompt")
+        if prompt and prompt.original_prompt:
+            for node_id, node_info in prompt.original_prompt.items():
+                if node_info.get("class_type") == "SamplerCustomAdvanced":
+                    # Found a SamplerCustomAdvanced node
+                    if node_id in metadata.get(SAMPLING, {}):
+                        return node_id, metadata[SAMPLING][node_id]
+        
+        # Next, check for KSamplerAdvanced with add_noise="enable"
+        for node_id, sampler_info in metadata.get(SAMPLING, {}).items():
+            parameters = sampler_info.get("parameters", {})
+            add_noise = parameters.get("add_noise")
+            
+            # If add_noise is "enable", this is likely the primary sampler for KSamplerAdvanced
+            if add_noise == "enable":
+                primary_sampler = sampler_info
+                primary_sampler_id = node_id
+                break
+        
+        # If no specialized sampler found, find the sampler with highest denoise value
+        if primary_sampler is None:
+            for node_id, sampler_info in metadata.get(SAMPLING, {}).items():
+                parameters = sampler_info.get("parameters", {})
+                denoise = parameters.get("denoise")
+                
+                # If denoise exists and is higher than current max, use this sampler
+                if denoise is not None and denoise > max_denoise:
+                    max_denoise = denoise
+                    primary_sampler = sampler_info
+                    primary_sampler_id = node_id
+                
+        return primary_sampler_id, primary_sampler
+    
+    @staticmethod
+    def trace_node_input(prompt, node_id, input_name, target_class=None, max_depth=10):
+        """
+        Trace an input connection from a node to find the source node
+        
+        Parameters:
+        - prompt: The prompt object containing node connections
+        - node_id: ID of the starting node
+        - input_name: Name of the input to trace
+        - target_class: Optional class name to search for (e.g., "CLIPTextEncode")
+        - max_depth: Maximum depth to follow the node chain to prevent infinite loops
+        
+        Returns:
+        - node_id of the found node, or None if not found
+        """
+        if not prompt or not prompt.original_prompt or node_id not in prompt.original_prompt:
+            return None
+            
+        # For depth tracking
+        current_depth = 0
+        
+        current_node_id = node_id
+        current_input = input_name
+        
+        while current_depth < max_depth:
+            if current_node_id not in prompt.original_prompt:
+                return None
+                
+            node_inputs = prompt.original_prompt[current_node_id].get("inputs", {})
+            if current_input not in node_inputs:
+                return None
+                
+            input_value = node_inputs[current_input]
+            # Input connections are formatted as [node_id, output_index]
+            if isinstance(input_value, list) and len(input_value) >= 2:
+                found_node_id = input_value[0]  # Connected node_id
+                
+                # If we're looking for a specific node class
+                if target_class and prompt.original_prompt[found_node_id].get("class_type") == target_class:
+                    return found_node_id
+                
+                # If we're not looking for a specific class or haven't found it yet
+                if not target_class:
+                    return found_node_id
+                
+                # Continue tracing through intermediate nodes
+                current_node_id = found_node_id
+                # For most conditioning nodes, the input we want to follow is named "conditioning"
+                if "conditioning" in prompt.original_prompt[current_node_id].get("inputs", {}):
+                    current_input = "conditioning"
+                else:
+                    # If there's no "conditioning" input, we can't trace further
+                    return found_node_id if not target_class else None
+            else:
+                # We've reached a node with no further connections
+                return None
+            
+            current_depth += 1
+            
+        # If we've reached max depth without finding target_class
+        return None
+    
+    @staticmethod
+    def find_primary_checkpoint(metadata):
+        """Find the primary checkpoint model in the workflow"""
+        if not metadata.get(MODELS):
+            return None
+            
+        # In most workflows, there's only one checkpoint, so we can just take the first one
+        for node_id, model_info in metadata.get(MODELS, {}).items():
+            if model_info.get("type") == "checkpoint":
+                return model_info.get("name")
+                
+        return None
+    
+    @staticmethod
+    def extract_generation_params(metadata):
+        """Extract generation parameters from metadata using node relationships"""
+        params = {
+            "prompt": "",
+            "negative_prompt": "",
+            "seed": None,
+            "steps": None,
+            "cfg_scale": None,
+            "guidance": None,  # Add guidance parameter
+            "sampler": None,
+            "scheduler": None,
+            "checkpoint": None,
+            "loras": "",
+            "size": None,
+            "clip_skip": None
+        }
+        
+        # Get the prompt object for node relationship tracing
+        prompt = metadata.get("current_prompt")
+        
+        # Find the primary KSampler node
+        primary_sampler_id, primary_sampler = MetadataProcessor.find_primary_sampler(metadata)
+        
+        # Directly get checkpoint from metadata instead of tracing
+        checkpoint = MetadataProcessor.find_primary_checkpoint(metadata)
+        if checkpoint:
+            params["checkpoint"] = checkpoint
+        
+        if primary_sampler:
+            # Extract sampling parameters
+            sampling_params = primary_sampler.get("parameters", {})
+            # Handle both seed and noise_seed
+            params["seed"] = sampling_params.get("seed") if sampling_params.get("seed") is not None else sampling_params.get("noise_seed")
+            params["steps"] = sampling_params.get("steps")
+            params["cfg_scale"] = sampling_params.get("cfg")
+            params["sampler"] = sampling_params.get("sampler_name")
+            params["scheduler"] = sampling_params.get("scheduler")
+            
+            # Trace connections from the primary sampler
+            if prompt and primary_sampler_id:
+                # Check if this is a SamplerCustomAdvanced node
+                is_custom_advanced = False
+                if prompt.original_prompt and primary_sampler_id in prompt.original_prompt:
+                    is_custom_advanced = prompt.original_prompt[primary_sampler_id].get("class_type") == "SamplerCustomAdvanced"
+                
+                if is_custom_advanced:
+                    # For SamplerCustomAdvanced, trace specific inputs
+                    
+                    # 1. Trace sigmas input to find BasicScheduler
+                    scheduler_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "sigmas", "BasicScheduler", max_depth=5)
+                    if scheduler_node_id and scheduler_node_id in metadata.get(SAMPLING, {}):
+                        scheduler_params = metadata[SAMPLING][scheduler_node_id].get("parameters", {})
+                        params["steps"] = scheduler_params.get("steps")
+                        params["scheduler"] = scheduler_params.get("scheduler")
+                    
+                    # 2. Trace sampler input to find KSamplerSelect
+                    sampler_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "sampler", "KSamplerSelect", max_depth=5)
+                    if sampler_node_id and sampler_node_id in metadata.get(SAMPLING, {}):
+                        sampler_params = metadata[SAMPLING][sampler_node_id].get("parameters", {})
+                        params["sampler"] = sampler_params.get("sampler_name")
+                    
+                    # 3. Trace guider input for FluxGuidance and CLIPTextEncode
+                    guider_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "guider", max_depth=5)
+                    if guider_node_id:
+                        # Look for FluxGuidance along the guider path
+                        flux_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "FluxGuidance", max_depth=5)
+                        if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
+                            flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
+                            params["guidance"] = flux_params.get("guidance")
+                        
+                        # Find CLIPTextEncode for positive prompt (through conditioning)
+                        positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "CLIPTextEncode", max_depth=10)
+                        if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                            params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                
+                else:
+                    # Original tracing for standard samplers
+                    # Trace positive prompt - look specifically for CLIPTextEncode
+                    positive_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "CLIPTextEncode", max_depth=10)
+                    if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                        params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                    else:
+                        # If CLIPTextEncode is not found, try to find CLIPTextEncodeFlux
+                        positive_flux_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "CLIPTextEncodeFlux", max_depth=10)
+                        if positive_flux_node_id and positive_flux_node_id in metadata.get(PROMPTS, {}):
+                            params["prompt"] = metadata[PROMPTS][positive_flux_node_id].get("text", "")
+                            
+                            # Also extract guidance value if present in the sampling data
+                            if positive_flux_node_id in metadata.get(SAMPLING, {}):
+                                flux_params = metadata[SAMPLING][positive_flux_node_id].get("parameters", {})
+                                if "guidance" in flux_params:
+                                    params["guidance"] = flux_params.get("guidance")
+                    
+                    # Find any FluxGuidance nodes in the positive conditioning path
+                    flux_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "positive", "FluxGuidance", max_depth=5)
+                    if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
+                        flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
+                        params["guidance"] = flux_params.get("guidance")
+                    
+                    # Trace negative prompt - look specifically for CLIPTextEncode
+                    negative_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "negative", "CLIPTextEncode", max_depth=10)
+                    if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
+                        params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
+                
+                # Size extraction is same for all sampler types
+                # Check if the sampler itself has size information (from latent_image)
+                if primary_sampler_id in metadata.get(SIZE, {}):
+                    width = metadata[SIZE][primary_sampler_id].get("width")
+                    height = metadata[SIZE][primary_sampler_id].get("height")
+                    if width and height:
+                        params["size"] = f"{width}x{height}"
+        
+        # Extract LoRAs using the standardized format
+        lora_parts = []
+        for node_id, lora_info in metadata.get(LORAS, {}).items():
+            # Access the lora_list from the standardized format
+            lora_list = lora_info.get("lora_list", [])
+            for lora in lora_list:
+                name = lora.get("name", "unknown")
+                strength = lora.get("strength", 1.0)
+                lora_parts.append(f"<lora:{name}:{strength}>")
+        
+        params["loras"] = " ".join(lora_parts)
+        
+        # Set default clip_skip value
+        params["clip_skip"] = "1"  # Common default
+        
+        return params
+    
+    @staticmethod
+    def to_dict(metadata):
+        """Convert extracted metadata to the ComfyUI output.json format"""           
+        if standalone_mode:
+            # Return empty dictionary in standalone mode
+            return {}
+        
+        params = MetadataProcessor.extract_generation_params(metadata)
+        
+        # Convert all values to strings to match output.json format
+        for key in params:
+            if params[key] is not None:
+                params[key] = str(params[key])
+        
+        return params
+    
+    @staticmethod
+    def to_json(metadata):
+        """Convert metadata to JSON string"""
+        params = MetadataProcessor.to_dict(metadata)
+        return json.dumps(params, indent=4)

py/metadata_collector/metadata_registry.py

@@ -0,0 +1,275 @@
+import time
+from nodes import NODE_CLASS_MAPPINGS
+from .node_extractors import NODE_EXTRACTORS, GenericNodeExtractor
+from .constants import METADATA_CATEGORIES, IMAGES
+
+class MetadataRegistry:
+    """A singleton registry to store and retrieve workflow metadata"""
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._reset()
+        return cls._instance
+    
+    def _reset(self):
+        self.current_prompt_id = None
+        self.current_prompt = None
+        self.metadata = {}
+        self.prompt_metadata = {}
+        self.executed_nodes = set()
+        
+        # Node-level cache for metadata
+        self.node_cache = {}
+        
+        # Limit the number of stored prompts
+        self.max_prompt_history = 3
+        
+        # Categories we want to track and retrieve from cache
+        self.metadata_categories = METADATA_CATEGORIES
+    
+    def _clean_old_prompts(self):
+        """Clean up old prompt metadata, keeping only recent ones"""
+        if len(self.prompt_metadata) <= self.max_prompt_history:
+            return
+            
+        # Sort all prompt_ids by timestamp
+        sorted_prompts = sorted(
+            self.prompt_metadata.keys(),
+            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0)
+        )
+        
+        # Remove oldest records
+        prompts_to_remove = sorted_prompts[:len(sorted_prompts) - self.max_prompt_history]
+        for pid in prompts_to_remove:
+            del self.prompt_metadata[pid]
+    
+    def start_collection(self, prompt_id):
+        """Begin metadata collection for a new prompt"""
+        self.current_prompt_id = prompt_id
+        self.executed_nodes = set()
+        self.prompt_metadata[prompt_id] = {
+            category: {} for category in METADATA_CATEGORIES
+        }
+        # Add additional metadata fields
+        self.prompt_metadata[prompt_id].update({
+            "execution_order": [],
+            "current_prompt": None,  # Will store the prompt object
+            "timestamp": time.time()
+        })
+        
+        # Clean up old prompt data
+        self._clean_old_prompts()
+    
+    def set_current_prompt(self, prompt):
+        """Set the current prompt object reference"""
+        self.current_prompt = prompt
+        if self.current_prompt_id and self.current_prompt_id in self.prompt_metadata:
+            # Store the prompt in the metadata for later relationship tracing
+            self.prompt_metadata[self.current_prompt_id]["current_prompt"] = prompt
+        
+    def get_metadata(self, prompt_id=None):
+        """Get collected metadata for a prompt"""
+        key = prompt_id if prompt_id is not None else self.current_prompt_id
+        if key not in self.prompt_metadata:
+            return {}
+            
+        metadata = self.prompt_metadata[key]
+        
+        # If we have a current prompt object, check for non-executed nodes
+        prompt_obj = metadata.get("current_prompt")
+        if prompt_obj and hasattr(prompt_obj, "original_prompt"):
+            original_prompt = prompt_obj.original_prompt
+            
+            # Fill in missing metadata from cache for nodes that weren't executed
+            self._fill_missing_metadata(key, original_prompt)
+            
+        return self.prompt_metadata.get(key, {})
+    
+    def _fill_missing_metadata(self, prompt_id, original_prompt):
+        """Fill missing metadata from cache for non-executed nodes"""
+        if not original_prompt:
+            return
+            
+        executed_nodes = self.executed_nodes
+        metadata = self.prompt_metadata[prompt_id]
+        
+        # Iterate through nodes in the original prompt
+        for node_id, node_data in original_prompt.items():
+            # Skip if already executed in this run
+            if node_id in executed_nodes:
+                continue
+                
+            # Get the node type from the prompt (this is the key in NODE_CLASS_MAPPINGS)
+            prompt_class_type = node_data.get("class_type")
+            if not prompt_class_type:
+                continue
+                
+            # Convert to actual class name (which is what we use in our cache)
+            class_type = prompt_class_type
+            if prompt_class_type in NODE_CLASS_MAPPINGS:
+                class_obj = NODE_CLASS_MAPPINGS[prompt_class_type]
+                class_type = class_obj.__name__
+            
+            # Create cache key using the actual class name
+            cache_key = f"{node_id}:{class_type}"
+            
+            # Check if this node type is relevant for metadata collection
+            if class_type in NODE_EXTRACTORS:
+                # Check if we have cached metadata for this node
+                if cache_key in self.node_cache:
+                    cached_data = self.node_cache[cache_key]
+                    
+                    # Apply cached metadata to the current metadata
+                    for category in self.metadata_categories:
+                        if category in cached_data and node_id in cached_data[category]:
+                            if node_id not in metadata[category]:
+                                metadata[category][node_id] = cached_data[category][node_id]
+    
+    def record_node_execution(self, node_id, class_type, inputs, outputs):
+        """Record information about a node's execution"""
+        if not self.current_prompt_id:
+            return
+            
+        # Add to execution order and mark as executed
+        if node_id not in self.executed_nodes:
+            self.executed_nodes.add(node_id)
+            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(node_id)
+        
+        # Process inputs to simplify working with them
+        processed_inputs = {}
+        for input_name, input_values in inputs.items():
+            if isinstance(input_values, list) and len(input_values) > 0:
+                # For single values, just use the first one (most common case)
+                processed_inputs[input_name] = input_values[0]
+            else:
+                processed_inputs[input_name] = input_values
+            
+        # Extract node-specific metadata
+        extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
+        extractor.extract(
+            node_id, 
+            processed_inputs, 
+            outputs, 
+            self.prompt_metadata[self.current_prompt_id]
+        )
+        
+        # Cache this node's metadata
+        self._cache_node_metadata(node_id, class_type)
+    
+    def update_node_execution(self, node_id, class_type, outputs):
+        """Update node metadata with output information"""
+        if not self.current_prompt_id:
+            return
+        
+        # Process outputs to make them more usable
+        processed_outputs = outputs
+            
+        # Use the same extractor to update with outputs
+        extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
+        if hasattr(extractor, 'update'):
+            extractor.update(
+                node_id, 
+                processed_outputs, 
+                self.prompt_metadata[self.current_prompt_id]
+            )
+            
+        # Update the cached metadata for this node
+        self._cache_node_metadata(node_id, class_type)
+            
+    def _cache_node_metadata(self, node_id, class_type):
+        """Cache the metadata for a specific node"""
+        if not self.current_prompt_id or not node_id or not class_type:
+            return
+            
+        # Create a cache key combining node_id and class_type
+        cache_key = f"{node_id}:{class_type}"
+        
+        # Create a shallow copy of the node's metadata
+        node_metadata = {}
+        current_metadata = self.prompt_metadata[self.current_prompt_id]
+        
+        for category in self.metadata_categories:
+            if category in current_metadata and node_id in current_metadata[category]:
+                if category not in node_metadata:
+                    node_metadata[category] = {}
+                node_metadata[category][node_id] = current_metadata[category][node_id]
+        
+        # Save to cache if we have any metadata for this node
+        if any(node_metadata.values()):
+            self.node_cache[cache_key] = node_metadata
+    
+    def clear_unused_cache(self):
+        """Clean up node_cache entries that are no longer in use"""
+        # Collect all node_ids currently in prompt_metadata
+        active_node_ids = set()
+        for prompt_data in self.prompt_metadata.values():
+            for category in self.metadata_categories:
+                if category in prompt_data:
+                    active_node_ids.update(prompt_data[category].keys())
+        
+        # Find cache keys that are no longer needed
+        keys_to_remove = []
+        for cache_key in self.node_cache:
+            node_id = cache_key.split(':')[0]
+            if node_id not in active_node_ids:
+                keys_to_remove.append(cache_key)
+        
+        # Remove cache entries that are no longer needed
+        for key in keys_to_remove:
+            del self.node_cache[key]
+    
+    def clear_metadata(self, prompt_id=None):
+        """Clear metadata for a specific prompt or reset all data"""
+        if prompt_id is not None:
+            if prompt_id in self.prompt_metadata:
+                del self.prompt_metadata[prompt_id]
+                # Clean up cache after removing prompt
+                self.clear_unused_cache()
+        else:
+            # Reset all data
+            self._reset()
+    
+    def get_first_decoded_image(self, prompt_id=None):
+        """Get the first decoded image result"""
+        key = prompt_id if prompt_id is not None else self.current_prompt_id
+        if key not in self.prompt_metadata:
+            return None
+            
+        metadata = self.prompt_metadata[key]
+        if IMAGES in metadata and "first_decode" in metadata[IMAGES]:
+            image_data = metadata[IMAGES]["first_decode"]["image"]
+            
+            # If it's an image batch or tuple, handle various formats
+            if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
+                # Return first element of list/tuple
+                return image_data[0]
+            
+            # If it's a tensor, return as is for processing in the route handler
+            return image_data
+        
+        # If no image is found in the current metadata, try to find it in the cache
+        # This handles the case where VAEDecode was cached by ComfyUI and not executed
+        prompt_obj = metadata.get("current_prompt")
+        if prompt_obj and hasattr(prompt_obj, "original_prompt"):
+            original_prompt = prompt_obj.original_prompt
+            for node_id, node_data in original_prompt.items():
+                class_type = node_data.get("class_type")
+                if class_type and class_type in NODE_CLASS_MAPPINGS:
+                    class_obj = NODE_CLASS_MAPPINGS[class_type]
+                    class_name = class_obj.__name__
+                    # Check if this is a VAEDecode node
+                    if class_name == "VAEDecode":
+                        # Try to find this node in the cache
+                        cache_key = f"{node_id}:{class_name}"
+                        if cache_key in self.node_cache:
+                            cached_data = self.node_cache[cache_key]
+                            if IMAGES in cached_data and node_id in cached_data[IMAGES]:
+                                image_data = cached_data[IMAGES][node_id]["image"]
+                                # Handle different image formats
+                                if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
+                                    return image_data[0]
+                                return image_data
+        
+        return None

py/metadata_collector/node_extractors.py

@@ -0,0 +1,389 @@
+import os
+
+from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES
+
+
+class NodeMetadataExtractor:
+    """Base class for node-specific metadata extraction"""
+    
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        """Extract metadata from node inputs/outputs"""
+        pass
+        
+    @staticmethod
+    def update(node_id, outputs, metadata):
+        """Update metadata with node outputs after execution"""
+        pass
+        
+class GenericNodeExtractor(NodeMetadataExtractor):
+    """Default extractor for nodes without specific handling"""
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        pass
+        
+class CheckpointLoaderExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "ckpt_name" not in inputs:
+            return
+            
+        model_name = inputs.get("ckpt_name")
+        if model_name:
+            metadata[MODELS][node_id] = {
+                "name": model_name,
+                "type": "checkpoint",
+                "node_id": node_id
+            }
+        
+class CLIPTextEncodeExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "text" not in inputs:
+            return
+            
+        text = inputs.get("text", "")
+        metadata[PROMPTS][node_id] = {
+            "text": text,
+            "node_id": node_id
+        }
+        
+class SamplerExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+        for key in ["seed", "steps", "cfg", "sampler_name", "scheduler", "denoise"]:
+            if key in inputs:
+                sampling_params[key] = inputs[key]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+        
+        # Extract latent image dimensions if available
+        if "latent_image" in inputs and inputs["latent_image"] is not None:
+            latent = inputs["latent_image"]
+            if isinstance(latent, dict) and "samples" in latent:
+                # Extract dimensions from latent tensor
+                samples = latent["samples"]
+                if hasattr(samples, "shape") and len(samples.shape) >= 3:
+                    # Correct shape interpretation: [batch_size, channels, height/8, width/8]
+                    # Multiply by 8 to get actual pixel dimensions
+                    height = int(samples.shape[2] * 8)
+                    width = int(samples.shape[3] * 8)
+                    
+                    if SIZE not in metadata:
+                        metadata[SIZE] = {}
+                        
+                    metadata[SIZE][node_id] = {
+                        "width": width,
+                        "height": height,
+                        "node_id": node_id
+                    }
+
+class KSamplerAdvancedExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+        for key in ["noise_seed", "steps", "cfg", "sampler_name", "scheduler", "add_noise"]:
+            if key in inputs:
+                sampling_params[key] = inputs[key]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+        
+        # Extract latent image dimensions if available
+        if "latent_image" in inputs and inputs["latent_image"] is not None:
+            latent = inputs["latent_image"]
+            if isinstance(latent, dict) and "samples" in latent:
+                # Extract dimensions from latent tensor
+                samples = latent["samples"]
+                if hasattr(samples, "shape") and len(samples.shape) >= 3:
+                    # Correct shape interpretation: [batch_size, channels, height/8, width/8]
+                    # Multiply by 8 to get actual pixel dimensions
+                    height = int(samples.shape[2] * 8)
+                    width = int(samples.shape[3] * 8)
+                    
+                    if SIZE not in metadata:
+                        metadata[SIZE] = {}
+                        
+                    metadata[SIZE][node_id] = {
+                        "width": width,
+                        "height": height,
+                        "node_id": node_id
+                    }
+
+class LoraLoaderExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "lora_name" not in inputs:
+            return
+            
+        lora_name = inputs.get("lora_name")
+        # Extract base filename without extension from path
+        lora_name = os.path.splitext(os.path.basename(lora_name))[0]
+        strength_model = round(float(inputs.get("strength_model", 1.0)), 2)
+        
+        # Use the standardized format with lora_list
+        metadata[LORAS][node_id] = {
+            "lora_list": [
+                {
+                    "name": lora_name,
+                    "strength": strength_model
+                }
+            ],
+            "node_id": node_id
+        }
+
+class ImageSizeExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+        
+        width = inputs.get("width", 512)
+        height = inputs.get("height", 512)
+        
+        if SIZE not in metadata:
+            metadata[SIZE] = {}
+            
+        metadata[SIZE][node_id] = {
+            "width": width,
+            "height": height,
+            "node_id": node_id
+        }
+
+class LoraLoaderManagerExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+        
+        active_loras = []
+        
+        # Process lora_stack if available
+        if "lora_stack" in inputs:
+            lora_stack = inputs.get("lora_stack", [])
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Extract lora name from path (following the format in lora_loader.py)
+                lora_name = os.path.splitext(os.path.basename(lora_path))[0]
+                active_loras.append({
+                    "name": lora_name,
+                    "strength": model_strength
+                })
+        
+        # Process loras from inputs
+        if "loras" in inputs:
+            loras_data = inputs.get("loras", [])
+            
+            # Handle new format: {'loras': {'__value__': [...]}} 
+            if isinstance(loras_data, dict) and '__value__' in loras_data:
+                loras_list = loras_data['__value__']
+            # Handle old format: {'loras': [...]}
+            elif isinstance(loras_data, list):
+                loras_list = loras_data
+            else:
+                loras_list = []
+                
+            # Filter for active loras
+            for lora in loras_list:
+                if isinstance(lora, dict) and lora.get("active", True) and not lora.get("_isDummy", False):
+                    active_loras.append({
+                        "name": lora.get("name", ""),
+                        "strength": float(lora.get("strength", 1.0))
+                    })
+        
+        if active_loras:
+            metadata[LORAS][node_id] = {
+                "lora_list": active_loras,
+                "node_id": node_id
+            }
+
+class FluxGuidanceExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "guidance" not in inputs:
+            return
+            
+        guidance_value = inputs.get("guidance")
+        
+        # Store the guidance value in SAMPLING category
+        if node_id not in metadata[SAMPLING]:
+            metadata[SAMPLING][node_id] = {"parameters": {}, "node_id": node_id}
+            
+        metadata[SAMPLING][node_id]["parameters"]["guidance"] = guidance_value
+
+class UNETLoaderExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "unet_name" not in inputs:
+            return
+            
+        model_name = inputs.get("unet_name")
+        if model_name:
+            metadata[MODELS][node_id] = {
+                "name": model_name,
+                "type": "checkpoint",
+                "node_id": node_id
+            }
+
+class VAEDecodeExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        pass
+        
+    @staticmethod
+    def update(node_id, outputs, metadata):
+        # Ensure IMAGES category exists
+        if IMAGES not in metadata:
+            metadata[IMAGES] = {}
+            
+        # Save image data under node ID index to be captured by caching mechanism
+        metadata[IMAGES][node_id] = {
+            "node_id": node_id,
+            "image": outputs
+        }
+        
+        # Only set first_decode if it hasn't been recorded yet
+        if "first_decode" not in metadata[IMAGES]:
+            metadata[IMAGES]["first_decode"] = metadata[IMAGES][node_id]
+
+class KSamplerSelectExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "sampler_name" not in inputs:
+            return
+            
+        sampling_params = {}
+        if "sampler_name" in inputs:
+            sampling_params["sampler_name"] = inputs["sampler_name"]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+
+class BasicSchedulerExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+        for key in ["scheduler", "steps", "denoise"]:
+            if key in inputs:
+                sampling_params[key] = inputs[key]
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+
+class SamplerCustomAdvancedExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+            
+        sampling_params = {}
+
+        # Handle noise.seed as seed
+        if "noise" in inputs and inputs["noise"] is not None and hasattr(inputs["noise"], "seed"):
+            noise = inputs["noise"]
+            sampling_params["seed"] = noise.seed
+                
+        metadata[SAMPLING][node_id] = {
+            "parameters": sampling_params,
+            "node_id": node_id
+        }
+        
+        # Extract latent image dimensions if available
+        if "latent_image" in inputs and inputs["latent_image"] is not None:
+            latent = inputs["latent_image"]
+            if isinstance(latent, dict) and "samples" in latent:
+                # Extract dimensions from latent tensor
+                samples = latent["samples"]
+                if hasattr(samples, "shape") and len(samples.shape) >= 3:
+                    # Correct shape interpretation: [batch_size, channels, height/8, width/8]
+                    # Multiply by 8 to get actual pixel dimensions
+                    height = int(samples.shape[2] * 8)
+                    width = int(samples.shape[3] * 8)
+                    
+                    if SIZE not in metadata:
+                        metadata[SIZE] = {}
+                        
+                    metadata[SIZE][node_id] = {
+                        "width": width,
+                        "height": height,
+                        "node_id": node_id
+                    }
+
+import json
+
+class CLIPTextEncodeFluxExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "clip_l" not in inputs or "t5xxl" not in inputs:
+            return
+            
+        clip_l_text = inputs.get("clip_l", "")
+        t5xxl_text = inputs.get("t5xxl", "")
+        
+        # Create JSON string with T5 content first, then CLIP-L
+        combined_text = json.dumps({
+            "T5": t5xxl_text,
+            "CLIP-L": clip_l_text
+        })
+        
+        metadata[PROMPTS][node_id] = {
+            "text": combined_text,
+            "node_id": node_id
+        }
+        
+        # Extract guidance value if available
+        if "guidance" in inputs:
+            guidance_value = inputs.get("guidance")
+            
+            # Store the guidance value in SAMPLING category
+            if SAMPLING not in metadata:
+                metadata[SAMPLING] = {}
+                
+            if node_id not in metadata[SAMPLING]:
+                metadata[SAMPLING][node_id] = {"parameters": {}, "node_id": node_id}
+                
+            metadata[SAMPLING][node_id]["parameters"]["guidance"] = guidance_value
+
+# Registry of node-specific extractors
+NODE_EXTRACTORS = {
+    # Sampling
+    "KSampler": SamplerExtractor,
+    "KSamplerAdvanced": KSamplerAdvancedExtractor,
+    "SamplerCustomAdvanced": SamplerCustomAdvancedExtractor,  # Updated to use dedicated extractor
+    # Sampling Selectors
+    "KSamplerSelect": KSamplerSelectExtractor,  # Add KSamplerSelect
+    "BasicScheduler": BasicSchedulerExtractor,  # Add BasicScheduler
+    # Loaders
+    "CheckpointLoaderSimple": CheckpointLoaderExtractor,
+    "UNETLoader": UNETLoaderExtractor,          # Updated to use dedicated extractor
+    "LoraLoader": LoraLoaderExtractor,
+    "LoraManagerLoader": LoraLoaderManagerExtractor,
+    # Conditioning
+    "CLIPTextEncode": CLIPTextEncodeExtractor,
+    "CLIPTextEncodeFlux": CLIPTextEncodeFluxExtractor,  # Add CLIPTextEncodeFlux
+    # Latent
+    "EmptyLatentImage": ImageSizeExtractor,
+    # Flux
+    "FluxGuidance": FluxGuidanceExtractor,      # Add FluxGuidance
+    # Image
+    "VAEDecode": VAEDecodeExtractor,  # Added VAEDecode extractor
+    # Add other nodes as needed
+}

py/nodes/debug_metadata.py

@@ -0,0 +1,35 @@
+import logging
+from ..metadata_collector.metadata_processor import MetadataProcessor
+
+logger = logging.getLogger(__name__)
+
+class DebugMetadata:
+    NAME = "Debug Metadata (LoraManager)"
+    CATEGORY = "Lora Manager/utils"
+    DESCRIPTION = "Debug node to verify metadata_processor functionality"
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("metadata_json",)
+    FUNCTION = "process_metadata"
+
+    def process_metadata(self, images):
+        try:
+            # Get the current execution context's metadata
+            from ..metadata_collector import get_metadata
+            metadata = get_metadata()
+            
+            # Use the MetadataProcessor to convert it to JSON string
+            metadata_json = MetadataProcessor.to_json(metadata)
+            
+            return (metadata_json,)
+        except Exception as e:
+            logger.error(f"Error processing metadata: {e}")
+            return ("{}",)  # Return empty JSON object in case of error

py/nodes/lora_loader.py

@@ -5,7 +5,7 @@ from ..services.lora_scanner import LoraScanner
 from ..config import config
 import asyncio
 import os
-from .utils import FlexibleOptionalInputType, any_type
+from .utils import FlexibleOptionalInputType, any_type, get_lora_info, extract_lora_name, get_loras_list
 
 logger = logging.getLogger(__name__)
 
@@ -32,48 +32,6 @@ class LoraManagerLoader:
     RETURN_TYPES = ("MODEL", "CLIP", IO.STRING, IO.STRING)
     RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
     FUNCTION = "load_loras"
-
-    async def get_lora_info(self, lora_name):
-        """Get the lora path and trigger words from cache"""
-        scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
-        
-        for item in cache.raw_data:
-            if item.get('file_name') == lora_name:
-                file_path = item.get('file_path')
-                if file_path:
-                    for root in config.loras_roots:
-                        root = root.replace(os.sep, '/')
-                        if file_path.startswith(root):
-                            relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
-                            # Get trigger words from civitai metadata
-                            civitai = item.get('civitai', {})
-                            trigger_words = civitai.get('trainedWords', []) if civitai else []
-                            return relative_path, trigger_words
-        return lora_name, []  # Fallback if not found
-
-    def extract_lora_name(self, lora_path):
-        """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-        # Get the basename without extension
-        basename = os.path.basename(lora_path)
-        return os.path.splitext(basename)[0]
-    
-    def _get_loras_list(self, kwargs):
-        """Helper to extract loras list from either old or new kwargs format"""
-        if 'loras' not in kwargs:
-            return []
-            
-        loras_data = kwargs['loras']
-        # Handle new format: {'loras': {'__value__': [...]}}
-        if isinstance(loras_data, dict) and '__value__' in loras_data:
-            return loras_data['__value__']
-        # Handle old format: {'loras': [...]}
-        elif isinstance(loras_data, list):
-            return loras_data
-        # Unexpected format
-        else:
-            logger.warning(f"Unexpected loras format: {type(loras_data)}")
-            return []
     
     def load_loras(self, model, text, **kwargs):
         """Loads multiple LoRAs based on the kwargs input and lora_stack."""
@@ -89,14 +47,14 @@ class LoraManagerLoader:
                 model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
                 
                 # Extract lora name for trigger words lookup
-                lora_name = self.extract_lora_name(lora_path)
-                _, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = asyncio.run(get_lora_info(lora_name))
                 
                 all_trigger_words.extend(trigger_words)
                 loaded_loras.append(f"{lora_name}: {model_strength}")
         
         # Then process loras from kwargs with support for both old and new formats
-        loras_list = self._get_loras_list(kwargs)
+        loras_list = get_loras_list(kwargs)
         for lora in loras_list:
             if not lora.get('active', False):
                 continue
@@ -105,7 +63,7 @@ class LoraManagerLoader:
             strength = float(lora['strength'])
             
             # Get lora path and trigger words
-            lora_path, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+            lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
             
             # Apply the LoRA using the resolved path
             model, clip = LoraLoader().load_lora(model, clip, lora_path, strength, strength)

py/nodes/lora_stacker.py

@@ -3,7 +3,7 @@ from ..services.lora_scanner import LoraScanner
 from ..config import config
 import asyncio
 import os
-from .utils import FlexibleOptionalInputType, any_type
+from .utils import FlexibleOptionalInputType, any_type, get_lora_info, extract_lora_name, get_loras_list
 import logging
 
 logger = logging.getLogger(__name__)
@@ -29,48 +29,6 @@ class LoraStacker:
     RETURN_TYPES = ("LORA_STACK", IO.STRING, IO.STRING)
     RETURN_NAMES = ("LORA_STACK", "trigger_words", "active_loras")
     FUNCTION = "stack_loras"
-
-    async def get_lora_info(self, lora_name):
-        """Get the lora path and trigger words from cache"""
-        scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
-        
-        for item in cache.raw_data:
-            if item.get('file_name') == lora_name:
-                file_path = item.get('file_path')
-                if file_path:
-                    for root in config.loras_roots:
-                        root = root.replace(os.sep, '/')
-                        if file_path.startswith(root):
-                            relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
-                            # Get trigger words from civitai metadata
-                            civitai = item.get('civitai', {})
-                            trigger_words = civitai.get('trainedWords', []) if civitai else []
-                            return relative_path, trigger_words
-        return lora_name, []  # Fallback if not found
-
-    def extract_lora_name(self, lora_path):
-        """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-        # Get the basename without extension
-        basename = os.path.basename(lora_path)
-        return os.path.splitext(basename)[0]
-    
-    def _get_loras_list(self, kwargs):
-        """Helper to extract loras list from either old or new kwargs format"""
-        if 'loras' not in kwargs:
-            return []
-            
-        loras_data = kwargs['loras']
-        # Handle new format: {'loras': {'__value__': [...]}}
-        if isinstance(loras_data, dict) and '__value__' in loras_data:
-            return loras_data['__value__']
-        # Handle old format: {'loras': [...]}
-        elif isinstance(loras_data, list):
-            return loras_data
-        # Unexpected format
-        else:
-            logger.warning(f"Unexpected loras format: {type(loras_data)}")
-            return []
     
     def stack_loras(self, text, **kwargs):
         """Stacks multiple LoRAs based on the kwargs input without loading them."""
@@ -84,12 +42,12 @@ class LoraStacker:
             stack.extend(lora_stack)
             # Get trigger words from existing stack entries
             for lora_path, _, _ in lora_stack:
-                lora_name = self.extract_lora_name(lora_path)
-                _, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = asyncio.run(get_lora_info(lora_name))
                 all_trigger_words.extend(trigger_words)
         
         # Process loras from kwargs with support for both old and new formats
-        loras_list = self._get_loras_list(kwargs)
+        loras_list = get_loras_list(kwargs)
         for lora in loras_list:
             if not lora.get('active', False):
                 continue
@@ -99,7 +57,7 @@ class LoraStacker:
             clip_strength = model_strength  # Using same strength for both as in the original loader
             
             # Get lora path and trigger words
-            lora_path, trigger_words = asyncio.run(self.get_lora_info(lora_name))
+            lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
             
             # Add to stack without loading
             # replace '/' with os.sep to avoid different OS path format

py/nodes/save_image.py

@@ -5,10 +5,11 @@ import re
 import numpy as np
 import folder_paths # type: ignore
 from ..services.lora_scanner import LoraScanner
-from ..workflow.parser import WorkflowParser
+from ..services.checkpoint_scanner import CheckpointScanner
+from ..metadata_collector.metadata_processor import MetadataProcessor
+from ..metadata_collector import get_metadata
 from PIL import Image, PngImagePlugin
 import piexif
-from io import BytesIO
 
 class SaveImage:
     NAME = "Save Image (LoraManager)"
@@ -34,8 +35,7 @@ class SaveImage:
                 "file_format": (["png", "jpeg", "webp"],),
             },
             "optional": {
-                "custom_prompt": ("STRING", {"default": "", "forceInput": True}),
-                "lossless_webp": ("BOOLEAN", {"default": True}),
+                "lossless_webp": ("BOOLEAN", {"default": False}),
                 "quality": ("INT", {"default": 100, "min": 1, "max": 100}),
                 "embed_workflow": ("BOOLEAN", {"default": False}),
                 "add_counter_to_filename": ("BOOLEAN", {"default": True}),
@@ -54,28 +54,61 @@ class SaveImage:
     async def get_lora_hash(self, lora_name):
         """Get the lora hash from cache"""
         scanner = await LoraScanner.get_instance()
-        cache = await scanner.get_cached_data()
         
+        # Use the new direct filename lookup method
+        hash_value = scanner.get_hash_by_filename(lora_name)
+        if hash_value:
+            return hash_value
+            
+        # Fallback to old method for compatibility
+        cache = await scanner.get_cached_data()
         for item in cache.raw_data:
             if item.get('file_name') == lora_name:
                 return item.get('sha256')
         return None
 
-    async def format_metadata(self, parsed_workflow, custom_prompt=None):
+    async def get_checkpoint_hash(self, checkpoint_path):
+        """Get the checkpoint hash from cache"""
+        scanner = await CheckpointScanner.get_instance()
+        
+        if not checkpoint_path:
+            return None
+            
+        # Extract basename without extension
+        checkpoint_name = os.path.basename(checkpoint_path)
+        checkpoint_name = os.path.splitext(checkpoint_name)[0]
+        
+        # Try direct filename lookup first
+        hash_value = scanner.get_hash_by_filename(checkpoint_name)
+        if hash_value:
+            return hash_value
+            
+        # Fallback to old method for compatibility
+        cache = await scanner.get_cached_data()
+        normalized_path = checkpoint_path.replace('\\', '/')
+        
+        for item in cache.raw_data:
+            if item.get('file_name') == checkpoint_name and item.get('file_path').endswith(normalized_path):
+                return item.get('sha256')
+                
+        return None
+
+    async def format_metadata(self, metadata_dict):
         """Format metadata in the requested format similar to userComment example"""
-        if not parsed_workflow:
+        if not metadata_dict:
             return ""
         
-        # Extract the prompt and negative prompt
-        prompt = parsed_workflow.get('prompt', '')
-        negative_prompt = parsed_workflow.get('negative_prompt', '')
+        # Helper function to only add parameter if value is not None
+        def add_param_if_not_none(param_list, label, value):
+            if value is not None:
+                param_list.append(f"{label}: {value}")
         
-        # Override prompt with custom_prompt if provided
-        if custom_prompt:
-            prompt = custom_prompt
+        # Extract the prompt and negative prompt
+        prompt = metadata_dict.get('prompt', '')
+        negative_prompt = metadata_dict.get('negative_prompt', '')
         
         # Extract loras from the prompt if present
-        loras_text = parsed_workflow.get('loras', '')
+        loras_text = metadata_dict.get('loras', '')
         lora_hashes = {}
         
         # If loras are found, add them on a new line after the prompt
@@ -104,11 +137,15 @@ class SaveImage:
         params = []
         
         # Add standard parameters in the correct order
-        if 'steps' in parsed_workflow:
-            params.append(f"Steps: {parsed_workflow.get('steps')}")
+        if 'steps' in metadata_dict:
+            add_param_if_not_none(params, "Steps", metadata_dict.get('steps'))
         
-        if 'sampler' in parsed_workflow:
-            sampler = parsed_workflow.get('sampler')
+        # Combine sampler and scheduler information
+        sampler_name = None
+        scheduler_name = None
+        
+        if 'sampler' in metadata_dict:
+            sampler = metadata_dict.get('sampler')
             # Convert ComfyUI sampler names to user-friendly names
             sampler_mapping = {
                 'euler': 'Euler',
@@ -128,10 +165,9 @@ class SaveImage:
                 'ddim': 'DDIM'
             }
             sampler_name = sampler_mapping.get(sampler, sampler)
-            params.append(f"Sampler: {sampler_name}")
         
-        if 'scheduler' in parsed_workflow:
-            scheduler = parsed_workflow.get('scheduler')
+        if 'scheduler' in metadata_dict:
+            scheduler = metadata_dict.get('scheduler')
             scheduler_mapping = {
                 'normal': 'Simple',
                 'karras': 'Karras',
@@ -140,29 +176,48 @@ class SaveImage:
                 'sgm_quadratic': 'SGM Quadratic'
             }
             scheduler_name = scheduler_mapping.get(scheduler, scheduler)
-            params.append(f"Schedule type: {scheduler_name}")
         
-        # CFG scale (cfg in parsed_workflow)
-        if 'cfg_scale' in parsed_workflow:
-            params.append(f"CFG scale: {parsed_workflow.get('cfg_scale')}")
-        elif 'cfg' in parsed_workflow:
-            params.append(f"CFG scale: {parsed_workflow.get('cfg')}")
+        # Add combined sampler and scheduler information
+        if sampler_name:
+            if scheduler_name:
+                params.append(f"Sampler: {sampler_name} {scheduler_name}")
+            else:
+                params.append(f"Sampler: {sampler_name}")
+        
+        # CFG scale (Use guidance if available, otherwise fall back to cfg_scale or cfg)
+        if 'guidance' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('guidance'))
+        elif 'cfg_scale' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg_scale'))
+        elif 'cfg' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg'))
         
         # Seed
-        if 'seed' in parsed_workflow:
-            params.append(f"Seed: {parsed_workflow.get('seed')}")
+        if 'seed' in metadata_dict:
+            add_param_if_not_none(params, "Seed", metadata_dict.get('seed'))
         
         # Size
-        if 'size' in parsed_workflow:
-            params.append(f"Size: {parsed_workflow.get('size')}")
+        if 'size' in metadata_dict:
+            add_param_if_not_none(params, "Size", metadata_dict.get('size'))
         
         # Model info
-        if 'checkpoint' in parsed_workflow:
-            # Extract basename without path
-            checkpoint = os.path.basename(parsed_workflow.get('checkpoint', ''))
-            # Remove extension if present
-            checkpoint = os.path.splitext(checkpoint)[0]
-            params.append(f"Model: {checkpoint}")
+        if 'checkpoint' in metadata_dict:
+            # Ensure checkpoint is a string before processing
+            checkpoint = metadata_dict.get('checkpoint')
+            if checkpoint is not None:
+                # Get model hash
+                model_hash = await self.get_checkpoint_hash(checkpoint)
+                
+                # Extract basename without path
+                checkpoint_name = os.path.basename(checkpoint)
+                # Remove extension if present
+                checkpoint_name = os.path.splitext(checkpoint_name)[0]
+                
+                # Add model hash if available
+                if model_hash:
+                    params.append(f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}")
+                else:
+                    params.append(f"Model: {checkpoint_name}")
         
         # Add LoRA hashes if available
         if lora_hashes:
@@ -181,9 +236,9 @@ class SaveImage:
 
     # credit to nkchocoai
     # Add format_filename method to handle pattern substitution
-    def format_filename(self, filename, parsed_workflow):
+    def format_filename(self, filename, metadata_dict):
         """Format filename with metadata values"""
-        if not parsed_workflow:
+        if not metadata_dict:
             return filename
             
         result = re.findall(self.pattern_format, filename)
@@ -191,30 +246,30 @@ class SaveImage:
             parts = segment.replace("%", "").split(":")
             key = parts[0]
             
-            if key == "seed" and 'seed' in parsed_workflow:
-                filename = filename.replace(segment, str(parsed_workflow.get('seed', '')))
-            elif key == "width" and 'size' in parsed_workflow:
-                size = parsed_workflow.get('size', 'x')
+            if key == "seed" and 'seed' in metadata_dict:
+                filename = filename.replace(segment, str(metadata_dict.get('seed', '')))
+            elif key == "width" and 'size' in metadata_dict:
+                size = metadata_dict.get('size', 'x')
                 w = size.split('x')[0] if isinstance(size, str) else size[0]
                 filename = filename.replace(segment, str(w))
-            elif key == "height" and 'size' in parsed_workflow:
-                size = parsed_workflow.get('size', 'x')
+            elif key == "height" and 'size' in metadata_dict:
+                size = metadata_dict.get('size', 'x')
                 h = size.split('x')[1] if isinstance(size, str) else size[1]
                 filename = filename.replace(segment, str(h))
-            elif key == "pprompt" and 'prompt' in parsed_workflow:
-                prompt = parsed_workflow.get('prompt', '').replace("\n", " ")
+            elif key == "pprompt" and 'prompt' in metadata_dict:
+                prompt = metadata_dict.get('prompt', '').replace("\n", " ")
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
-            elif key == "nprompt" and 'negative_prompt' in parsed_workflow:
-                prompt = parsed_workflow.get('negative_prompt', '').replace("\n", " ")
+            elif key == "nprompt" and 'negative_prompt' in metadata_dict:
+                prompt = metadata_dict.get('negative_prompt', '').replace("\n", " ")
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
-            elif key == "model" and 'checkpoint' in parsed_workflow:
-                model = parsed_workflow.get('checkpoint', '')
+            elif key == "model" and 'checkpoint' in metadata_dict:
+                model = metadata_dict.get('checkpoint', '')
                 model = os.path.splitext(os.path.basename(model))[0]
                 if len(parts) >= 2:
                     length = int(parts[1])
@@ -224,12 +279,13 @@ class SaveImage:
                 from datetime import datetime
                 now = datetime.now()
                 date_table = {
-                    "yyyy": str(now.year),
-                    "MM": str(now.month).zfill(2),
-                    "dd": str(now.day).zfill(2),
-                    "hh": str(now.hour).zfill(2),
-                    "mm": str(now.minute).zfill(2),
-                    "ss": str(now.second).zfill(2),
+                    "yyyy": f"{now.year:04d}",
+                    "yy": f"{now.year % 100:02d}",
+                    "MM": f"{now.month:02d}",
+                    "dd": f"{now.day:02d}",
+                    "hh": f"{now.hour:02d}",
+                    "mm": f"{now.minute:02d}",
+                    "ss": f"{now.second:02d}",
                 }
                 if len(parts) >= 2:
                     date_format = parts[1]
@@ -245,23 +301,19 @@ class SaveImage:
         return filename
 
     def save_images(self, images, filename_prefix, file_format, prompt=None, extra_pnginfo=None, 
-                   lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True,
-                   custom_prompt=None):
+                   lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
         """Save images with metadata"""
         results = []
         
-        # Parse the workflow using the WorkflowParser
-        parser = WorkflowParser()
-        if prompt:
-            parsed_workflow = parser.parse_workflow(prompt)
-        else:
-            parsed_workflow = {}
+        # Get metadata using the metadata collector
+        raw_metadata = get_metadata()
+        metadata_dict = MetadataProcessor.to_dict(raw_metadata)
             
         # Get or create metadata asynchronously
-        metadata = asyncio.run(self.format_metadata(parsed_workflow, custom_prompt))
+        metadata = asyncio.run(self.format_metadata(metadata_dict))
         
         # Process filename_prefix with pattern substitution
-        filename_prefix = self.format_filename(filename_prefix, parsed_workflow)
+        filename_prefix = self.format_filename(filename_prefix, metadata_dict)
         
         # Get initial save path info once for the batch
         full_output_folder, filename, counter, subfolder, processed_prefix = folder_paths.get_save_image_path(
@@ -283,13 +335,14 @@ class SaveImage:
             if add_counter_to_filename:
                 # Use counter + i to ensure unique filenames for all images in batch
                 current_counter = counter + i
-                base_filename += f"_{current_counter:05}"
+                base_filename += f"_{current_counter:05}_"
                 
             # Set file extension and prepare saving parameters
             if file_format == "png":
                 file = base_filename + ".png"
                 file_extension = ".png"
-                save_kwargs = {"optimize": True, "compress_level": self.compress_level}
+                # Remove "optimize": True to match built-in node behavior
+                save_kwargs = {"compress_level": self.compress_level}
                 pnginfo = PngImagePlugin.PngInfo()
             elif file_format == "jpeg":
                 file = base_filename + ".jpg"
@@ -298,7 +351,8 @@ class SaveImage:
             elif file_format == "webp":
                 file = base_filename + ".webp" 
                 file_extension = ".webp"
-                save_kwargs = {"quality": quality, "lossless": lossless_webp}
+                # Add optimization param to control performance
+                save_kwargs = {"quality": quality, "lossless": lossless_webp, "method": 0}
             
             # Full save path
             file_path = os.path.join(full_output_folder, file)
@@ -346,8 +400,7 @@ class SaveImage:
         return results
 
     def process_image(self, images, filename_prefix="ComfyUI", file_format="png", prompt=None, extra_pnginfo=None,
-                     lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True,
-                     custom_prompt=""):
+                     lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
         """Process and save image with metadata"""
         # Make sure the output directory exists
         os.makedirs(self.output_dir, exist_ok=True)
@@ -368,8 +421,7 @@ class SaveImage:
             lossless_webp,
             quality,
             embed_workflow,
-            add_counter_to_filename,
-            custom_prompt if custom_prompt.strip() else None
+            add_counter_to_filename
         )
         
         return (images,)

py/nodes/trigger_word_toggle.py

@@ -47,10 +47,10 @@ class TriggerWordToggle:
         trigger_words = trigger_words_data if isinstance(trigger_words_data, str) else ""
         
         # Send trigger words to frontend
-        PromptServer.instance.send_sync("trigger_word_update", {
-            "id": id,
-            "message": trigger_words
-        })
+        # PromptServer.instance.send_sync("trigger_word_update", {
+        #     "id": id,
+        #     "message": trigger_words
+        # })
         
         filtered_triggers = trigger_words
         

py/nodes/utils.py

@@ -30,4 +30,55 @@ class FlexibleOptionalInputType(dict):
     return True
 
 
-any_type = AnyType("*")
+any_type = AnyType("*")
+
+# Common methods extracted from lora_loader.py and lora_stacker.py
+import os
+import logging
+import asyncio
+from ..services.lora_scanner import LoraScanner
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+async def get_lora_info(lora_name):
+    """Get the lora path and trigger words from cache"""
+    scanner = await LoraScanner.get_instance()
+    cache = await scanner.get_cached_data()
+    
+    for item in cache.raw_data:
+        if item.get('file_name') == lora_name:
+            file_path = item.get('file_path')
+            if file_path:
+                for root in config.loras_roots:
+                    root = root.replace(os.sep, '/')
+                    if file_path.startswith(root):
+                        relative_path = os.path.relpath(file_path, root).replace(os.sep, '/')
+                        # Get trigger words from civitai metadata
+                        civitai = item.get('civitai', {})
+                        trigger_words = civitai.get('trainedWords', []) if civitai else []
+                        return relative_path, trigger_words
+    return lora_name, []  # Fallback if not found
+
+def extract_lora_name(lora_path):
+    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
+    # Get the basename without extension
+    basename = os.path.basename(lora_path)
+    return os.path.splitext(basename)[0]
+
+def get_loras_list(kwargs):
+    """Helper to extract loras list from either old or new kwargs format"""
+    if 'loras' not in kwargs:
+        return []
+        
+    loras_data = kwargs['loras']
+    # Handle new format: {'loras': {'__value__': [...]}}
+    if isinstance(loras_data, dict) and '__value__' in loras_data:
+        return loras_data['__value__']
+    # Handle old format: {'loras': [...]}
+    elif isinstance(loras_data, list):
+        return loras_data
+    # Unexpected format
+    else:
+        logger.warning(f"Unexpected loras format: {type(loras_data)}")
+        return []

py/routes/api_routes.py

@@ -3,8 +3,10 @@ import json
 import logging
 from aiohttp import web
 from typing import Dict
+from server import PromptServer # type: ignore
 
 from ..utils.routes_common import ModelRouteUtils
+from ..nodes.utils import get_lora_info
 
 from ..config import config
 from ..services.websocket_manager import ws_manager
@@ -41,6 +43,7 @@ class ApiRoutes:
         app.on_startup.append(lambda _: routes.initialize_services())
         
         app.router.add_post('/api/delete_model', routes.delete_model)
+        app.router.add_post('/api/loras/exclude', routes.exclude_model)  # Add new exclude endpoint
         app.router.add_post('/api/fetch-civitai', routes.fetch_civitai)
         app.router.add_post('/api/replace_preview', routes.replace_preview)
         app.router.add_get('/api/loras', routes.get_loras)
@@ -50,10 +53,9 @@ class ApiRoutes:
         app.router.add_get('/api/lora-roots', routes.get_lora_roots)
         app.router.add_get('/api/folders', routes.get_folders)
         app.router.add_get('/api/civitai/versions/{model_id}', routes.get_civitai_versions)
-        app.router.add_get('/api/civitai/model/{modelVersionId}', routes.get_civitai_model)
-        app.router.add_get('/api/civitai/model/{hash}', routes.get_civitai_model)
+        app.router.add_get('/api/civitai/model/version/{modelVersionId}', routes.get_civitai_model_by_version)
+        app.router.add_get('/api/civitai/model/hash/{hash}', routes.get_civitai_model_by_hash)
         app.router.add_post('/api/download-lora', routes.download_lora)
-        app.router.add_post('/api/settings', routes.update_settings)
         app.router.add_post('/api/move_model', routes.move_model)
         app.router.add_get('/api/lora-model-description', routes.get_lora_model_description)  # Add new route
         app.router.add_post('/api/loras/save-metadata', routes.save_metadata)
@@ -64,6 +66,12 @@ class ApiRoutes:
         app.router.add_get('/api/lora-civitai-url', routes.get_lora_civitai_url)  # Add new route for Civitai URL
         app.router.add_post('/api/rename_lora', routes.rename_lora)  # Add new route for renaming LoRA files
         app.router.add_get('/api/loras/scan', routes.scan_loras)  # Add new route for scanning LoRA files
+        
+        # Add the new trigger words route
+        app.router.add_post('/loramanager/get_trigger_words', routes.get_trigger_words)
+
+        # Add new endpoint for letter counts
+        app.router.add_get('/api/loras/letter-counts', routes.get_letter_counts)
 
         # Add update check routes
         UpdateRoutes.setup_routes(app)
@@ -74,6 +82,12 @@ class ApiRoutes:
             self.scanner = await ServiceRegistry.get_lora_scanner()
         return await ModelRouteUtils.handle_delete_model(request, self.scanner)
 
+    async def exclude_model(self, request: web.Request) -> web.Response:
+        """Handle model exclusion request"""
+        if self.scanner is None:
+            self.scanner = await ServiceRegistry.get_lora_scanner()
+        return await ModelRouteUtils.handle_exclude_model(request, self.scanner)
+
     async def fetch_civitai(self, request: web.Request) -> web.Response:
         """Handle CivitAI metadata fetch request"""
         if self.scanner is None:
@@ -120,6 +134,10 @@ class ApiRoutes:
             # Get filter parameters
             base_models = request.query.get('base_models', None)
             tags = request.query.get('tags', None)
+            favorites_only = request.query.get('favorites_only', 'false').lower() == 'true'  # New parameter
+            
+            # New parameter for alphabet filtering
+            first_letter = request.query.get('first_letter', None)
             
             # New parameters for recipe filtering
             lora_hash = request.query.get('lora_hash', None)
@@ -150,7 +168,9 @@ class ApiRoutes:
                 base_models=filters.get('base_model', None),
                 tags=filters.get('tags', None),
                 search_options=search_options,
-                hash_filters=hash_filters
+                hash_filters=hash_filters,
+                favorites_only=favorites_only,  # Pass favorites_only parameter
+                first_letter=first_letter  # Pass the new first_letter parameter
             )
 
             # Get all available folders from cache
@@ -190,6 +210,7 @@ class ApiRoutes:
             "from_civitai": lora.get("from_civitai", True),
             "usage_tips": lora.get("usage_tips", ""),
             "notes": lora.get("notes", ""),
+            "favorite": lora.get("favorite", False),  # Include favorite status in response
             "civitai": ModelRouteUtils.filter_civitai_data(lora.get("civitai", {}))
         }
 
@@ -226,7 +247,7 @@ class ApiRoutes:
                 target_width=CARD_PREVIEW_WIDTH,
                 format='webp',
                 quality=85,
-                preserve_metadata=True
+                preserve_metadata=False
             )
             extension = '.webp'  # Use .webp without .preview part
         
@@ -396,25 +417,52 @@ class ApiRoutes:
             logger.error(f"Error fetching model versions: {e}")
             return web.Response(status=500, text=str(e))
         
-    async def get_civitai_model(self, request: web.Request) -> web.Response:
-        """Get CivitAI model details by model version ID or hash"""
+    async def get_civitai_model_by_version(self, request: web.Request) -> web.Response:
+        """Get CivitAI model details by model version ID"""
         try:
             if self.civitai_client is None:
                 self.civitai_client = await ServiceRegistry.get_civitai_client()
                 
             model_version_id = request.match_info.get('modelVersionId')
-            if not model_version_id:
-                hash = request.match_info.get('hash')
-                model = await self.civitai_client.get_model_by_hash(hash)
-                return web.json_response(model)
             
             # Get model details from Civitai API    
-            model = await self.civitai_client.get_model_version_info(model_version_id)
+            model, error_msg = await self.civitai_client.get_model_version_info(model_version_id)
+            
+            if not model:
+                # Log warning for failed model retrieval
+                logger.warning(f"Failed to fetch model version {model_version_id}: {error_msg}")
+                
+                # Determine status code based on error message
+                status_code = 404 if error_msg and "not found" in error_msg.lower() else 500
+                
+                return web.json_response({
+                    "success": False,
+                    "error": error_msg or "Failed to fetch model information"
+                }, status=status_code)
+                
             return web.json_response(model)
         except Exception as e:
             logger.error(f"Error fetching model details: {e}")
-            return web.Response(status=500, text=str(e))
-    
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+
+    async def get_civitai_model_by_hash(self, request: web.Request) -> web.Response:
+        """Get CivitAI model details by hash"""
+        try:
+            if self.civitai_client is None:
+                self.civitai_client = await ServiceRegistry.get_civitai_client()
+                
+            hash = request.match_info.get('hash')
+            model = await self.civitai_client.get_model_by_hash(hash)
+            return web.json_response(model)
+        except Exception as e:
+            logger.error(f"Error fetching model details by hash: {e}")
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
 
     async def download_lora(self, request: web.Request) -> web.Response:
         async with self._download_lock:
@@ -480,21 +528,6 @@ class ApiRoutes:
                 logger.error(f"Error downloading LoRA: {error_message}")
                 return web.Response(status=500, text=error_message)
 
-    async def update_settings(self, request: web.Request) -> web.Response:
-        """Update application settings"""
-        try:
-            data = await request.json()
-            
-            # Validate and update settings
-            if 'civitai_api_key' in data:
-                settings.set('civitai_api_key', data['civitai_api_key'])
-            if 'show_only_sfw' in data:
-                settings.set('show_only_sfw', data['show_only_sfw'])
-            
-            return web.json_response({'success': True})
-        except Exception as e:
-            logger.error(f"Error updating settings: {e}", exc_info=True)
-            return web.Response(status=500, text=str(e))
 
     async def move_model(self, request: web.Request) -> web.Response:
         """Handle model move request"""
@@ -762,20 +795,23 @@ class ApiRoutes:
             # Check if we already have the description stored in metadata
             description = None
             tags = []
+            creator = {}
             if file_path:
                 metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
                 metadata = await ModelRouteUtils.load_local_metadata(metadata_path)
                 description = metadata.get('modelDescription')
                 tags = metadata.get('tags', [])
+                creator = metadata.get('creator', {})
             
             # If description is not in metadata, fetch from CivitAI
             if not description:
                 logger.info(f"Fetching model metadata for model ID: {model_id}")
                 model_metadata, _ = await self.civitai_client.get_model_metadata(model_id)
                 
-                if model_metadata:
+                if (model_metadata):
                     description = model_metadata.get('description')
                     tags = model_metadata.get('tags', [])
+                    creator = model_metadata.get('creator', {})
                 
                     # Save the metadata to file if we have a file path and got metadata
                     if file_path:
@@ -785,6 +821,7 @@ class ApiRoutes:
                             
                             metadata['modelDescription'] = description
                             metadata['tags'] = tags
+                            metadata['creator'] = creator
                             
                             with open(metadata_path, 'w', encoding='utf-8') as f:
                                 json.dump(metadata, f, indent=2, ensure_ascii=False)
@@ -795,7 +832,8 @@ class ApiRoutes:
             return web.json_response({
                 'success': True,
                 'description': description or "<p>No model description available.</p>",
-                'tags': tags
+                'tags': tags,
+                'creator': creator
             })
             
         except Exception as e:
@@ -994,4 +1032,55 @@ class ApiRoutes:
             return web.json_response({
                 'success': False,
                 'error': str(e)
-            }, status=500)
+            }, status=500)
+
+    async def get_trigger_words(self, request: web.Request) -> web.Response:
+        """Get trigger words for specified LoRA models"""
+        try:
+            json_data = await request.json()
+            lora_names = json_data.get("lora_names", [])
+            node_ids = json_data.get("node_ids", [])
+            
+            all_trigger_words = []
+            for lora_name in lora_names:
+                _, trigger_words = await get_lora_info(lora_name)
+                all_trigger_words.extend(trigger_words)
+            
+            # Format the trigger words
+            trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+            
+            # Send update to all connected trigger word toggle nodes
+            for node_id in node_ids:
+                PromptServer.instance.send_sync("trigger_word_update", {
+                    "id": node_id,
+                    "message": trigger_words_text
+                })
+            
+            return web.json_response({"success": True})
+
+        except Exception as e:
+            logger.error(f"Error getting trigger words: {e}")
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+
+    async def get_letter_counts(self, request: web.Request) -> web.Response:
+        """Get count of loras for each letter of the alphabet"""
+        try:
+            if self.scanner is None:
+                self.scanner = await ServiceRegistry.get_lora_scanner()
+                
+            # Get letter counts
+            letter_counts = await self.scanner.get_letter_counts()
+            
+            return web.json_response({
+                'success': True,
+                'letter_counts': letter_counts
+            })
+        except Exception as e:
+            logger.error(f"Error getting letter counts: {e}")
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/routes/checkpoints_routes.py

@@ -49,6 +49,7 @@ class CheckpointsRoutes:
         
         # Add new routes for model management similar to LoRA routes
         app.router.add_post('/api/checkpoints/delete', self.delete_model)
+        app.router.add_post('/api/checkpoints/exclude', self.exclude_model)  # Add new exclude endpoint
         app.router.add_post('/api/checkpoints/fetch-civitai', self.fetch_civitai)
         app.router.add_post('/api/checkpoints/replace-preview', self.replace_preview)
         app.router.add_post('/api/checkpoints/download', self.download_checkpoint)
@@ -69,6 +70,7 @@ class CheckpointsRoutes:
             fuzzy_search = request.query.get('fuzzy_search', 'false').lower() == 'true'
             base_models = request.query.getall('base_model', [])
             tags = request.query.getall('tag', [])
+            favorites_only = request.query.get('favorites_only', 'false').lower() == 'true'  # Add favorites_only parameter
             
             # Process search options
             search_options = {
@@ -101,7 +103,8 @@ class CheckpointsRoutes:
                 base_models=base_models,
                 tags=tags,
                 search_options=search_options,
-                hash_filters=hash_filters
+                hash_filters=hash_filters,
+                favorites_only=favorites_only  # Pass favorites_only parameter
             )
             
             # Format response items
@@ -123,7 +126,8 @@ class CheckpointsRoutes:
     async def get_paginated_data(self, page, page_size, sort_by='name', 
                                folder=None, search=None, fuzzy_search=False,
                                base_models=None, tags=None,
-                               search_options=None, hash_filters=None):
+                               search_options=None, hash_filters=None,
+                               favorites_only=False):  # Add favorites_only parameter with default False
         """Get paginated and filtered checkpoint data"""
         cache = await self.scanner.get_cached_data()
 
@@ -181,6 +185,13 @@ class CheckpointsRoutes:
                 if not cp.get('preview_nsfw_level') or cp.get('preview_nsfw_level') < NSFW_LEVELS['R']
             ]
         
+        # Apply favorites filtering if enabled
+        if favorites_only:
+            filtered_data = [
+                cp for cp in filtered_data
+                if cp.get('favorite', False) is True
+            ]
+        
         # Apply folder filtering
         if folder is not None:
             if search_options.get('recursive', False):
@@ -276,6 +287,7 @@ class CheckpointsRoutes:
             "from_civitai": checkpoint.get("from_civitai", True),
             "notes": checkpoint.get("notes", ""),
             "model_type": checkpoint.get("model_type", "checkpoint"),
+            "favorite": checkpoint.get("favorite", False),
             "civitai": ModelRouteUtils.filter_civitai_data(checkpoint.get("civitai", {}))
         }
     
@@ -488,6 +500,10 @@ class CheckpointsRoutes:
     async def delete_model(self, request: web.Request) -> web.Response:
         """Handle checkpoint model deletion request"""
         return await ModelRouteUtils.handle_delete_model(request, self.scanner)
+
+    async def exclude_model(self, request: web.Request) -> web.Response:
+        """Handle checkpoint model exclusion request"""
+        return await ModelRouteUtils.handle_exclude_model(request, self.scanner)
     
     async def fetch_civitai(self, request: web.Request) -> web.Response:
         """Handle CivitAI metadata fetch request for checkpoints"""
@@ -642,7 +658,7 @@ class CheckpointsRoutes:
             model_type = response.get('type', '')
             
             # Check model type - should be Checkpoint
-            if model_type.lower() != 'checkpoint':
+            if (model_type.lower() != 'checkpoint'):
                 return web.json_response({
                     'error': f"Model type mismatch. Expected Checkpoint, got {model_type}"
                 }, status=400)

py/routes/misc_routes.py

@@ -0,0 +1,767 @@
+import logging
+import os
+import asyncio
+import json
+import time
+import aiohttp
+from aiohttp import web
+from ..services.settings_manager import settings
+from ..utils.usage_stats import UsageStats
+from ..services.service_registry import ServiceRegistry
+from ..utils.exif_utils import ExifUtils
+from ..utils.constants import EXAMPLE_IMAGE_WIDTH, SUPPORTED_MEDIA_EXTENSIONS
+from ..services.civitai_client import CivitaiClient
+from ..utils.routes_common import ModelRouteUtils
+
+logger = logging.getLogger(__name__)
+
+# Download status tracking
+download_task = None
+is_downloading = False
+download_progress = {
+    'total': 0,
+    'completed': 0,
+    'current_model': '',
+    'status': 'idle',  # idle, running, paused, completed, error
+    'errors': [],
+    'last_error': None,
+    'start_time': None,
+    'end_time': None,
+    'processed_models': set(),  # Track models that have been processed
+    'refreshed_models': set()  # Track models that had metadata refreshed
+}
+
+class MiscRoutes:
+    """Miscellaneous routes for various utility functions"""
+    
+    @staticmethod
+    def setup_routes(app):
+        """Register miscellaneous routes"""
+        app.router.add_post('/api/settings', MiscRoutes.update_settings)
+
+        # Usage stats routes
+        app.router.add_post('/api/update-usage-stats', MiscRoutes.update_usage_stats)
+        app.router.add_get('/api/get-usage-stats', MiscRoutes.get_usage_stats)
+        
+        # Example images download routes
+        app.router.add_post('/api/download-example-images', MiscRoutes.download_example_images)
+        app.router.add_get('/api/example-images-status', MiscRoutes.get_example_images_status)
+        app.router.add_post('/api/pause-example-images', MiscRoutes.pause_example_images)
+        app.router.add_post('/api/resume-example-images', MiscRoutes.resume_example_images)
+        
+    @staticmethod
+    async def update_settings(request):
+        """Update application settings"""
+        try:
+            data = await request.json()
+            
+            # Validate and update settings
+            for key, value in data.items():
+                # Special handling for example_images_path - verify path exists
+                if key == 'example_images_path' and value:
+                    if not os.path.exists(value):
+                        return web.json_response({
+                            'success': False,
+                            'error': f"Path does not exist: {value}"
+                        })
+                    
+                    # Path changed - server restart required for new path to take effect
+                    old_path = settings.get('example_images_path')
+                    if old_path != value:
+                        logger.info(f"Example images path changed to {value} - server restart required")
+                
+                # Save to settings
+                settings.set(key, value)
+            
+            return web.json_response({'success': True})
+        except Exception as e:
+            logger.error(f"Error updating settings: {e}", exc_info=True)
+            return web.Response(status=500, text=str(e))
+    
+    @staticmethod
+    async def update_usage_stats(request):
+        """
+        Update usage statistics based on a prompt_id
+        
+        Expects a JSON body with:
+        {
+            "prompt_id": "string"
+        }
+        """
+        try:
+            # Parse the request body
+            data = await request.json()
+            prompt_id = data.get('prompt_id')
+            
+            if not prompt_id:
+                return web.json_response({
+                    'success': False,
+                    'error': 'Missing prompt_id'
+                }, status=400)
+            
+            # Call the UsageStats to process this prompt_id synchronously
+            usage_stats = UsageStats()
+            await usage_stats.process_execution(prompt_id)
+            
+            return web.json_response({
+                'success': True
+            })
+            
+        except Exception as e:
+            logger.error(f"Failed to update usage stats: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+    
+    @staticmethod
+    async def get_usage_stats(request):
+        """Get current usage statistics"""
+        try:
+            usage_stats = UsageStats()
+            stats = await usage_stats.get_stats()
+            
+            return web.json_response({
+                'success': True,
+                'data': stats
+            })
+            
+        except Exception as e:
+            logger.error(f"Failed to get usage stats: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+    
+    @staticmethod
+    async def download_example_images(request):
+        """
+        Download example images for models from Civitai
+        
+        Expects a JSON body with:
+        {
+            "output_dir": "path/to/output",  # Base directory to save example images
+            "optimize": true,                # Whether to optimize images (default: true)
+            "model_types": ["lora", "checkpoint"], # Model types to process (default: both)
+            "delay": 1.0                     # Delay between downloads to avoid rate limiting (default: 1.0)
+        }
+        """
+        global download_task, is_downloading, download_progress
+        
+        if is_downloading:
+            # Create a copy for JSON serialization
+            response_progress = download_progress.copy()
+            response_progress['processed_models'] = list(download_progress['processed_models'])
+            response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
+            
+            return web.json_response({
+                'success': False,
+                'error': 'Download already in progress',
+                'status': response_progress
+            }, status=400)
+        
+        try:
+            # Parse the request body
+            data = await request.json()
+            output_dir = data.get('output_dir')
+            optimize = data.get('optimize', True)
+            model_types = data.get('model_types', ['lora', 'checkpoint'])
+            delay = float(data.get('delay', 0.2))
+            
+            if not output_dir:
+                return web.json_response({
+                    'success': False,
+                    'error': 'Missing output_dir parameter'
+                }, status=400)
+            
+            # Create the output directory
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Initialize progress tracking
+            download_progress['total'] = 0
+            download_progress['completed'] = 0
+            download_progress['current_model'] = ''
+            download_progress['status'] = 'running'
+            download_progress['errors'] = []
+            download_progress['last_error'] = None
+            download_progress['start_time'] = time.time()
+            download_progress['end_time'] = None
+            
+            # Get the processed models list from a file if it exists
+            progress_file = os.path.join(output_dir, '.download_progress.json')
+            if os.path.exists(progress_file):
+                try:
+                    with open(progress_file, 'r', encoding='utf-8') as f:
+                        saved_progress = json.load(f)
+                        download_progress['processed_models'] = set(saved_progress.get('processed_models', []))
+                        logger.info(f"Loaded previous progress, {len(download_progress['processed_models'])} models already processed")
+                except Exception as e:
+                    logger.error(f"Failed to load progress file: {e}")
+                    download_progress['processed_models'] = set()
+            else:
+                download_progress['processed_models'] = set()
+            
+            # Start the download task
+            is_downloading = True
+            download_task = asyncio.create_task(
+                MiscRoutes._download_all_example_images(
+                    output_dir, 
+                    optimize, 
+                    model_types,
+                    delay
+                )
+            )
+            
+            # Create a copy for JSON serialization
+            response_progress = download_progress.copy()
+            response_progress['processed_models'] = list(download_progress['processed_models'])
+            response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
+            
+            return web.json_response({
+                'success': True,
+                'message': 'Download started',
+                'status': response_progress
+            })
+            
+        except Exception as e:
+            logger.error(f"Failed to start example images download: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
+    @staticmethod
+    async def get_example_images_status(request):
+        """Get the current status of example images download"""
+        global download_progress
+        
+        # Create a copy of the progress dict with the set converted to a list for JSON serialization
+        response_progress = download_progress.copy()
+        response_progress['processed_models'] = list(download_progress['processed_models'])
+        response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
+        
+        return web.json_response({
+            'success': True,
+            'is_downloading': is_downloading,
+            'status': response_progress
+        })
+
+    @staticmethod
+    async def pause_example_images(request):
+        """Pause the example images download"""
+        global download_progress
+        
+        if not is_downloading:
+            return web.json_response({
+                'success': False,
+                'error': 'No download in progress'
+            }, status=400)
+        
+        download_progress['status'] = 'paused'
+        
+        return web.json_response({
+            'success': True,
+            'message': 'Download paused'
+        })
+
+    @staticmethod
+    async def resume_example_images(request):
+        """Resume the example images download"""
+        global download_progress
+        
+        if not is_downloading:
+            return web.json_response({
+                'success': False,
+                'error': 'No download in progress'
+            }, status=400)
+        
+        if download_progress['status'] == 'paused':
+            download_progress['status'] = 'running'
+            
+            return web.json_response({
+                'success': True,
+                'message': 'Download resumed'
+            })
+        else:
+            return web.json_response({
+                'success': False,
+                'error': f"Download is in '{download_progress['status']}' state, cannot resume"
+            }, status=400)
+
+    @staticmethod
+    async def _refresh_model_metadata(model_hash, model_name, scanner_type, scanner):
+        """Refresh model metadata from CivitAI
+        
+        Args:
+            model_hash: SHA256 hash of the model
+            model_name: Name of the model (for logging)
+            scanner_type: Type of scanner ('lora' or 'checkpoint')
+            scanner: Scanner instance for this model type
+            
+        Returns:
+            bool: True if metadata was successfully refreshed, False otherwise
+        """
+        global download_progress
+        
+        try:
+            # Find the model in the scanner cache
+            cache = await scanner.get_cached_data()
+            model_data = None
+            
+            for item in cache.raw_data:
+                if item.get('sha256') == model_hash:
+                    model_data = item
+                    break
+            
+            if not model_data:
+                logger.warning(f"Model {model_name} with hash {model_hash} not found in cache")
+                return False
+            
+            file_path = model_data.get('file_path')
+            if not file_path:
+                logger.warning(f"Model {model_name} has no file path")
+                return False
+            
+            # Track that we're refreshing this model
+            download_progress['refreshed_models'].add(model_hash)
+            
+            # Use ModelRouteUtils to refresh the metadata
+            async def update_cache_func(old_path, new_path, metadata):
+                return await scanner.update_single_model_cache(old_path, new_path, metadata)
+            
+            success = await ModelRouteUtils.fetch_and_update_model(
+                model_hash, 
+                file_path, 
+                model_data,
+                update_cache_func
+            )
+            
+            if success:
+                logger.info(f"Successfully refreshed metadata for {model_name}")
+                return True
+            else:
+                logger.warning(f"Failed to refresh metadata for {model_name}")
+                return False
+                
+        except Exception as e:
+            error_msg = f"Error refreshing metadata for {model_name}: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            download_progress['errors'].append(error_msg)
+            download_progress['last_error'] = error_msg
+            return False
+    
+    @staticmethod
+    async def _process_model_images(model_hash, model_name, model_images, model_dir, optimize, independent_session, delay):
+        """Process and download images for a single model
+        
+        Args:
+            model_hash: SHA256 hash of the model
+            model_name: Name of the model
+            model_images: List of image objects from CivitAI
+            model_dir: Directory to save images to
+            optimize: Whether to optimize images
+            independent_session: aiohttp session for downloads
+            delay: Delay between downloads
+            
+        Returns:
+            bool: True if all images were processed successfully, False otherwise
+        """
+        global download_progress
+        
+        model_success = True
+        
+        for i, image in enumerate(model_images, 1):
+            image_url = image.get('url')
+            if not image_url:
+                continue
+            
+            # Get image filename from URL
+            image_filename = os.path.basename(image_url.split('?')[0])
+            image_ext = os.path.splitext(image_filename)[1].lower()
+            
+            # Handle both images and videos
+            is_image = image_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
+            is_video = image_ext in SUPPORTED_MEDIA_EXTENSIONS['videos']
+            
+            if not (is_image or is_video):
+                logger.debug(f"Skipping unsupported file type: {image_filename}")
+                continue
+            
+            save_filename = f"image_{i}{image_ext}"
+            
+            # Check if already downloaded
+            save_path = os.path.join(model_dir, save_filename)
+            if os.path.exists(save_path):
+                logger.debug(f"File already exists: {save_path}")
+                continue
+            
+            # Download the file
+            try:
+                logger.debug(f"Downloading {save_filename} for {model_name}")
+                
+                # Direct download using the independent session
+                async with independent_session.get(image_url, timeout=60) as response:
+                    if response.status == 200:
+                        if is_image and optimize:
+                            # For images, optimize if requested
+                            image_data = await response.read()
+                            optimized_data, ext = ExifUtils.optimize_image(
+                                image_data, 
+                                target_width=EXAMPLE_IMAGE_WIDTH, 
+                                format='webp', 
+                                quality=85, 
+                                preserve_metadata=False
+                            )
+                            
+                            # Update save filename if format changed
+                            if ext == '.webp':
+                                save_filename = os.path.splitext(save_filename)[0] + '.webp'
+                                save_path = os.path.join(model_dir, save_filename)
+                            
+                            # Save the optimized image
+                            with open(save_path, 'wb') as f:
+                                f.write(optimized_data)
+                        else:
+                            # For videos or unoptimized images, save directly
+                            with open(save_path, 'wb') as f:
+                                async for chunk in response.content.iter_chunked(8192):
+                                    if chunk:
+                                        f.write(chunk)
+                    elif response.status == 404:
+                        error_msg = f"Failed to download file: {image_url}, status code: 404 - Model metadata might be stale"
+                        logger.warning(error_msg)
+                        download_progress['errors'].append(error_msg)
+                        download_progress['last_error'] = error_msg
+                        model_success = False  # Mark model as failed due to 404
+                        # Return early to trigger metadata refresh attempt
+                        return False, True  # (success, is_stale_metadata)
+                    else:
+                        error_msg = f"Failed to download file: {image_url}, status code: {response.status}"
+                        logger.warning(error_msg)
+                        download_progress['errors'].append(error_msg)
+                        download_progress['last_error'] = error_msg
+                        model_success = False  # Mark model as failed
+                
+                # Add a delay between downloads for remote files only
+                await asyncio.sleep(delay)
+            except Exception as e:
+                error_msg = f"Error downloading file {image_url}: {str(e)}"
+                logger.error(error_msg)
+                download_progress['errors'].append(error_msg)
+                download_progress['last_error'] = error_msg
+                model_success = False  # Mark model as failed
+        
+        return model_success, False  # (success, is_stale_metadata)
+    
+    @staticmethod
+    async def _process_local_example_images(model_file_path, model_file_name, model_name, model_dir, optimize):
+        """Process local example images for a model
+        
+        Args:
+            model_file_path: Path to the model file
+            model_file_name: Filename of the model
+            model_name: Name of the model
+            model_dir: Directory to save processed images to
+            optimize: Whether to optimize images
+            
+        Returns:
+            bool: True if local images were processed successfully, False otherwise
+        """
+        global download_progress
+        
+        try:
+            model_dir_path = os.path.dirname(model_file_path)
+            local_images = []
+            
+            # Look for files with pattern: filename.example.*.ext
+            if model_file_name:
+                example_prefix = f"{model_file_name}.example."
+                
+                if os.path.exists(model_dir_path):
+                    for file in os.listdir(model_dir_path):
+                        file_lower = file.lower()
+                        if file_lower.startswith(example_prefix.lower()):
+                            file_ext = os.path.splitext(file_lower)[1]
+                            is_supported = (file_ext in SUPPORTED_MEDIA_EXTENSIONS['images'] or 
+                                           file_ext in SUPPORTED_MEDIA_EXTENSIONS['videos'])
+                            
+                            if is_supported:
+                                local_images.append(os.path.join(model_dir_path, file))
+            
+            # Process local images if found
+            if local_images:
+                logger.info(f"Found {len(local_images)} local example images for {model_name}")
+                
+                for i, local_image_path in enumerate(local_images, 1):
+                    local_ext = os.path.splitext(local_image_path)[1].lower()
+                    save_filename = f"image_{i}{local_ext}"
+                    save_path = os.path.join(model_dir, save_filename)
+                    
+                    # Skip if already exists in output directory
+                    if os.path.exists(save_path):
+                        logger.debug(f"File already exists in output: {save_path}")
+                        continue
+                    
+                    # Handle image processing based on file type and optimize setting
+                    is_image = local_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
+                    
+                    if is_image and optimize:
+                        # Optimize the image
+                        with open(local_image_path, 'rb') as img_file:
+                            image_data = img_file.read()
+                        
+                        optimized_data, ext = ExifUtils.optimize_image(
+                            image_data, 
+                            target_width=EXAMPLE_IMAGE_WIDTH, 
+                            format='webp', 
+                            quality=85, 
+                            preserve_metadata=False
+                        )
+                        
+                        # Update save filename if format changed
+                        if ext == '.webp':
+                            save_filename = os.path.splitext(save_filename)[0] + '.webp'
+                            save_path = os.path.join(model_dir, save_filename)
+                        
+                        # Save the optimized image
+                        with open(save_path, 'wb') as f:
+                            f.write(optimized_data)
+                    else:
+                        # For videos or unoptimized images, copy directly
+                        with open(local_image_path, 'rb') as src_file:
+                            with open(save_path, 'wb') as dst_file:
+                                dst_file.write(src_file.read())
+                
+                return True
+            return False
+        except Exception as e:
+            error_msg = f"Error processing local examples for {model_name}: {str(e)}"
+            logger.error(error_msg)
+            download_progress['errors'].append(error_msg)
+            download_progress['last_error'] = error_msg
+            return False
+
+    @staticmethod
+    async def _download_all_example_images(output_dir, optimize, model_types, delay):
+        """Download example images for all models
+        
+        Args:
+            output_dir: Base directory to save example images
+            optimize: Whether to optimize images
+            model_types: List of model types to process
+            delay: Delay between downloads to avoid rate limiting
+        """
+        global is_downloading, download_progress
+        
+        # Create an independent session for downloading example images
+        # This avoids interference with the CivitAI client's session
+        connector = aiohttp.TCPConnector(
+            ssl=True,
+            limit=3,
+            force_close=False,
+            enable_cleanup_closed=True
+        )
+        timeout = aiohttp.ClientTimeout(total=None, connect=60, sock_read=60)
+        
+        # Create a dedicated session just for this download task
+        independent_session = aiohttp.ClientSession(
+            connector=connector,
+            trust_env=True,
+            timeout=timeout
+        )
+        
+        try:
+            # Get the scanners
+            scanners = []
+            if 'lora' in model_types:
+                lora_scanner = await ServiceRegistry.get_lora_scanner()
+                scanners.append(('lora', lora_scanner))
+            
+            if 'checkpoint' in model_types:
+                checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
+                scanners.append(('checkpoint', checkpoint_scanner))
+            
+            # Get all models from all scanners
+            all_models = []
+            for scanner_type, scanner in scanners:
+                cache = await scanner.get_cached_data()
+                if cache and cache.raw_data:
+                    for model in cache.raw_data:
+                        # Only process models with images and a valid sha256
+                        if model.get('civitai') and model.get('civitai', {}).get('images') and model.get('sha256'):
+                            all_models.append((scanner_type, model, scanner))
+            
+            # Update total count
+            download_progress['total'] = len(all_models)
+            logger.info(f"Found {download_progress['total']} models with example images")
+            
+            # Process each model
+            for scanner_type, model, scanner in all_models:
+                # Check if download is paused
+                while download_progress['status'] == 'paused':
+                    await asyncio.sleep(1)
+                
+                # Check if download should continue
+                if download_progress['status'] != 'running':
+                    logger.info(f"Download stopped: {download_progress['status']}")
+                    break
+                
+                model_hash = model.get('sha256', '').lower()
+                model_name = model.get('model_name', 'Unknown')
+                model_file_path = model.get('file_path', '')
+                model_file_name = model.get('file_name', '')
+                
+                try:
+                    # Update current model info
+                    download_progress['current_model'] = f"{model_name} ({model_hash[:8]})"
+                    
+                    # Skip if already processed
+                    if model_hash in download_progress['processed_models']:
+                        logger.debug(f"Skipping already processed model: {model_name}")
+                        download_progress['completed'] += 1
+                        continue
+                    
+                    # Create model directory
+                    model_dir = os.path.join(output_dir, model_hash)
+                    os.makedirs(model_dir, exist_ok=True)
+                    
+                    # Process images for this model
+                    images = model.get('civitai', {}).get('images', [])
+                    
+                    if not images:
+                        logger.debug(f"No images found for model: {model_name}")
+                        download_progress['processed_models'].add(model_hash)
+                        download_progress['completed'] += 1
+                        continue
+                    
+                    # First check if we have local example images for this model
+                    local_images_processed = False
+                    if model_file_path:
+                        local_images_processed = await MiscRoutes._process_local_example_images(
+                            model_file_path, 
+                            model_file_name, 
+                            model_name, 
+                            model_dir, 
+                            optimize
+                        )
+                        
+                        if local_images_processed:
+                            # Mark as successfully processed if all local images were processed
+                            download_progress['processed_models'].add(model_hash)
+                            logger.info(f"Successfully processed local examples for {model_name}")
+                    
+                    # If we didn't process local images, download from remote
+                    if not local_images_processed:
+                        # Try to download images
+                        model_success, is_stale_metadata = await MiscRoutes._process_model_images(
+                            model_hash, 
+                            model_name, 
+                            images, 
+                            model_dir, 
+                            optimize, 
+                            independent_session, 
+                            delay
+                        )
+                        
+                        # If metadata is stale (404 error), try to refresh it and download again
+                        if is_stale_metadata and model_hash not in download_progress['refreshed_models']:
+                            logger.info(f"Metadata seems stale for {model_name}, attempting to refresh...")
+                            
+                            # Refresh metadata from CivitAI
+                            refresh_success = await MiscRoutes._refresh_model_metadata(
+                                model_hash, 
+                                model_name, 
+                                scanner_type, 
+                                scanner
+                            )
+                            
+                            if refresh_success:
+                                # Get updated model data
+                                updated_cache = await scanner.get_cached_data()
+                                updated_model = None
+                                
+                                for item in updated_cache.raw_data:
+                                    if item.get('sha256') == model_hash:
+                                        updated_model = item
+                                        break
+                                
+                                if updated_model and updated_model.get('civitai', {}).get('images'):
+                                    # Try downloading with updated metadata
+                                    logger.info(f"Retrying download with refreshed metadata for {model_name}")
+                                    updated_images = updated_model.get('civitai', {}).get('images', [])
+                                    
+                                    # Retry download with new images
+                                    model_success, _ = await MiscRoutes._process_model_images(
+                                        model_hash, 
+                                        model_name, 
+                                        updated_images, 
+                                        model_dir, 
+                                        optimize, 
+                                        independent_session, 
+                                        delay
+                                    )
+                        
+                        # Only mark model as processed if all images downloaded successfully
+                        if model_success:
+                            download_progress['processed_models'].add(model_hash)
+                        else:
+                            logger.warning(f"Model {model_name} had download errors, will not mark as completed")
+                    
+                    # Save progress to file periodically
+                    if download_progress['completed'] % 10 == 0 or download_progress['completed'] == download_progress['total'] - 1:
+                        progress_file = os.path.join(output_dir, '.download_progress.json')
+                        with open(progress_file, 'w', encoding='utf-8') as f:
+                            json.dump({
+                                'processed_models': list(download_progress['processed_models']),
+                                'refreshed_models': list(download_progress['refreshed_models']),
+                                'completed': download_progress['completed'],
+                                'total': download_progress['total'],
+                                'last_update': time.time()
+                            }, f, indent=2)
+                
+                except Exception as e:
+                    error_msg = f"Error processing model {model.get('model_name')}: {str(e)}"
+                    logger.error(error_msg, exc_info=True)
+                    download_progress['errors'].append(error_msg)
+                    download_progress['last_error'] = error_msg
+                
+                # Update progress
+                download_progress['completed'] += 1
+            
+            # Mark as completed
+            download_progress['status'] = 'completed'
+            download_progress['end_time'] = time.time()
+            logger.info(f"Example images download completed: {download_progress['completed']}/{download_progress['total']} models processed")
+        
+        except Exception as e:
+            error_msg = f"Error during example images download: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            download_progress['errors'].append(error_msg)
+            download_progress['last_error'] = error_msg
+            download_progress['status'] = 'error'
+            download_progress['end_time'] = time.time()
+        
+        finally:
+            # Close the independent session
+            try:
+                await independent_session.close()
+            except Exception as e:
+                logger.error(f"Error closing download session: {e}")
+                
+            # Save final progress to file
+            try:
+                progress_file = os.path.join(output_dir, '.download_progress.json')
+                with open(progress_file, 'w', encoding='utf-8') as f:
+                    json.dump({
+                        'processed_models': list(download_progress['processed_models']),
+                        'refreshed_models': list(download_progress['refreshed_models']),
+                        'completed': download_progress['completed'],
+                        'total': download_progress['total'],
+                        'last_update': time.time(),
+                        'status': download_progress['status']
+                    }, f, indent=2)
+            except Exception as e:
+                logger.error(f"Failed to save progress file: {e}")
+            
+            # Set download status to not downloading
+            is_downloading = False

py/routes/recipe_routes.py

@@ -1,20 +1,35 @@
 import os
 import time
+import numpy as np
+from PIL import Image
+import torch
+import io
 import logging
 from aiohttp import web
 from typing import Dict
 import tempfile
 import json
 import asyncio
+import sys
 from ..utils.exif_utils import ExifUtils
 from ..utils.recipe_parsers import RecipeParserFactory
 from ..utils.constants import CARD_PREVIEW_WIDTH
 
 from ..config import config
-from ..workflow.parser import WorkflowParser
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
 from ..utils.utils import download_civitai_image
 from ..services.service_registry import ServiceRegistry  # Add ServiceRegistry import
 
+# Only import MetadataRegistry in non-standalone mode
+if not standalone_mode:
+    # Import metadata_collector functions and classes conditionally
+    from ..metadata_collector import get_metadata  # Add MetadataCollector import
+    from ..metadata_collector.metadata_processor import MetadataProcessor  # Add MetadataProcessor import
+    from ..metadata_collector.metadata_registry import MetadataRegistry
+
 logger = logging.getLogger(__name__)
 
 class RecipeRoutes:
@@ -24,7 +39,7 @@ class RecipeRoutes:
         # Initialize service references as None, will be set during async init
         self.recipe_scanner = None
         self.civitai_client = None
-        self.parser = WorkflowParser()
+        # Remove WorkflowParser instance
         
         # Pre-warm the cache
         self._init_cache_task = None
@@ -68,6 +83,9 @@ class RecipeRoutes:
         
         # Add route to get recipes for a specific Lora
         app.router.add_get('/api/recipes/for-lora', routes.get_recipes_for_lora)
+        
+        # Add new endpoint for scanning and rebuilding the recipe cache
+        app.router.add_get('/api/recipes/scan', routes.scan_recipes)
     
     async def _init_cache(self, app):
         """Initialize cache on startup"""
@@ -656,8 +674,8 @@ class RecipeRoutes:
             logger.error(f"Error retrieving base models: {e}", exc_info=True)
             return web.json_response({
                 'success': False,
-                'error': str(e)
-            }, status=500) 
+                'error': str(e)}
+            , status=500) 
 
     async def share_recipe(self, request: web.Request) -> web.Response:
         """Process a recipe image for sharing by adding metadata to EXIF"""
@@ -786,50 +804,75 @@ class RecipeRoutes:
             # Ensure services are initialized
             await self.init_services()
             
-            reader = await request.multipart()
+            # Get metadata using the metadata collector instead of workflow parsing
+            raw_metadata = get_metadata()
+            metadata_dict = MetadataProcessor.to_dict(raw_metadata)
             
-            # Process form data
-            workflow_json = None
+            # Check if we have valid metadata
+            if not metadata_dict:
+                return web.json_response({"error": "No generation metadata found"}, status=400)
             
-            while True:
-                field = await reader.next()
-                if field is None:
-                    break
+            # Get the most recent image from metadata registry instead of temp directory
+            if not standalone_mode:
+                metadata_registry = MetadataRegistry()
+                latest_image = metadata_registry.get_first_decoded_image()
+            else:
+                latest_image = None
+            
+            if not latest_image:
+                return web.json_response({"error": "No recent images found to use for recipe. Try generating an image first."}, status=400)
+            
+            # Convert the image data to bytes - handle tuple and tensor cases
+            logger.debug(f"Image type: {type(latest_image)}")
+            
+            try:
+                # Handle the tuple case first
+                if isinstance(latest_image, tuple):
+                    # Extract the tensor from the tuple
+                    if len(latest_image) > 0:
+                        tensor_image = latest_image[0]
+                    else:
+                        return web.json_response({"error": "Empty image tuple received"}, status=400)
+                else:
+                    tensor_image = latest_image
                 
-                if field.name == 'workflow_json':
-                    workflow_text = await field.text()
-                    try:
-                        workflow_json = json.loads(workflow_text)
-                    except:
-                        return web.json_response({"error": "Invalid workflow JSON"}, status=400)
+                # Get the shape info for debugging
+                if hasattr(tensor_image, 'shape'):
+                    shape_info = tensor_image.shape
+                    logger.debug(f"Tensor shape: {shape_info}, dtype: {tensor_image.dtype}")
+                
+                # Convert tensor to numpy array
+                if isinstance(tensor_image, torch.Tensor):
+                    image_np = tensor_image.cpu().numpy()
+                else:
+                    image_np = np.array(tensor_image)
+                
+                # Handle different tensor shapes
+                # Case: (1, 1, H, W, 3) or (1, H, W, 3) - batch or multi-batch
+                if len(image_np.shape) > 3:
+                    # Remove batch dimensions until we get to (H, W, 3)
+                    while len(image_np.shape) > 3:
+                        image_np = image_np[0]
+                
+                # If values are in [0, 1] range, convert to [0, 255]
+                if image_np.dtype == np.float32 or image_np.dtype == np.float64:
+                    if image_np.max() <= 1.0:
+                        image_np = (image_np * 255).astype(np.uint8)
+                
+                # Ensure image is in the right format (HWC with RGB channels)
+                if len(image_np.shape) == 3 and image_np.shape[2] == 3:
+                    pil_image = Image.fromarray(image_np)
+                    img_byte_arr = io.BytesIO()
+                    pil_image.save(img_byte_arr, format='PNG')
+                    image = img_byte_arr.getvalue()
+                else:
+                    return web.json_response({"error": f"Cannot handle this data shape: {image_np.shape}, {image_np.dtype}"}, status=400)
+            except Exception as e:
+                logger.error(f"Error processing image data: {str(e)}", exc_info=True)
+                return web.json_response({"error": f"Error processing image: {str(e)}"}, status=400)
             
-            if not workflow_json:
-                return web.json_response({"error": "Missing workflow JSON"}, status=400)
-            
-            # Find the latest image in the temp directory
-            temp_dir = config.temp_directory
-            image_files = []
-            
-            for file in os.listdir(temp_dir):
-                if file.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-                    file_path = os.path.join(temp_dir, file)
-                    image_files.append((file_path, os.path.getmtime(file_path)))
-            
-            if not image_files:
-                return web.json_response({"error": "No recent images found to use for recipe"}, status=400)
-            
-            # Sort by modification time (newest first)
-            image_files.sort(key=lambda x: x[1], reverse=True)
-            latest_image_path = image_files[0][0]
-            
-            # Parse the workflow to extract generation parameters and loras
-            parsed_workflow = self.parser.parse_workflow(workflow_json)
-
-            if not parsed_workflow:
-                return web.json_response({"error": "Could not extract parameters from workflow"}, status=400)
-            
-            # Get the lora stack from the parsed workflow
-            lora_stack = parsed_workflow.get("loras", "")
+            # Get the lora stack from the metadata
+            lora_stack = metadata_dict.get("loras", "")
             
             # Parse the lora stack format: "<lora:name:strength> <lora:name2:strength2> ..."
             import re
@@ -837,7 +880,7 @@ class RecipeRoutes:
             
             # Check if any loras were found
             if not lora_matches:
-                return web.json_response({"error": "No LoRAs found in the workflow"}, status=400)
+                return web.json_response({"error": "No LoRAs found in the generation metadata"}, status=400)
             
             # Generate recipe name from the first 3 loras (or less if fewer are available)
             loras_for_name = lora_matches[:3]  # Take at most 3 loras for the name
@@ -851,10 +894,6 @@ class RecipeRoutes:
             
             recipe_name = " ".join(recipe_name_parts)
             
-            # Read the image
-            with open(latest_image_path, 'rb') as f:
-                image = f.read()
-            
             # Create recipes directory if it doesn't exist
             recipes_dir = self.recipe_scanner.recipes_dir
             os.makedirs(recipes_dir, exist_ok=True)
@@ -922,8 +961,8 @@ class RecipeRoutes:
                 "created_date": time.time(),
                 "base_model": most_common_base_model,
                 "loras": loras_data,
-                "checkpoint": parsed_workflow.get("checkpoint", ""),
-                "gen_params": {key: value for key, value in parsed_workflow.items() 
+                "checkpoint": metadata_dict.get("checkpoint", ""),
+                "gen_params": {key: value for key, value in metadata_dict.items() 
                                if key not in ['checkpoint', 'loras']},
                 "loras_stack": lora_stack  # Include the original lora stack string
             }
@@ -1231,3 +1270,24 @@ class RecipeRoutes:
         except Exception as e:
             logger.error(f"Error getting recipes for Lora: {str(e)}")
             return web.json_response({'success': False, 'error': str(e)}, status=500)
+
+    async def scan_recipes(self, request: web.Request) -> web.Response:
+        """API endpoint for scanning and rebuilding the recipe cache"""
+        try:
+            # Ensure services are initialized
+            await self.init_services()
+            
+            # Force refresh the recipe cache
+            logger.info("Manually triggering recipe cache rebuild")
+            await self.recipe_scanner.get_cached_data(force_refresh=True)
+            
+            return web.json_response({
+                'success': True,
+                'message': 'Recipe cache refreshed successfully'
+            })
+        except Exception as e:
+            logger.error(f"Error refreshing recipe cache: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/routes/update_routes.py

@@ -150,11 +150,16 @@ class UpdateRoutes:
         """
         Compare two semantic version strings
         Returns True if version2 is newer than version1
+        Ignores any suffixes after '-' (e.g., -bugfix, -alpha)
         """
         try:
+            # Clean version strings - remove any suffix after '-'
+            v1_clean = version1.split('-')[0]
+            v2_clean = version2.split('-')[0]
+            
             # Split versions into components
-            v1_parts = [int(x) for x in version1.split('.')]
-            v2_parts = [int(x) for x in version2.split('.')]
+            v1_parts = [int(x) for x in v1_clean.split('.')]
+            v2_parts = [int(x) for x in v2_clean.split('.')]
             
             # Ensure both have 3 components (major.minor.patch)
             while len(v1_parts) < 3:

py/server_routes.py

@@ -0,0 +1,26 @@
+from aiohttp import web
+from server import PromptServer
+from .nodes.utils import get_lora_info
+
+@PromptServer.instance.routes.post("/loramanager/get_trigger_words")
+async def get_trigger_words(request):
+    json_data = await request.json()
+    lora_names = json_data.get("lora_names", [])
+    node_ids = json_data.get("node_ids", [])
+    
+    all_trigger_words = []
+    for lora_name in lora_names:
+        _, trigger_words = await get_lora_info(lora_name)
+        all_trigger_words.extend(trigger_words)
+    
+    # Format the trigger words
+    trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+    
+    # Send update to all connected trigger word toggle nodes
+    for node_id in node_ids:
+        PromptServer.instance.send_sync("trigger_word_update", {
+            "id": node_id,
+            "message": trigger_words_text
+        })
+    
+    return web.json_response({"success": True})

py/services/civitai_client.py

@@ -34,6 +34,7 @@ class CivitaiClient:
             'User-Agent': 'ComfyUI-LoRA-Manager/1.0'
         }
         self._session = None
+        self._session_created_at = None
         # Set default buffer size to 1MB for higher throughput
         self.chunk_size = 1024 * 1024
     
@@ -44,8 +45,8 @@ class CivitaiClient:
             # Optimize TCP connection parameters
             connector = aiohttp.TCPConnector(
                 ssl=True,
-                limit=10,  # Increase parallel connections
-                ttl_dns_cache=300,  # DNS cache time
+                limit=3,  # Further reduced from 5 to 3
+                ttl_dns_cache=0,  # Disabled DNS caching completely
                 force_close=False,  # Keep connections for reuse
                 enable_cleanup_closed=True
             )
@@ -57,7 +58,18 @@ class CivitaiClient:
                 trust_env=trust_env,
                 timeout=timeout
             )
+            self._session_created_at = datetime.now()
         return self._session
+    
+    async def _ensure_fresh_session(self):
+        """Refresh session if it's been open too long"""
+        if self._session is not None:
+            if not hasattr(self, '_session_created_at') or \
+               (datetime.now() - self._session_created_at).total_seconds() > 300:  # 5 minutes
+                await self.close()
+                self._session = None
+        
+        return await self.session
 
     def _parse_content_disposition(self, header: str) -> str:
         """Parse filename from content-disposition header"""
@@ -103,13 +115,15 @@ class CivitaiClient:
         Returns:
             Tuple[bool, str]: (success, save_path or error message)
         """
-        session = await self.session
+        logger.debug(f"Resolving DNS for: {url}")
+        session = await self._ensure_fresh_session()
         try:
             headers = self._get_request_headers()
             
             # Add Range header to allow resumable downloads
             headers['Accept-Encoding'] = 'identity'  # Disable compression for better chunked downloads
             
+            logger.debug(f"Starting download from: {url}")
             async with session.get(url, headers=headers, allow_redirects=True) as response:
                 if response.status != 200:
                     # Handle 401 unauthorized responses
@@ -124,6 +138,7 @@ class CivitaiClient:
                         return False, "Access forbidden: You don't have permission to download this file."
                     
                     # Generic error response for other status codes
+                    logger.error(f"Download failed for {url} with status {response.status}")
                     return False, f"Download failed with status {response.status}"
 
                 # Get filename from content-disposition header
@@ -170,7 +185,7 @@ class CivitaiClient:
 
     async def get_model_by_hash(self, model_hash: str) -> Optional[Dict]:
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             async with session.get(f"{self.base_url}/model-versions/by-hash/{model_hash}") as response:
                 if response.status == 200:
                     return await response.json()
@@ -181,7 +196,7 @@ class CivitaiClient:
 
     async def download_preview_image(self, image_url: str, save_path: str):
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             async with session.get(image_url) as response:
                 if response.status == 200:
                     content = await response.read()
@@ -196,7 +211,7 @@ class CivitaiClient:
     async def get_model_versions(self, model_id: str) -> List[Dict]:
         """Get all versions of a model with local availability info"""
         try:
-            session = await self.session  # 等待获取 session
+            session = await self._ensure_fresh_session()  # Use fresh session
             async with session.get(f"{self.base_url}/models/{model_id}") as response:
                 if response.status != 200:
                     return None
@@ -210,23 +225,49 @@ class CivitaiClient:
             logger.error(f"Error fetching model versions: {e}")
             return None
 
-    async def get_model_version_info(self, version_id: str) -> Optional[Dict]:
-        """Fetch model version metadata from Civitai"""
+    async def get_model_version_info(self, version_id: str) -> Tuple[Optional[Dict], Optional[str]]:
+        """Fetch model version metadata from Civitai
+        
+        Args:
+            version_id: The Civitai model version ID
+            
+        Returns:
+            Tuple[Optional[Dict], Optional[str]]: A tuple containing:
+                - The model version data or None if not found
+                - An error message if there was an error, or None on success
+        """
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             url = f"{self.base_url}/model-versions/{version_id}"
             headers = self._get_request_headers()
             
+            logger.debug(f"Resolving DNS for model version info: {url}")
             async with session.get(url, headers=headers) as response:
                 if response.status == 200:
-                    return await response.json()
-                return None
+                    logger.debug(f"Successfully fetched model version info for: {version_id}")
+                    return await response.json(), None
+                
+                # Handle specific error cases
+                if response.status == 404:
+                    # Try to parse the error message
+                    try:
+                        error_data = await response.json()
+                        error_msg = error_data.get('error', f"Model not found (status 404)")
+                        logger.warning(f"Model version not found: {version_id} - {error_msg}")
+                        return None, error_msg
+                    except:
+                        return None, "Model not found (status 404)"
+                
+                # Other error cases
+                logger.error(f"Failed to fetch model info for {version_id} (status {response.status})")
+                return None, f"Failed to fetch model info (status {response.status})"
         except Exception as e:
-            logger.error(f"Error fetching model version info: {e}")
-            return None
+            error_msg = f"Error fetching model version info: {e}"
+            logger.error(error_msg)
+            return None, error_msg
 
     async def get_model_metadata(self, model_id: str) -> Tuple[Optional[Dict], int]:
-        """Fetch model metadata (description and tags) from Civitai API
+        """Fetch model metadata (description, tags, and creator info) from Civitai API
         
         Args:
             model_id: The Civitai model ID
@@ -237,7 +278,7 @@ class CivitaiClient:
                 - The HTTP status code from the request
         """
         try:
-            session = await self.session
+            session = await self._ensure_fresh_session()
             headers = self._get_request_headers()
             url = f"{self.base_url}/models/{model_id}"
             
@@ -253,10 +294,14 @@ class CivitaiClient:
                 # Extract relevant metadata
                 metadata = {
                     "description": data.get("description") or "No model description available",
-                    "tags": data.get("tags", [])
+                    "tags": data.get("tags", []),
+                    "creator": {
+                        "username": data.get("creator", {}).get("username"),
+                        "image": data.get("creator", {}).get("image")
+                    }
                 }
                 
-                if metadata["description"] or metadata["tags"]:
+                if metadata["description"] or metadata["tags"] or metadata["creator"]["username"]:
                     return metadata, status_code
                 else:
                     logger.warning(f"No metadata found for model {model_id}")
@@ -281,10 +326,11 @@ class CivitaiClient:
     async def _get_hash_from_civitai(self, model_version_id: str) -> Optional[str]:
         """Get hash from Civitai API"""
         try:
-            if not self._session:
+            session = await self._ensure_fresh_session()
+            if not session:
                 return None
             
-            version_info = await self._session.get(f"{self.base_url}/model-versions/{model_version_id}")
+            version_info = await session.get(f"{self.base_url}/model-versions/{model_version_id}")
             
             if not version_info or not version_info.json().get('files'):
                 return None

py/services/download_manager.py

@@ -86,21 +86,24 @@ class DownloadManager:
 
             # Get version info based on the provided identifier
             version_info = None
+            error_msg = None
             
-            if download_url:
-                # Extract version ID from download URL
-                version_id = download_url.split('/')[-1]
-                version_info = await civitai_client.get_model_version_info(version_id)
-            elif model_version_id:
-                # Use model version ID directly
-                version_info = await civitai_client.get_model_version_info(model_version_id)
-            elif model_hash:
+            if model_hash:
                 # Get model by hash
                 version_info = await civitai_client.get_model_by_hash(model_hash)
+            elif model_version_id:
+                # Use model version ID directly
+                version_info, error_msg = await civitai_client.get_model_version_info(model_version_id)
+            elif download_url:
+                # Extract version ID from download URL
+                version_id = download_url.split('/')[-1]
+                version_info, error_msg = await civitai_client.get_model_version_info(version_id)
 
             
             if not version_info:
-                return {'success': False, 'error': 'Failed to fetch model metadata'}
+                if error_msg and "model not found" in error_msg.lower():
+                    return {'success': False, 'error': f'Model not found on Civitai: {error_msg}'}
+                return {'success': False, 'error': error_msg or 'Failed to fetch model metadata'}
 
             # Check if this is an early access model
             if version_info.get('earlyAccessEndsAt'):
@@ -151,7 +154,7 @@ class DownloadManager:
                 metadata = LoraMetadata.from_civitai_info(version_info, file_info, save_path)
                 logger.info(f"Creating LoraMetadata for {file_name}")
             
-            # 5.1 Get and update model tags and description
+            # 5.1 Get and update model tags, description and creator info
             model_id = version_info.get('modelId')
             if model_id:
                 model_metadata, _ = await civitai_client.get_model_metadata(str(model_id))
@@ -160,6 +163,8 @@ class DownloadManager:
                         metadata.tags = model_metadata.get("tags", [])
                     if model_metadata.get("description"):
                         metadata.modelDescription = model_metadata.get("description", "")
+                    if model_metadata.get("creator"):
+                        metadata.civitai["creator"] = model_metadata.get("creator")
             
             # 6. Start download process
             result = await self._execute_download(
@@ -202,7 +207,7 @@ class DownloadManager:
                 # Check if it's a video or an image
                 is_video = images[0].get('type') == 'video'
                 
-                if is_video:
+                if (is_video):
                     # For videos, use .mp4 extension
                     preview_ext = '.mp4'
                     preview_path = os.path.splitext(save_path)[0] + preview_ext
@@ -229,7 +234,7 @@ class DownloadManager:
                             target_width=CARD_PREVIEW_WIDTH,
                             format='webp',
                             quality=85,
-                            preserve_metadata=True
+                            preserve_metadata=False
                         )
                         
                         # Save the optimized image

py/services/file_monitor.py

@@ -408,7 +408,7 @@ class BaseFileMonitor:
     def start(self):
         """Start file monitoring"""
         if not ENABLE_FILE_MONITORING:
-            logger.info("File monitoring is disabled via ENABLE_FILE_MONITORING setting")
+            logger.debug("File monitoring is disabled via ENABLE_FILE_MONITORING setting")
             return
             
         for path in self.monitor_paths:
@@ -525,18 +525,18 @@ class CheckpointFileMonitor(BaseFileMonitor):
     def start(self):
         """Override start to check global enable flag"""
         if not ENABLE_FILE_MONITORING:
-            logger.info("Checkpoint file monitoring is disabled via ENABLE_FILE_MONITORING setting")
+            logger.debug("Checkpoint file monitoring is disabled via ENABLE_FILE_MONITORING setting")
             return
             
-        logger.info("Checkpoint file monitoring is temporarily disabled")
+        logger.debug("Checkpoint file monitoring is temporarily disabled")
         # Skip the actual monitoring setup
         pass
     
     async def initialize_paths(self):
         """Initialize monitor paths from scanner - currently disabled"""
         if not ENABLE_FILE_MONITORING:
-            logger.info("Checkpoint path initialization skipped (monitoring disabled)")
+            logger.debug("Checkpoint path initialization skipped (monitoring disabled)")
             return
             
-        logger.info("Checkpoint file path initialization skipped (monitoring disabled)")
+        logger.debug("Checkpoint file path initialization skipped (monitoring disabled)")
         pass

py/services/lora_scanner.py

@@ -4,12 +4,13 @@ import logging
 import asyncio
 import shutil
 import time
+import re
 from typing import List, Dict, Optional, Set
 
 from ..utils.models import LoraMetadata
 from ..config import config
 from .model_scanner import ModelScanner
-from .lora_hash_index import LoraHashIndex
+from .model_hash_index import ModelHashIndex  # Changed from LoraHashIndex to ModelHashIndex
 from .settings_manager import settings
 from ..utils.constants import NSFW_LEVELS
 from ..utils.utils import fuzzy_match
@@ -35,12 +36,12 @@ class LoraScanner(ModelScanner):
             # Define supported file extensions
             file_extensions = {'.safetensors'}
             
-            # Initialize parent class
+            # Initialize parent class with ModelHashIndex
             super().__init__(
                 model_type="lora",
                 model_class=LoraMetadata, 
                 file_extensions=file_extensions,
-                hash_index=LoraHashIndex()
+                hash_index=ModelHashIndex()  # Changed from LoraHashIndex to ModelHashIndex
             )
             self._initialized = True
     
@@ -122,7 +123,8 @@ class LoraScanner(ModelScanner):
     async def get_paginated_data(self, page: int, page_size: int, sort_by: str = 'name', 
                                folder: str = None, search: str = None, fuzzy_search: bool = False,
                                base_models: list = None, tags: list = None,
-                               search_options: dict = None, hash_filters: dict = None) -> Dict:
+                               search_options: dict = None, hash_filters: dict = None,
+                               favorites_only: bool = False, first_letter: str = None) -> Dict:
         """Get paginated and filtered lora data
         
         Args:
@@ -136,6 +138,8 @@ class LoraScanner(ModelScanner):
             tags: List of tags to filter by
             search_options: Dictionary with search options (filename, modelname, tags, recursive)
             hash_filters: Dictionary with hash filtering options (single_hash or multiple_hashes)
+            favorites_only: Filter for favorite models only
+            first_letter: Filter by first letter of model name
         """
         cache = await self.get_cached_data()
 
@@ -194,6 +198,17 @@ class LoraScanner(ModelScanner):
                 if not lora.get('preview_nsfw_level') or lora.get('preview_nsfw_level') < NSFW_LEVELS['R']
             ]
         
+        # Apply favorites filtering if enabled
+        if favorites_only:
+            filtered_data = [
+                lora for lora in filtered_data
+                if lora.get('favorite', False) is True
+            ]
+            
+        # Apply first letter filtering
+        if first_letter:
+            filtered_data = self._filter_by_first_letter(filtered_data, first_letter)
+        
         # Apply folder filtering
         if folder is not None:
             if search_options.get('recursive', False):
@@ -264,6 +279,101 @@ class LoraScanner(ModelScanner):
         
         return result
 
+    def _filter_by_first_letter(self, data, letter):
+        """Filter data by first letter of model name
+        
+        Special handling:
+        - '#': Numbers (0-9)
+        - '@': Special characters (not alphanumeric)
+        - '漢': CJK characters
+        """
+        filtered_data = []
+        
+        for lora in data:
+            model_name = lora.get('model_name', '')
+            if not model_name:
+                continue
+                
+            first_char = model_name[0].upper()
+            
+            if letter == '#' and first_char.isdigit():
+                filtered_data.append(lora)
+            elif letter == '@' and not first_char.isalnum():
+                # Special characters (not alphanumeric)
+                filtered_data.append(lora)
+            elif letter == '漢' and self._is_cjk_character(first_char):
+                # CJK characters
+                filtered_data.append(lora)
+            elif letter.upper() == first_char:
+                # Regular alphabet matching
+                filtered_data.append(lora)
+                
+        return filtered_data
+    
+    def _is_cjk_character(self, char):
+        """Check if character is a CJK character"""
+        # Define Unicode ranges for CJK characters
+        cjk_ranges = [
+            (0x4E00, 0x9FFF),   # CJK Unified Ideographs
+            (0x3400, 0x4DBF),   # CJK Unified Ideographs Extension A
+            (0x20000, 0x2A6DF), # CJK Unified Ideographs Extension B
+            (0x2A700, 0x2B73F), # CJK Unified Ideographs Extension C
+            (0x2B740, 0x2B81F), # CJK Unified Ideographs Extension D
+            (0x2B820, 0x2CEAF), # CJK Unified Ideographs Extension E
+            (0x2CEB0, 0x2EBEF), # CJK Unified Ideographs Extension F
+            (0x30000, 0x3134F), # CJK Unified Ideographs Extension G
+            (0xF900, 0xFAFF),   # CJK Compatibility Ideographs
+            (0x3300, 0x33FF),   # CJK Compatibility
+            (0x3200, 0x32FF),   # Enclosed CJK Letters and Months
+            (0x3100, 0x312F),   # Bopomofo
+            (0x31A0, 0x31BF),   # Bopomofo Extended
+            (0x3040, 0x309F),   # Hiragana
+            (0x30A0, 0x30FF),   # Katakana
+            (0x31F0, 0x31FF),   # Katakana Phonetic Extensions
+            (0xAC00, 0xD7AF),   # Hangul Syllables
+            (0x1100, 0x11FF),   # Hangul Jamo
+            (0xA960, 0xA97F),   # Hangul Jamo Extended-A
+            (0xD7B0, 0xD7FF),   # Hangul Jamo Extended-B
+        ]
+        
+        code_point = ord(char)
+        return any(start <= code_point <= end for start, end in cjk_ranges)
+    
+    async def get_letter_counts(self):
+        """Get count of models for each letter of the alphabet"""
+        cache = await self.get_cached_data()
+        data = cache.sorted_by_name
+        
+        # Define letter categories
+        letters = {
+            '#': 0,  # Numbers
+            'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 0,
+            'I': 0, 'J': 0, 'K': 0, 'L': 0, 'M': 0, 'N': 0, 'O': 0, 'P': 0,
+            'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 0, 'V': 0, 'W': 0, 'X': 0,
+            'Y': 0, 'Z': 0,
+            '@': 0,  # Special characters
+            '漢': 0   # CJK characters
+        }
+        
+        # Count models for each letter
+        for lora in data:
+            model_name = lora.get('model_name', '')
+            if not model_name:
+                continue
+                
+            first_char = model_name[0].upper()
+            
+            if first_char.isdigit():
+                letters['#'] += 1
+            elif first_char in letters:
+                letters[first_char] += 1
+            elif self._is_cjk_character(first_char):
+                letters['漢'] += 1
+            elif not first_char.isalnum():
+                letters['@'] += 1
+                
+        return letters
+
     async def _update_metadata_paths(self, metadata_path: str, lora_path: str) -> Dict:
         """Update file paths in metadata file"""
         try:

py/services/model_hash_index.py

@@ -1,11 +1,12 @@
 from typing import Dict, Optional, Set
+import os
 
 class ModelHashIndex:
     """Index for looking up models by hash or path"""
     
     def __init__(self):
         self._hash_to_path: Dict[str, str] = {}
-        self._path_to_hash: Dict[str, str] = {}
+        self._filename_to_hash: Dict[str, str] = {}  # Changed from path_to_hash to filename_to_hash
     
     def add_entry(self, sha256: str, file_path: str) -> None:
         """Add or update hash index entry"""
@@ -15,37 +16,47 @@ class ModelHashIndex:
         # Ensure hash is lowercase for consistency
         sha256 = sha256.lower()
         
+        # Extract filename without extension
+        filename = self._get_filename_from_path(file_path)
+        
         # Remove old path mapping if hash exists
         if sha256 in self._hash_to_path:
             old_path = self._hash_to_path[sha256]
-            if old_path in self._path_to_hash:
-                del self._path_to_hash[old_path]
+            old_filename = self._get_filename_from_path(old_path)
+            if old_filename in self._filename_to_hash:
+                del self._filename_to_hash[old_filename]
         
-        # Remove old hash mapping if path exists
-        if file_path in self._path_to_hash:
-            old_hash = self._path_to_hash[file_path]
+        # Remove old hash mapping if filename exists
+        if filename in self._filename_to_hash:
+            old_hash = self._filename_to_hash[filename]
             if old_hash in self._hash_to_path:
                 del self._hash_to_path[old_hash]
         
         # Add new mappings
         self._hash_to_path[sha256] = file_path
-        self._path_to_hash[file_path] = sha256
+        self._filename_to_hash[filename] = sha256
+    
+    def _get_filename_from_path(self, file_path: str) -> str:
+        """Extract filename without extension from path"""
+        return os.path.splitext(os.path.basename(file_path))[0]
     
     def remove_by_path(self, file_path: str) -> None:
         """Remove entry by file path"""
-        if file_path in self._path_to_hash:
-            hash_val = self._path_to_hash[file_path]
+        filename = self._get_filename_from_path(file_path)
+        if filename in self._filename_to_hash:
+            hash_val = self._filename_to_hash[filename]
             if hash_val in self._hash_to_path:
                 del self._hash_to_path[hash_val]
-            del self._path_to_hash[file_path]
+            del self._filename_to_hash[filename]
     
     def remove_by_hash(self, sha256: str) -> None:
         """Remove entry by hash"""
         sha256 = sha256.lower()
         if sha256 in self._hash_to_path:
             path = self._hash_to_path[sha256]
-            if path in self._path_to_hash:
-                del self._path_to_hash[path]
+            filename = self._get_filename_from_path(path)
+            if filename in self._filename_to_hash:
+                del self._filename_to_hash[filename]
             del self._hash_to_path[sha256]
     
     def has_hash(self, sha256: str) -> bool:
@@ -58,20 +69,27 @@ class ModelHashIndex:
     
     def get_hash(self, file_path: str) -> Optional[str]:
         """Get hash for a file path"""
-        return self._path_to_hash.get(file_path)
+        filename = self._get_filename_from_path(file_path)
+        return self._filename_to_hash.get(filename)
+    
+    def get_hash_by_filename(self, filename: str) -> Optional[str]:
+        """Get hash for a filename without extension"""
+        # Strip extension if present to make the function more flexible
+        filename = os.path.splitext(filename)[0]
+        return self._filename_to_hash.get(filename)
     
     def clear(self) -> None:
         """Clear all entries"""
         self._hash_to_path.clear()
-        self._path_to_hash.clear()
+        self._filename_to_hash.clear()
     
     def get_all_hashes(self) -> Set[str]:
         """Get all hashes in the index"""
         return set(self._hash_to_path.keys())
     
-    def get_all_paths(self) -> Set[str]:
-        """Get all file paths in the index"""
-        return set(self._path_to_hash.keys())
+    def get_all_filenames(self) -> Set[str]:
+        """Get all filenames in the index"""
+        return set(self._filename_to_hash.keys())
     
     def __len__(self) -> int:
         """Get number of entries"""

py/services/model_scanner.py

@@ -38,6 +38,7 @@ class ModelScanner:
         self._hash_index = hash_index or ModelHashIndex()
         self._tags_count = {}  # Dictionary to store tag counts
         self._is_initializing = False  # Flag to track initialization state
+        self._excluded_models = []  # List to track excluded models
         
         # Register this service
         asyncio.create_task(self._register_service())
@@ -292,7 +293,7 @@ class ModelScanner:
             )
 
         # If force refresh is requested, initialize the cache directly
-        if force_refresh:
+        if (force_refresh):
             if self._cache is None:
                 # For initial creation, do a full initialization
                 await self._initialize_cache()
@@ -394,6 +395,9 @@ class ModelScanner:
                             if file_path in cached_paths:
                                 found_paths.add(file_path)
                                 continue
+
+                            if file_path in self._excluded_models:
+                                continue
                                 
                             # Try case-insensitive match on Windows
                             if os.name == 'nt':
@@ -406,7 +410,7 @@ class ModelScanner:
                                         break
                                 if matched:
                                     continue
-                            
+                                
                             # This is a new file to process
                             new_files.append(file_path)
                     
@@ -553,12 +557,44 @@ class ModelScanner:
                         logger.debug(f"Created metadata from .civitai.info for {file_path}")
                 except Exception as e:
                     logger.error(f"Error creating metadata from .civitai.info for {file_path}: {e}")
+        else:
+            # Check if metadata exists but civitai field is empty - try to restore from civitai.info
+            if metadata.civitai is None or metadata.civitai == {}:
+                civitai_info_path = f"{os.path.splitext(file_path)[0]}.civitai.info"
+                if os.path.exists(civitai_info_path):
+                    try:
+                        with open(civitai_info_path, 'r', encoding='utf-8') as f:
+                            version_info = json.load(f)
+                        
+                        logger.debug(f"Restoring missing civitai data from .civitai.info for {file_path}")
+                        metadata.civitai = version_info
+                        
+                        # Ensure tags are also updated if they're missing
+                        if (not metadata.tags or len(metadata.tags) == 0) and 'model' in version_info:
+                            if 'tags' in version_info['model']:
+                                metadata.tags = version_info['model']['tags']
+                        
+                        # Also restore description if missing
+                        if (not metadata.modelDescription or metadata.modelDescription == "") and 'model' in version_info:
+                            if 'description' in version_info['model']:
+                                metadata.modelDescription = version_info['model']['description']
+                        
+                        # Save the updated metadata
+                        await save_metadata(file_path, metadata)
+                        logger.debug(f"Updated metadata with civitai info for {file_path}")
+                    except Exception as e:
+                        logger.error(f"Error restoring civitai data from .civitai.info for {file_path}: {e}")
             
-            if metadata is None:
-                metadata = await self._get_file_info(file_path)
+        if metadata is None:
+            metadata = await self._get_file_info(file_path)
         
         model_data = metadata.to_dict()
         
+        # Skip excluded models
+        if model_data.get('exclude', False):
+            self._excluded_models.append(model_data['file_path'])
+            return None
+            
         await self._fetch_missing_metadata(file_path, model_data)
         rel_path = os.path.relpath(file_path, root_path)
         folder = os.path.dirname(rel_path)
@@ -583,7 +619,10 @@ class ModelScanner:
                     model_id = str(model_id)
                     tags_missing = not model_data.get('tags') or len(model_data.get('tags', [])) == 0
                     desc_missing = not model_data.get('modelDescription') or model_data.get('modelDescription') in (None, "")
-                    needs_metadata_update = tags_missing or desc_missing
+                    # TODO: not for now, but later we should check if the creator is missing
+                    # creator_missing = not model_data.get('civitai', {}).get('creator')
+                    creator_missing = False
+                    needs_metadata_update = tags_missing or desc_missing or creator_missing
             
             if needs_metadata_update and model_id:
                 logger.debug(f"Fetching missing metadata for {file_path} with model ID {model_id}")
@@ -609,6 +648,8 @@ class ModelScanner:
                     
                     if model_metadata.get('description') and (not model_data.get('modelDescription') or model_data.get('modelDescription') in (None, "")):
                         model_data['modelDescription'] = model_metadata['description']
+
+                    model_data['civitai']['creator'] = model_metadata['creator']
                     
                     metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
                     with open(metadata_path, 'w', encoding='utf-8') as f:
@@ -709,6 +750,12 @@ class ModelScanner:
                 shutil.move(source_metadata, target_metadata)
                 metadata = await self._update_metadata_paths(target_metadata, target_file)
             
+            # Move civitai.info file if exists
+            source_civitai = os.path.join(source_dir, f"{base_name}.civitai.info")
+            if os.path.exists(source_civitai):
+                target_civitai = os.path.join(target_path, f"{base_name}.civitai.info")
+                shutil.move(source_civitai, target_civitai)
+            
             for ext in PREVIEW_EXTENSIONS:
                 source_preview = os.path.join(source_dir, f"{base_name}{ext}")
                 if os.path.exists(source_preview):
@@ -805,6 +852,10 @@ class ModelScanner:
     def get_hash_by_path(self, file_path: str) -> Optional[str]:
         """Get hash for a model by its file path"""
         return self._hash_index.get_hash(file_path)
+        
+    def get_hash_by_filename(self, filename: str) -> Optional[str]:
+        """Get hash for a model by its filename without path"""
+        return self._hash_index.get_hash_by_filename(filename)
 
     # TODO: Adjust this method to use metadata instead of finding the file    
     def get_preview_url_by_hash(self, sha256: str) -> Optional[str]:
@@ -863,6 +914,10 @@ class ModelScanner:
             logger.error(f"Error getting model info by name: {e}", exc_info=True)
             return None
         
+    def get_excluded_models(self) -> List[str]:
+        """Get list of excluded model file paths"""
+        return self._excluded_models.copy()
+
     async def update_preview_in_cache(self, file_path: str, preview_url: str) -> bool:
         """Update preview URL in cache for a specific lora
         
@@ -876,4 +931,4 @@ class ModelScanner:
         if self._cache is None:
             return False
 
-        return await self._cache.update_preview_url(file_path, preview_url)
+        return await self._cache.update_preview_url(file_path, preview_url)

py/services/recipe_scanner.py

@@ -341,6 +341,10 @@ class RecipeScanner:
         metadata_updated = False
         
         for lora in recipe_data['loras']:
+            # Skip deleted loras that were already marked
+            if lora.get('isDeleted', False):
+                continue
+                
             # Skip if already has complete information
             if 'hash' in lora and 'file_name' in lora and lora['file_name']:
                 continue
@@ -356,10 +360,17 @@ class RecipeScanner:
                     metadata_updated = True
                 else:
                     # If not in cache, fetch from Civitai
-                    hash_from_civitai = await self._get_hash_from_civitai(model_version_id)
-                    if hash_from_civitai:
-                        lora['hash'] = hash_from_civitai
-                        metadata_updated = True
+                    result = await self._get_hash_from_civitai(model_version_id)
+                    if isinstance(result, tuple):
+                        hash_from_civitai, is_deleted = result
+                        if hash_from_civitai:
+                            lora['hash'] = hash_from_civitai
+                            metadata_updated = True
+                        elif is_deleted:
+                            # Mark the lora as deleted if it was not found on Civitai
+                            lora['isDeleted'] = True
+                            logger.warning(f"Marked lora with modelVersionId {model_version_id} as deleted")
+                            metadata_updated = True
                     else:
                         logger.debug(f"Could not get hash for modelVersionId {model_version_id}")
             
@@ -411,41 +422,26 @@ class RecipeScanner:
                 logger.error("Failed to get CivitaiClient from ServiceRegistry")
                 return None
                 
-            version_info = await civitai_client.get_model_version_info(model_version_id)
+            version_info, error_msg = await civitai_client.get_model_version_info(model_version_id)
             
-            if not version_info or not version_info.get('files'):
-                logger.debug(f"No files found in version info for ID: {model_version_id}")
-                return None
-                
+            if not version_info:
+                if error_msg and "model not found" in error_msg.lower():
+                    logger.warning(f"Model with version ID {model_version_id} was not found on Civitai - marking as deleted")
+                    return None, True  # Return None hash and True for isDeleted flag
+                else:
+                    logger.debug(f"Could not get hash for modelVersionId {model_version_id}: {error_msg}")
+                    return None, False  # Return None hash but not marked as deleted
+                    
             # Get hash from the first file
             for file_info in version_info.get('files', []):
                 if file_info.get('hashes', {}).get('SHA256'):
-                    return file_info['hashes']['SHA256']
+                    return file_info['hashes']['SHA256'], False  # Return hash with False for isDeleted flag
                     
             logger.debug(f"No SHA256 hash found in version info for ID: {model_version_id}")
-            return None
+            return None, False
         except Exception as e:
             logger.error(f"Error getting hash from Civitai: {e}")
-            return None
-
-    async def _get_model_version_name(self, model_version_id: str) -> Optional[str]:
-        """Get model version name from Civitai API"""
-        try:
-            # Get CivitaiClient from ServiceRegistry
-            civitai_client = await self._get_civitai_client()
-            if not civitai_client:
-                return None
-                
-            version_info = await civitai_client.get_model_version_info(model_version_id)
-            
-            if version_info and 'name' in version_info:
-                return version_info['name']
-                    
-            logger.debug(f"No version name found for modelVersionId {model_version_id}")
-            return None
-        except Exception as e:
-            logger.error(f"Error getting model version name from Civitai: {e}")
-            return None
+            return None, False
 
     async def _determine_base_model(self, loras: List[Dict]) -> Optional[str]:
         """Determine the most common base model among LoRAs"""

py/utils/constants.py

@@ -11,15 +11,24 @@ NSFW_LEVELS = {
 PREVIEW_EXTENSIONS = [
     '.webp',
     '.preview.webp',
-    '.preview.png', 
-    '.preview.jpeg', 
-    '.preview.jpg', 
+    '.preview.png',
+    '.preview.jpeg',
+    '.preview.jpg',
     '.preview.mp4',
-    '.png', 
-    '.jpeg', 
-    '.jpg', 
+    '.png',
+    '.jpeg',
+    '.jpg',
     '.mp4'
 ]
 
 # Card preview image width
-CARD_PREVIEW_WIDTH = 480
+CARD_PREVIEW_WIDTH = 480
+
+# Width for optimized example images
+EXAMPLE_IMAGE_WIDTH = 832
+
+# Supported media extensions for example downloads
+SUPPORTED_MEDIA_EXTENSIONS = {
+    'images': ['.jpg', '.jpeg', '.png', '.webp', '.gif'],
+    'videos': ['.mp4', '.webm']
+}

py/utils/exif_utils.py

@@ -203,7 +203,7 @@ class ExifUtils:
             return user_comment[:recipe_marker_index] + user_comment[next_line_index:]
             
     @staticmethod
-    def optimize_image(image_data, target_width=250, format='webp', quality=85, preserve_metadata=True):
+    def optimize_image(image_data, target_width=250, format='webp', quality=85, preserve_metadata=False):
         """
         Optimize an image by resizing and converting to WebP format
         
@@ -218,98 +218,144 @@ class ExifUtils:
             Tuple of (optimized_image_data, extension)
         """
         try:
-            # Extract metadata if needed
+            # First validate the image data is usable
+            img = None
+            if isinstance(image_data, str) and os.path.exists(image_data):
+                # It's a file path - validate file
+                try:
+                    with Image.open(image_data) as test_img:
+                        # Verify the image can be fully loaded by accessing its size
+                        width, height = test_img.size
+                    # If we got here, the image is valid
+                    img = Image.open(image_data)
+                except (IOError, OSError) as e:
+                    logger.error(f"Invalid or corrupt image file: {image_data}: {e}")
+                    raise ValueError(f"Cannot process corrupt image: {e}")
+            else:
+                # It's binary data - validate data
+                try:
+                    with BytesIO(image_data) as temp_buf:
+                        test_img = Image.open(temp_buf)
+                        # Verify the image can be fully loaded
+                        width, height = test_img.size
+                    # If successful, reopen for processing
+                    img = Image.open(BytesIO(image_data))
+                except Exception as e:
+                    logger.error(f"Invalid binary image data: {e}")
+                    raise ValueError(f"Cannot process corrupt image data: {e}")
+
+            # Extract metadata if needed and valid
             metadata = None
             if preserve_metadata:
-                if isinstance(image_data, str) and os.path.exists(image_data):
-                    # It's a file path
-                    metadata = ExifUtils.extract_image_metadata(image_data)
-                    img = Image.open(image_data)
-                else:
-                    # It's binary data
-                    temp_img = BytesIO(image_data)
-                    img = Image.open(temp_img)
-                    # Save to a temporary file to extract metadata
-                    import tempfile
-                    with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp_file:
-                        temp_path = temp_file.name
-                        temp_file.write(image_data)
-                    metadata = ExifUtils.extract_image_metadata(temp_path)
-                    os.unlink(temp_path)
-            else:
-                # Just open the image without extracting metadata
-                if isinstance(image_data, str) and os.path.exists(image_data):
-                    img = Image.open(image_data)
-                else:
-                    img = Image.open(BytesIO(image_data))
-            
+                try:
+                    if isinstance(image_data, str) and os.path.exists(image_data):
+                        # For file path, extract directly
+                        metadata = ExifUtils.extract_image_metadata(image_data)
+                    else:
+                        # For binary data, save to temp file first
+                        import tempfile
+                        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp_file:
+                            temp_path = temp_file.name
+                            temp_file.write(image_data)
+                        try:
+                            metadata = ExifUtils.extract_image_metadata(temp_path)
+                        except Exception as e:
+                            logger.warning(f"Failed to extract metadata from temp file: {e}")
+                        finally:
+                            # Clean up temp file
+                            try:
+                                os.unlink(temp_path)
+                            except Exception:
+                                pass
+                except Exception as e:
+                    logger.warning(f"Failed to extract metadata, continuing without it: {e}")
+                    # Continue without metadata
+
             # Calculate new height to maintain aspect ratio
             width, height = img.size
             new_height = int(height * (target_width / width))
             
-            # Resize the image
-            resized_img = img.resize((target_width, new_height), Image.LANCZOS)
+            # Resize the image with error handling
+            try:
+                resized_img = img.resize((target_width, new_height), Image.LANCZOS)
+            except Exception as e:
+                logger.error(f"Failed to resize image: {e}")
+                # Return original image if resize fails
+                return image_data, '.jpg' if not isinstance(image_data, str) else os.path.splitext(image_data)[1]
             
             # Save to BytesIO in the specified format
             output = BytesIO()
             
-            # WebP format
+            # Set format and extension
             if format.lower() == 'webp':
-                resized_img.save(output, format='WEBP', quality=quality)
-                extension = '.webp'
-            # JPEG format
+                save_format, extension = 'WEBP', '.webp'
             elif format.lower() in ('jpg', 'jpeg'):
-                resized_img.save(output, format='JPEG', quality=quality)
-                extension = '.jpg'
-            # PNG format
+                save_format, extension = 'JPEG', '.jpg'
             elif format.lower() == 'png':
-                resized_img.save(output, format='PNG', optimize=True)
-                extension = '.png'
+                save_format, extension = 'PNG', '.png'
             else:
-                # Default to WebP
-                resized_img.save(output, format='WEBP', quality=quality)
-                extension = '.webp'
+                save_format, extension = 'WEBP', '.webp'
+            
+            # Save with error handling
+            try:
+                if save_format == 'PNG':
+                    resized_img.save(output, format=save_format, optimize=True)
+                else:
+                    resized_img.save(output, format=save_format, quality=quality)
+            except Exception as e:
+                logger.error(f"Failed to save optimized image: {e}")
+                # Return original image if save fails
+                return image_data, '.jpg' if not isinstance(image_data, str) else os.path.splitext(image_data)[1]
             
             # Get the optimized image data
             optimized_data = output.getvalue()
             
-            # If we need to preserve metadata, write it to a temporary file
+            # Handle metadata preservation if requested and available
             if preserve_metadata and metadata:
-                # For WebP format, we'll directly save with metadata
-                if format.lower() == 'webp':
-                    # Create a new BytesIO with metadata
-                    output_with_metadata = BytesIO()
-                    
-                    # Create EXIF data with user comment
-                    exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
-                    exif_bytes = piexif.dump(exif_dict)
-                    
-                    # Save with metadata
-                    resized_img.save(output_with_metadata, format='WEBP', exif=exif_bytes, quality=quality)
-                    optimized_data = output_with_metadata.getvalue()
-                else:
-                    # For other formats, use the temporary file approach
-                    import tempfile
-                    with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as temp_file:
-                        temp_path = temp_file.name
-                        temp_file.write(optimized_data)
-                    
-                    # Add the metadata back
-                    ExifUtils.update_image_metadata(temp_path, metadata)
-                    
-                    # Read the file with metadata
-                    with open(temp_path, 'rb') as f:
-                        optimized_data = f.read()
-                    
-                    # Clean up
-                    os.unlink(temp_path)
+                try:
+                    if save_format == 'WEBP':
+                        # For WebP format, directly save with metadata
+                        try:
+                            output_with_metadata = BytesIO()
+                            exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
+                            exif_bytes = piexif.dump(exif_dict)
+                            resized_img.save(output_with_metadata, format='WEBP', exif=exif_bytes, quality=quality)
+                            optimized_data = output_with_metadata.getvalue()
+                        except Exception as e:
+                            logger.warning(f"Failed to add metadata to WebP, continuing without it: {e}")
+                    else:
+                        # For other formats, use temporary file
+                        import tempfile
+                        with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as temp_file:
+                            temp_path = temp_file.name
+                            temp_file.write(optimized_data)
+                        
+                        try:
+                            # Add metadata
+                            ExifUtils.update_image_metadata(temp_path, metadata)
+                            # Read back the file
+                            with open(temp_path, 'rb') as f:
+                                optimized_data = f.read()
+                        except Exception as e:
+                            logger.warning(f"Failed to add metadata to image, continuing without it: {e}")
+                        finally:
+                            # Clean up temp file
+                            try:
+                                os.unlink(temp_path)
+                            except Exception:
+                                pass
+                except Exception as e:
+                    logger.warning(f"Failed to preserve metadata: {e}, continuing with unmodified output")
             
             return optimized_data, extension
             
         except Exception as e:
             logger.error(f"Error optimizing image: {e}", exc_info=True)
-            # Return original data if optimization fails
+            # Return original data if optimization completely fails
             if isinstance(image_data, str) and os.path.exists(image_data):
-                with open(image_data, 'rb') as f:
-                    return f.read(), os.path.splitext(image_data)[1]
+                try:
+                    with open(image_data, 'rb') as f:
+                        return f.read(), os.path.splitext(image_data)[1]
+                except Exception:
+                    return image_data, '.jpg'  # Last resort fallback
             return image_data, '.jpg'

py/utils/file_utils.py

@@ -42,7 +42,7 @@ def find_preview_file(base_name: str, dir_path: str) -> str:
                         target_width=CARD_PREVIEW_WIDTH,
                         format='webp',
                         quality=85,
-                        preserve_metadata=True
+                        preserve_metadata=False  # Changed from True to False
                     )
                     
                     # Save the optimized webp file

py/utils/models.py

@@ -21,6 +21,9 @@ class BaseModelMetadata:
     civitai: Optional[Dict] = None  # Civitai API data if available
     tags: List[str] = None      # Model tags
     modelDescription: str = ""  # Full model description
+    civitai_deleted: bool = False  # Whether deleted from Civitai
+    favorite: bool = False      # Whether the model is a favorite
+    exclude: bool = False       # Whether to exclude this model from the cache
 
     def __post_init__(self):
         # Initialize empty lists to avoid mutable default parameter issue
@@ -64,6 +67,15 @@ class LoraMetadata(BaseModelMetadata):
         file_name = file_info['name']
         base_model = determine_base_model(version_info.get('baseModel', ''))
         
+        # Extract tags and description if available
+        tags = []
+        description = ""
+        if 'model' in version_info:
+            if 'tags' in version_info['model']:
+                tags = version_info['model']['tags']
+            if 'description' in version_info['model']:
+                description = version_info['model']['description']
+        
         return cls(
             file_name=os.path.splitext(file_name)[0],
             model_name=version_info.get('model').get('name', os.path.splitext(file_name)[0]),
@@ -75,7 +87,9 @@ class LoraMetadata(BaseModelMetadata):
             preview_url=None,  # Will be updated after preview download
             preview_nsfw_level=0, # Will be updated after preview download
             from_civitai=True,
-            civitai=version_info
+            civitai=version_info,
+            tags=tags,
+            modelDescription=description
         )
 
 @dataclass
@@ -90,6 +104,15 @@ class CheckpointMetadata(BaseModelMetadata):
         base_model = determine_base_model(version_info.get('baseModel', ''))
         model_type = version_info.get('type', 'checkpoint')
         
+        # Extract tags and description if available
+        tags = []
+        description = ""
+        if 'model' in version_info:
+            if 'tags' in version_info['model']:
+                tags = version_info['model']['tags']
+            if 'description' in version_info['model']:
+                description = version_info['model']['description']
+        
         return cls(
             file_name=os.path.splitext(file_name)[0],
             model_name=version_info.get('model').get('name', os.path.splitext(file_name)[0]),
@@ -102,6 +125,8 @@ class CheckpointMetadata(BaseModelMetadata):
             preview_nsfw_level=0,
             from_civitai=True,
             civitai=version_info,
-            model_type=model_type
+            model_type=model_type,
+            tags=tags,
+            modelDescription=description
         )
 

py/utils/recipe_parsers.py

@@ -45,14 +45,14 @@ class RecipeMetadataParser(ABC):
         """
         pass
     
-    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info: Dict[str, Any], 
+    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info_tuple: Tuple[Dict[str, Any], Optional[str]], 
                                          recipe_scanner=None, base_model_counts=None, hash_value=None) -> Dict[str, Any]:
         """
         Populate a lora entry with information from Civitai API response
         
         Args:
             lora_entry: The lora entry to populate
-            civitai_info: The response from Civitai API
+            civitai_info_tuple: The response tuple from Civitai API (data, error_msg)
             recipe_scanner: Optional recipe scanner for local file lookup
             base_model_counts: Optional dict to track base model counts
             hash_value: Optional hash value to use if not available in civitai_info
@@ -61,6 +61,9 @@ class RecipeMetadataParser(ABC):
             The populated lora_entry dict
         """
         try:
+            # Unpack the tuple to get the actual data
+            civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
+            
             if civitai_info and civitai_info.get("error") != "Model not found":
                 # Check if this is an early access lora
                 if civitai_info.get('earlyAccessEndsAt'):
@@ -94,8 +97,9 @@ class RecipeMetadataParser(ABC):
                 
                 # Process file information if available
                 if 'files' in civitai_info:
+                    # Find the primary model file (type="Model" and primary=true) in the files list
                     model_file = next((file for file in civitai_info.get('files', []) 
-                                    if file.get('type') == 'Model'), None)
+                                      if file.get('type') == 'Model' and file.get('primary') == True), None)
                     
                     if model_file:
                         # Get size
@@ -241,11 +245,11 @@ class RecipeFormatParser(RecipeMetadataParser):
                         # Try to get additional info from Civitai if we have a model version ID
                         if lora.get('modelVersionId') and civitai_client:
                             try:
-                                civitai_info = await civitai_client.get_model_version_info(lora['modelVersionId'])
+                                civitai_info_tuple = await civitai_client.get_model_version_info(lora['modelVersionId'])
                                 # Populate lora entry with Civitai info
                                 lora_entry = await self.populate_lora_from_civitai(
                                     lora_entry, 
-                                    civitai_info, 
+                                    civitai_info_tuple, 
                                     recipe_scanner,
                                     None,  # No need to track base model counts
                                     lora['hash']
@@ -336,12 +340,13 @@ class StandardMetadataParser(RecipeMetadataParser):
                 # Get additional info from Civitai if client is available
                 if civitai_client:
                     try:
-                        civitai_info = await civitai_client.get_model_version_info(model_version_id)
+                        civitai_info_tuple = await civitai_client.get_model_version_info(model_version_id)
                         # Populate lora entry with Civitai info
                         lora_entry = await self.populate_lora_from_civitai(
                             lora_entry, 
-                            civitai_info, 
-                            recipe_scanner
+                            civitai_info_tuple, 
+                            recipe_scanner,
+                            base_model_counts
                         )
                     except Exception as e:
                         logger.error(f"Error fetching Civitai info for LoRA: {e}")
@@ -398,27 +403,43 @@ class StandardMetadataParser(RecipeMetadataParser):
             
             # Extract Civitai resources
             if 'Civitai resources:' in user_comment:
-                resources_part = user_comment.split('Civitai resources:', 1)[1]
-                if '],' in resources_part:
-                    resources_json = resources_part.split('],', 1)[0] + ']'
-                    try:
-                        resources = json.loads(resources_json)
-                        # Filter loras and checkpoints
-                        for resource in resources:
-                            if resource.get('type') == 'lora':
-                                # 确保 weight 字段被正确保留
-                                lora_entry = resource.copy()
-                                # 如果找不到 weight，默认为 1.0
-                                if 'weight' not in lora_entry:
-                                    lora_entry['weight'] = 1.0
-                                # Ensure modelVersionName is included
-                                if 'modelVersionName' not in lora_entry:
-                                    lora_entry['modelVersionName'] = ''
-                                metadata['loras'].append(lora_entry)
-                            elif resource.get('type') == 'checkpoint':
-                                metadata['checkpoint'] = resource
-                    except json.JSONDecodeError:
-                        pass
+                resources_part = user_comment.split('Civitai resources:', 1)[1].strip()
+                
+                # Look for the opening and closing brackets to extract the JSON array
+                if resources_part.startswith('['):
+                    # Find the position of the closing bracket
+                    bracket_count = 0
+                    end_pos = -1
+                    
+                    for i, char in enumerate(resources_part):
+                        if char == '[':
+                            bracket_count += 1
+                        elif char == ']':
+                            bracket_count -= 1
+                            if bracket_count == 0:
+                                end_pos = i
+                                break
+                    
+                    if end_pos != -1:
+                        resources_json = resources_part[:end_pos+1]
+                        try:
+                            resources = json.loads(resources_json)
+                            # Filter loras and checkpoints
+                            for resource in resources:
+                                if resource.get('type') == 'lora':
+                                    # 确保 weight 字段被正确保留
+                                    lora_entry = resource.copy()
+                                    # 如果找不到 weight，默认为 1.0
+                                    if 'weight' not in lora_entry:
+                                        lora_entry['weight'] = 1.0
+                                    # Ensure modelVersionName is included
+                                    if 'modelVersionName' not in lora_entry:
+                                        lora_entry['modelVersionName'] = ''
+                                    metadata['loras'].append(lora_entry)
+                                elif resource.get('type') == 'checkpoint':
+                                    metadata['checkpoint'] = resource
+                        except json.JSONDecodeError:
+                            pass
             
             return metadata
         except Exception as e:
@@ -431,7 +452,7 @@ class A1111MetadataParser(RecipeMetadataParser):
     
     METADATA_MARKER = r'Lora hashes:'
     LORA_PATTERN = r'<lora:([^:]+):([^>]+)>'
-    LORA_HASH_PATTERN = r'([^:]+): ([a-f0-9]+)'
+    LORA_HASH_PATTERN = r'([^:]+):\s*([a-fA-F0-9]+)'
     
     def is_metadata_matching(self, user_comment: str) -> bool:
         """Check if the user comment matches the A1111 metadata format"""
@@ -440,51 +461,103 @@ class A1111MetadataParser(RecipeMetadataParser):
     async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
         """Parse metadata from images with A1111 metadata format"""
         try:
-            # Extract prompt and negative prompt
-            parts = user_comment.split('Negative prompt:', 1)
-            prompt = parts[0].strip()
+            # Initialize metadata with default empty values
+            metadata = {"prompt": "", "loras": []}
             
-            # Initialize metadata
-            metadata = {"prompt": prompt, "loras": []}
-            
-            # Extract negative prompt and parameters
-            if len(parts) > 1:
-                negative_and_params = parts[1]
+            # Check if the user_comment contains prompt and negative prompt
+            if 'Negative prompt:' in user_comment:
+                # Extract prompt and negative prompt
+                parts = user_comment.split('Negative prompt:', 1)
+                metadata["prompt"] = parts[0].strip()
                 
-                # Extract negative prompt
-                if "Steps:" in negative_and_params:
-                    neg_prompt = negative_and_params.split("Steps:", 1)[0].strip()
-                    metadata["negative_prompt"] = neg_prompt
-                
-                # Extract key-value parameters (Steps, Sampler, CFG scale, etc.)
-                param_pattern = r'([A-Za-z ]+): ([^,]+)'
-                params = re.findall(param_pattern, negative_and_params)
-                for key, value in params:
-                    clean_key = key.strip().lower().replace(' ', '_')
-                    metadata[clean_key] = value.strip()
+                # Extract negative prompt and parameters
+                if len(parts) > 1:
+                    negative_and_params = parts[1]
+                    
+                    # Extract negative prompt
+                    param_start = re.search(r'([A-Za-z ]+):', negative_and_params)
+                    if param_start:
+                        neg_prompt = negative_and_params[:param_start.start()].strip()
+                        metadata["negative_prompt"] = neg_prompt
+                        params_section = negative_and_params[param_start.start():]
+                    else:
+                        params_section = negative_and_params
+                    
+                    # Extract parameters from this section
+                    self._extract_parameters(params_section, metadata)
+            else:
+                # No prompt/negative prompt - extract parameters directly
+                self._extract_parameters(user_comment, metadata)
             
-            # Extract LoRA information from prompt
+            # Extract LoRA information from prompt if available
             lora_weights = {}
-            lora_matches = re.findall(self.LORA_PATTERN, prompt)
-            for lora_name, weights in lora_matches:
-                # Take only the first strength value (before the colon)
-                weight = weights.split(':')[0]
-                lora_weights[lora_name.strip()] = float(weight.strip())
-            
-            # Remove LoRA patterns from prompt
-            metadata["prompt"] = re.sub(self.LORA_PATTERN, '', prompt).strip()
+            if metadata["prompt"]:
+                lora_matches = re.findall(self.LORA_PATTERN, metadata["prompt"])
+                for lora_name, weights in lora_matches:
+                    # Take only the first strength value (before the colon)
+                    weight = weights.split(':')[0]
+                    lora_weights[lora_name.strip()] = float(weight.strip())
+                
+                # Remove LoRA patterns from prompt
+                metadata["prompt"] = re.sub(self.LORA_PATTERN, '', metadata["prompt"]).strip()
             
             # Extract LoRA hashes
             lora_hashes = {}
             if 'Lora hashes:' in user_comment:
+                # Get the LoRA hashes section
                 lora_hash_section = user_comment.split('Lora hashes:', 1)[1].strip()
+                
+                # Handle various format possibilities
                 if lora_hash_section.startswith('"'):
-                    lora_hash_section = lora_hash_section[1:].split('"', 1)[0]
-                hash_matches = re.findall(self.LORA_HASH_PATTERN, lora_hash_section)
-                for lora_name, hash_value in hash_matches:
-                    # Remove any leading comma and space from lora name
-                    clean_name = lora_name.strip().lstrip(',').strip()
-                    lora_hashes[clean_name] = hash_value.strip()
+                    # Extract content within quotes
+                    quote_match = re.match(r'"([^"]+)"', lora_hash_section)
+                    if quote_match:
+                        lora_hash_section = quote_match.group(1)
+                
+                # Split by commas and parse each LoRA entry
+                lora_entries = []
+                current_entry = ""
+                for part in lora_hash_section.split(','):
+                    # Check if this part contains a colon (indicating a complete entry)
+                    if ':' in part:
+                        if current_entry:
+                            lora_entries.append(current_entry.strip())
+                        current_entry = part.strip()
+                    else:
+                        # This is probably a continuation of the previous entry
+                        current_entry += ',' + part
+                
+                # Add the last entry if it exists
+                if current_entry:
+                    lora_entries.append(current_entry.strip())
+                
+                # Process each entry
+                for entry in lora_entries:
+                    # Split at the colon to get name and hash
+                    if ':' in entry:
+                        lora_name, hash_value = entry.split(':', 1)
+                        # Clean the values
+                        lora_name = lora_name.strip()
+                        hash_value = hash_value.strip()
+                        # Store in our dictionary
+                        lora_hashes[lora_name] = hash_value
+            
+            # Alternative backup method using regex if the above parsing fails
+            if not lora_hashes:
+                if 'Lora hashes:' in user_comment:
+                    lora_hash_section = user_comment.split('Lora hashes:', 1)[1].strip()
+                    if lora_hash_section.startswith('"'):
+                        # Extract content within quotes if present
+                        quote_match = re.match(r'"([^"]+)"', lora_hash_section)
+                        if quote_match:
+                            lora_hash_section = quote_match.group(1)
+                    
+                    # Use regex to find all name:hash pairs
+                    hash_matches = re.findall(self.LORA_HASH_PATTERN, lora_hash_section)
+                    for lora_name, hash_value in hash_matches:
+                        # Clean up name by removing any leading comma and spaces
+                        clean_name = lora_name.strip().lstrip(',').strip()
+                        lora_hashes[clean_name] = hash_value.strip()
             
             # Process LoRAs and collect base models
             base_model_counts = {}
@@ -502,7 +575,7 @@ class A1111MetadataParser(RecipeMetadataParser):
                     'existsLocally': False,
                     'localPath': None,
                     'file_name': lora_name,
-                    'hash': hash_value,
+                    'hash': hash_value.lower(),  # Ensure hash is lowercase
                     'thumbnailUrl': '/loras_static/images/no-preview.png',
                     'baseModel': '',
                     'size': 0,
@@ -552,6 +625,15 @@ class A1111MetadataParser(RecipeMetadataParser):
         except Exception as e:
             logger.error(f"Error parsing A1111 metadata: {e}", exc_info=True)
             return {"error": str(e), "loras": []}
+    
+    def _extract_parameters(self, text: str, metadata: Dict[str, Any]) -> None:
+        """Extract parameters from text section and populate metadata dict"""
+        # Extract key-value parameters (Steps, Sampler, CFG scale, etc.)
+        param_pattern = r'([A-Za-z][A-Za-z0-9 _]+): ([^,]+)(?:,|$)'
+        params = re.findall(param_pattern, text)
+        for key, value in params:
+            clean_key = key.strip().lower().replace(' ', '_')
+            metadata[clean_key] = value.strip()
 
 
 class ComfyMetadataParser(RecipeMetadataParser):
@@ -621,11 +703,11 @@ class ComfyMetadataParser(RecipeMetadataParser):
                 # Get additional info from Civitai if client is available
                 if civitai_client:
                     try:
-                        civitai_info = await civitai_client.get_model_version_info(model_version_id)
+                        civitai_info_tuple = await civitai_client.get_model_version_info(model_version_id)
                         # Populate lora entry with Civitai info
                         lora_entry = await self.populate_lora_from_civitai(
                             lora_entry, 
-                            civitai_info, 
+                            civitai_info_tuple, 
                             recipe_scanner
                         )
                     except Exception as e:
@@ -660,7 +742,8 @@ class ComfyMetadataParser(RecipeMetadataParser):
                         # Get additional checkpoint info from Civitai
                         if civitai_client:
                             try:
-                                civitai_info = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                civitai_info_tuple = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                civitai_info, _ = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
                                 # Populate checkpoint with Civitai info
                                 checkpoint = await self.populate_checkpoint_from_civitai(checkpoint, civitai_info)
                             except Exception as e:

py/utils/routes_common.py

@@ -53,6 +53,7 @@ class ModelRouteUtils:
                 if model_metadata:
                     local_metadata['modelDescription'] = model_metadata.get('description', '')
                     local_metadata['tags'] = model_metadata.get('tags', [])
+                    local_metadata['civitai']['creator'] = model_metadata['creator']
         
         # Update base model
         local_metadata['base_model'] = determine_base_model(civitai_metadata.get('baseModel'))
@@ -95,7 +96,7 @@ class ModelRouteUtils:
                                 target_width=CARD_PREVIEW_WIDTH,
                                 format='webp',
                                 quality=85,
-                                preserve_metadata=True
+                                preserve_metadata=False
                             )
                             
                             # Save the optimized WebP image
@@ -387,7 +388,7 @@ class ModelRouteUtils:
                     target_width=CARD_PREVIEW_WIDTH,
                     format='webp',
                     quality=85,
-                    preserve_metadata=True
+                    preserve_metadata=False
                 )
                 extension = '.webp'  # Use .webp without .preview part
             
@@ -424,6 +425,65 @@ class ModelRouteUtils:
             logger.error(f"Error replacing preview: {e}", exc_info=True)
             return web.Response(text=str(e), status=500)
 
+    @staticmethod
+    async def handle_exclude_model(request: web.Request, scanner) -> web.Response:
+        """Handle model exclusion request
+        
+        Args:
+            request: The aiohttp request
+            scanner: The model scanner instance with cache management methods
+            
+        Returns:
+            web.Response: The HTTP response
+        """
+        try:
+            data = await request.json()
+            file_path = data.get('file_path')
+            if not file_path:
+                return web.Response(text='Model path is required', status=400)
+
+            # Update metadata to mark as excluded
+            metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
+            metadata = await ModelRouteUtils.load_local_metadata(metadata_path)
+            metadata['exclude'] = True
+            
+            # Save updated metadata
+            with open(metadata_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+
+            # Update cache
+            cache = await scanner.get_cached_data()
+
+            # Find and remove model from cache
+            model_to_remove = next((item for item in cache.raw_data if item['file_path'] == file_path), None)
+            if model_to_remove:
+                # Update tags count
+                for tag in model_to_remove.get('tags', []):
+                    if tag in scanner._tags_count:
+                        scanner._tags_count[tag] = max(0, scanner._tags_count[tag] - 1)
+                        if scanner._tags_count[tag] == 0:
+                            del scanner._tags_count[tag]
+
+                # Remove from hash index if available
+                if hasattr(scanner, '_hash_index') and scanner._hash_index:
+                    scanner._hash_index.remove_by_path(file_path)
+
+                # Remove from cache data
+                cache.raw_data = [item for item in cache.raw_data if item['file_path'] != file_path]
+                await cache.resort()
+            
+            # Add to excluded models list
+            scanner._excluded_models.append(file_path)
+            
+            return web.json_response({
+                'success': True,
+                'message': f"Model {os.path.basename(file_path)} excluded"
+            })
+            
+        except Exception as e:
+            logger.error(f"Error excluding model: {e}", exc_info=True)
+            return web.Response(text=str(e), status=500)
+
     @staticmethod
     async def handle_download_model(request: web.Request, download_manager: DownloadManager, model_type="lora") -> web.Response:
         """Handle model download request
@@ -500,4 +560,4 @@ class ModelRouteUtils:
                 )
             
             logger.error(f"Error downloading {model_type}: {error_message}")
-            return web.Response(status=500, text=error_message)
+            return web.Response(status=500, text=error_message)

py/utils/usage_stats.py

@@ -0,0 +1,273 @@
+import os
+import json
+import sys
+import time
+import asyncio
+import logging
+from typing import Dict, Set
+
+from ..config import config
+from ..services.service_registry import ServiceRegistry
+
+# Check if running in standalone mode
+standalone_mode = 'nodes' not in sys.modules
+
+if not standalone_mode:
+    from ..metadata_collector.metadata_registry import MetadataRegistry
+    from ..metadata_collector.constants import MODELS, LORAS
+
+logger = logging.getLogger(__name__)
+
+class UsageStats:
+    """Track usage statistics for models and save to JSON"""
+    
+    _instance = None
+    _lock = asyncio.Lock()  # For thread safety
+    
+    # Default stats file name
+    STATS_FILENAME = "lora_manager_stats.json"
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+            
+        # Initialize stats storage
+        self.stats = {
+            "checkpoints": {},  # sha256 -> count
+            "loras": {},        # sha256 -> count
+            "total_executions": 0,
+            "last_save_time": 0
+        }
+        
+        # Queue for prompt_ids to process
+        self.pending_prompt_ids = set()
+        
+        # Load existing stats if available
+        self._stats_file_path = self._get_stats_file_path()
+        self._load_stats()
+        
+        # Save interval in seconds
+        self.save_interval = 90  # 1.5 minutes
+        
+        # Start background task to process queued prompt_ids
+        self._bg_task = asyncio.create_task(self._background_processor())
+        
+        self._initialized = True
+        logger.info("Usage statistics tracker initialized")
+    
+    def _get_stats_file_path(self) -> str:
+        """Get the path to the stats JSON file"""
+        if not config.loras_roots or len(config.loras_roots) == 0:
+            # Fallback to temporary directory if no lora roots
+            return os.path.join(config.temp_directory, self.STATS_FILENAME)
+        
+        # Use the first lora root
+        return os.path.join(config.loras_roots[0], self.STATS_FILENAME)
+    
+    def _load_stats(self):
+        """Load existing statistics from file"""
+        try:
+            if os.path.exists(self._stats_file_path):
+                with open(self._stats_file_path, 'r', encoding='utf-8') as f:
+                    loaded_stats = json.load(f)
+                
+                # Update our stats with loaded data
+                if isinstance(loaded_stats, dict):
+                    # Update individual sections to maintain structure
+                    if "checkpoints" in loaded_stats and isinstance(loaded_stats["checkpoints"], dict):
+                        self.stats["checkpoints"] = loaded_stats["checkpoints"]
+                    
+                    if "loras" in loaded_stats and isinstance(loaded_stats["loras"], dict):
+                        self.stats["loras"] = loaded_stats["loras"]
+                    
+                    if "total_executions" in loaded_stats:
+                        self.stats["total_executions"] = loaded_stats["total_executions"]
+                    
+                logger.info(f"Loaded usage statistics from {self._stats_file_path}")
+        except Exception as e:
+            logger.error(f"Error loading usage statistics: {e}")
+    
+    async def save_stats(self, force=False):
+        """Save statistics to file"""
+        try:
+            # Only save if it's been at least save_interval since last save or force is True
+            current_time = time.time()
+            if not force and (current_time - self.stats.get("last_save_time", 0)) < self.save_interval:
+                return False
+                
+            # Use a lock to prevent concurrent writes
+            async with self._lock:
+                # Update last save time
+                self.stats["last_save_time"] = current_time
+                
+                # Create directory if it doesn't exist
+                os.makedirs(os.path.dirname(self._stats_file_path), exist_ok=True)
+                
+                # Write to a temporary file first, then move it to avoid corruption
+                temp_path = f"{self._stats_file_path}.tmp"
+                with open(temp_path, 'w', encoding='utf-8') as f:
+                    json.dump(self.stats, f, indent=2, ensure_ascii=False)
+                
+                # Replace the old file with the new one
+                os.replace(temp_path, self._stats_file_path)
+                
+                logger.debug(f"Saved usage statistics to {self._stats_file_path}")
+                return True
+        except Exception as e:
+            logger.error(f"Error saving usage statistics: {e}", exc_info=True)
+            return False
+    
+    def register_execution(self, prompt_id):
+        """Register a completed execution by prompt_id for later processing"""
+        if prompt_id:
+            self.pending_prompt_ids.add(prompt_id)
+    
+    async def _background_processor(self):
+        """Background task to process queued prompt_ids"""
+        try:
+            while True:
+                # Wait a short interval before checking for new prompt_ids
+                await asyncio.sleep(5)  # Check every 5 seconds
+                
+                # Process any pending prompt_ids
+                if self.pending_prompt_ids:
+                    async with self._lock:
+                        # Get a copy of the set and clear original
+                        prompt_ids = self.pending_prompt_ids.copy()
+                        self.pending_prompt_ids.clear()
+                    
+                    # Process each prompt_id
+                    registry = MetadataRegistry()
+                    for prompt_id in prompt_ids:
+                        try:
+                            metadata = registry.get_metadata(prompt_id)
+                            await self._process_metadata(metadata)
+                        except Exception as e:
+                            logger.error(f"Error processing prompt_id {prompt_id}: {e}")
+                
+                # Periodically save stats
+                await self.save_stats()
+        except asyncio.CancelledError:
+            # Task was cancelled, clean up
+            await self.save_stats(force=True)
+        except Exception as e:
+            logger.error(f"Error in background processing task: {e}", exc_info=True)
+            # Restart the task after a delay if it fails
+            asyncio.create_task(self._restart_background_task())
+    
+    async def _restart_background_task(self):
+        """Restart the background task after a delay"""
+        await asyncio.sleep(30)  # Wait 30 seconds before restarting
+        self._bg_task = asyncio.create_task(self._background_processor())
+    
+    async def _process_metadata(self, metadata):
+        """Process metadata from an execution"""
+        if not metadata or not isinstance(metadata, dict):
+            return
+            
+        # Increment total executions count
+        self.stats["total_executions"] += 1
+        
+        # Process checkpoints
+        if MODELS in metadata and isinstance(metadata[MODELS], dict):
+            await self._process_checkpoints(metadata[MODELS])
+        
+        # Process loras
+        if LORAS in metadata and isinstance(metadata[LORAS], dict):
+            await self._process_loras(metadata[LORAS])
+    
+    async def _process_checkpoints(self, models_data):
+        """Process checkpoint models from metadata"""
+        try:
+            # Get checkpoint scanner service
+            checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
+            if not checkpoint_scanner:
+                logger.warning("Checkpoint scanner not available for usage tracking")
+                return
+            
+            for node_id, model_info in models_data.items():
+                if not isinstance(model_info, dict):
+                    continue
+                    
+                # Check if this is a checkpoint model
+                model_type = model_info.get("type")
+                if model_type == "checkpoint":
+                    model_name = model_info.get("name")
+                    if not model_name:
+                        continue
+                    
+                    # Clean up filename (remove extension if present)
+                    model_filename = os.path.splitext(os.path.basename(model_name))[0]
+                    
+                    # Get hash for this checkpoint
+                    model_hash = checkpoint_scanner.get_hash_by_filename(model_filename)
+                    if model_hash:
+                        # Update stats for this checkpoint
+                        self.stats["checkpoints"][model_hash] = self.stats["checkpoints"].get(model_hash, 0) + 1
+        except Exception as e:
+            logger.error(f"Error processing checkpoint usage: {e}", exc_info=True)
+    
+    async def _process_loras(self, loras_data):
+        """Process LoRA models from metadata"""
+        try:
+            # Get LoRA scanner service
+            lora_scanner = await ServiceRegistry.get_lora_scanner()
+            if not lora_scanner:
+                logger.warning("LoRA scanner not available for usage tracking")
+                return
+            
+            for node_id, lora_info in loras_data.items():
+                if not isinstance(lora_info, dict):
+                    continue
+                
+                # Get the list of LoRAs from standardized format
+                lora_list = lora_info.get("lora_list", [])
+                for lora in lora_list:
+                    if not isinstance(lora, dict):
+                        continue
+                        
+                    lora_name = lora.get("name")
+                    if not lora_name:
+                        continue
+                    
+                    # Get hash for this LoRA
+                    lora_hash = lora_scanner.get_hash_by_filename(lora_name)
+                    if lora_hash:
+                        # Update stats for this LoRA
+                        self.stats["loras"][lora_hash] = self.stats["loras"].get(lora_hash, 0) + 1
+        except Exception as e:
+            logger.error(f"Error processing LoRA usage: {e}", exc_info=True)
+    
+    async def get_stats(self):
+        """Get current usage statistics"""
+        return self.stats
+    
+    async def get_model_usage_count(self, model_type, sha256):
+        """Get usage count for a specific model by hash"""
+        if model_type == "checkpoint":
+            return self.stats["checkpoints"].get(sha256, 0)
+        elif model_type == "lora":
+            return self.stats["loras"].get(sha256, 0)
+        return 0
+    
+    async def process_execution(self, prompt_id):
+        """Process a prompt execution immediately (synchronous approach)"""
+        if not prompt_id:
+            return
+            
+        try:
+            # Process metadata for this prompt_id
+            registry = MetadataRegistry()
+            metadata = registry.get_metadata(prompt_id)
+            if metadata:
+                await self._process_metadata(metadata)
+                # Save stats if needed
+                await self.save_stats()
+        except Exception as e:
+            logger.error(f"Error processing prompt_id {prompt_id}: {e}", exc_info=True)

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "LoRA Manager for ComfyUI - Access it at http://localhost:8188/loras for managing LoRA models with previews and metadata integration."
-version = "0.8.6"
+version = "0.8.12"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",
@@ -12,7 +12,8 @@ dependencies = [
     "piexif",
     "Pillow",
     "olefile", # for getting rid of warning message
-    "requests"
+    "requests",
+    "toml"
 ]
 
 [project.urls]

refs/test_output.txt

@@ -1,294 +0,0 @@
-Loading workflow from D:\Workspace\ComfyUI\custom_nodes\ComfyUI-Lora-Manager\refs\prompt.json
-Expected output from D:\Workspace\ComfyUI\custom_nodes\ComfyUI-Lora-Manager\refs\output.json
-
-Expected output:
-{
-  "loras": "<lora:ck-neon-retrowave-IL-000012:0.8> <lora:aorunIllstrious:1> <lora:ck-shadow-circuit-IL-000012:0.78> <lora:MoriiMee_Gothic_Niji_Style_Illustrious_r1:0.45> <lora:ck-nc-cyberpunk-IL-000011:0.4>",
-  "gen_params": {
-    "prompt": "in the style of ck-rw, aorun, scales, makeup, bare shoulders, pointy ears, dress, claws, in the style of cksc, artist:moriimee, in the style of cknc, masterpiece, best quality, good quality, very aesthetic, absurdres, newest, 8K, depth of field, focused subject, close up, stylized, in gold and neon shades, wabi sabi, 1girl, rainbow angel wings, looking at viewer, dynamic angle, from below, from side, relaxing",
-    "negative_prompt": "bad quality, worst quality, worst detail, sketch ,signature, watermark, patreon logo, nsfw",
-    "steps": "20",
-    "sampler": "euler_ancestral",
-    "cfg_scale": "8",
-    "seed": "241",
-    "size": "832x1216",
-    "clip_skip": "2"
-  }
-}
-
-Sampler node:
-{
-  "inputs": {
-    "seed": 241,
-    "steps": 20,
-    "cfg": 8,
-    "sampler_name": "euler_ancestral",
-    "scheduler": "karras",
-    "denoise": 1,
-    "model": [
-      "56",
-      0
-    ],
-    "positive": [
-      "6",
-      0
-    ],
-    "negative": [
-      "7",
-      0
-    ],
-    "latent_image": [
-      "5",
-      0
-    ]
-  },
-  "class_type": "KSampler",
-  "_meta": {
-    "title": "KSampler"
-  }
-}
-
-Extracted parameters:
-seed: 241
-steps: 20
-cfg_scale: 8
-
-Positive node (6):
-{
-  "inputs": {
-    "text": [
-      "22",
-      0
-    ],
-    "clip": [
-      "56",
-      1
-    ]
-  },
-  "class_type": "CLIPTextEncode",
-  "_meta": {
-    "title": "CLIP Text Encode (Prompt)"
-  }
-}
-
-Text node (22):
-{
-  "inputs": {
-    "string1": [
-      "55",
-      0
-    ],
-    "string2": [
-      "21",
-      0
-    ],
-    "delimiter": ", "
-  },
-  "class_type": "JoinStrings",
-  "_meta": {
-    "title": "Join Strings"
-  }
-}
-
-String1 node (55):
-{
-  "inputs": {
-    "group_mode": true,
-    "toggle_trigger_words": [
-      {
-        "text": "in the style of ck-rw",
-        "active": true
-      },
-      {
-        "text": "aorun, scales, makeup, bare shoulders, pointy ears",
-        "active": true
-      },
-      {
-        "text": "dress",
-        "active": true
-      },
-      {
-        "text": "claws",
-        "active": true
-      },
-      {
-        "text": "in the style of cksc",
-        "active": true
-      },
-      {
-        "text": "artist:moriimee",
-        "active": true
-      },
-      {
-        "text": "in the style of cknc",
-        "active": true
-      },
-      {
-        "text": "__dummy_item__",
-        "active": false,
-        "_isDummy": true
-      },
-      {
-        "text": "__dummy_item__",
-        "active": false,
-        "_isDummy": true
-      }
-    ],
-    "orinalMessage": "in the style of ck-rw,, aorun, scales, makeup, bare shoulders, pointy ears,, dress,, claws,, in the style of cksc,, artist:moriimee,, in the style of cknc",
-    "trigger_words": [
-      "56",
-      2
-    ]
-  },
-  "class_type": "TriggerWord Toggle (LoraManager)",
-  "_meta": {
-    "title": "TriggerWord Toggle (LoraManager)"
-  }
-}
-
-String2 node (21):
-{
-  "inputs": {
-    "string": "masterpiece, best quality, good quality, very aesthetic, absurdres, newest, 8K, depth of field, focused subject, close up, stylized, in gold and neon shades, wabi sabi, 1girl, rainbow angel wings, looking at viewer, dynamic angle, from below, from side, relaxing",
-    "strip_newlines": false
-  },
-  "class_type": "StringConstantMultiline",
-  "_meta": {
-    "title": "positive"
-  }
-}
-
-Negative node (7):
-{
-  "inputs": {
-    "text": "bad quality, worst quality, worst detail, sketch ,signature, watermark, patreon logo, nsfw",
-    "clip": [
-      "56",
-      1
-    ]
-  },
-  "class_type": "CLIPTextEncode",
-  "_meta": {
-    "title": "CLIP Text Encode (Prompt)"
-  }
-}
-
-LoRA nodes (3):
-
-LoRA node 56:
-{
-  "inputs": {
-    "text": "<lora:ck-shadow-circuit-IL-000012:0.78> <lora:MoriiMee_Gothic_Niji_Style_Illustrious_r1:0.45> <lora:ck-nc-cyberpunk-IL-000011:0.4>",
-    "loras": [
-      {
-        "name": "ck-shadow-circuit-IL-000012",
-        "strength": 0.78,
-        "active": true
-      },
-      {
-        "name": "MoriiMee_Gothic_Niji_Style_Illustrious_r1",
-        "strength": 0.45,
-        "active": true
-      },
-      {
-        "name": "ck-nc-cyberpunk-IL-000011",
-        "strength": 0.4,
-        "active": true
-      },
-      {
-        "name": "__dummy_item1__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      },
-      {
-        "name": "__dummy_item2__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      }
-    ],
-    "model": [
-      "4",
-      0
-    ],
-    "clip": [
-      "4",
-      1
-    ],
-    "lora_stack": [
-      "57",
-      0
-    ]
-  },
-  "class_type": "Lora Loader (LoraManager)",
-  "_meta": {
-    "title": "Lora Loader (LoraManager)"
-  }
-}
-
-LoRA node 57:
-{
-  "inputs": {
-    "text": "<lora:aorunIllstrious:1>",
-    "loras": [
-      {
-        "name": "aorunIllstrious",
-        "strength": "0.90",
-        "active": true
-      },
-      {
-        "name": "__dummy_item1__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      },
-      {
-        "name": "__dummy_item2__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      }
-    ],
-    "lora_stack": [
-      "59",
-      0
-    ]
-  },
-  "class_type": "Lora Stacker (LoraManager)",
-  "_meta": {
-    "title": "Lora Stacker (LoraManager)"
-  }
-}
-
-LoRA node 59:
-{
-  "inputs": {
-    "text": "<lora:ck-neon-retrowave-IL-000012:0.8>",
-    "loras": [
-      {
-        "name": "ck-neon-retrowave-IL-000012",
-        "strength": 0.8,
-        "active": true
-      },
-      {
-        "name": "__dummy_item1__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      },
-      {
-        "name": "__dummy_item2__",
-        "strength": 0,
-        "active": false,
-        "_isDummy": true
-      }
-    ]
-  },
-  "class_type": "Lora Stacker (LoraManager)",
-  "_meta": {
-    "title": "Lora Stacker (LoraManager)"
-  }
-}
-
-Test completed.

requirements.txt

@@ -6,4 +6,7 @@ beautifulsoup4
 piexif
 Pillow
 olefile
-requests
+requests
+toml
+numpy
+torch

settings.json.example

@@ -0,0 +1,14 @@
+{
+  "civitai_api_key": "your_civitai_api_key_here",
+  "show_only_sfw": false,
+  "folder_paths": {
+    "loras": [
+      "C:/path/to/your/loras_folder",
+      "C:/path/to/another/loras_folder"
+    ],
+    "checkpoints": [
+      "C:/path/to/your/checkpoints_folder",
+      "C:/path/to/another/checkpoints_folder"
+    ]
+  }
+}

standalone.py

@@ -0,0 +1,358 @@
+import os
+import sys
+import json
+
+# Create mock folder_paths module BEFORE any other imports
+class MockFolderPaths:
+    @staticmethod
+    def get_folder_paths(folder_name):
+        # Load paths from settings.json
+        settings_path = os.path.join(os.path.dirname(__file__), 'settings.json')
+        try:
+            if os.path.exists(settings_path):
+                with open(settings_path, 'r', encoding='utf-8') as f:
+                    settings = json.load(f)
+                
+                # For diffusion_models, combine unet and diffusers paths
+                if folder_name == "diffusion_models":
+                    paths = []
+                    if 'folder_paths' in settings:
+                        if 'unet' in settings['folder_paths']:
+                            paths.extend(settings['folder_paths']['unet'])
+                        if 'diffusers' in settings['folder_paths']:
+                            paths.extend(settings['folder_paths']['diffusers'])
+                    # Filter out paths that don't exist
+                    valid_paths = [p for p in paths if os.path.exists(p)]
+                    if valid_paths:
+                        return valid_paths
+                    else:
+                        print(f"Warning: No valid paths found for {folder_name}")
+                # For other folder names, return their paths directly
+                elif 'folder_paths' in settings and folder_name in settings['folder_paths']:
+                    paths = settings['folder_paths'][folder_name]
+                    valid_paths = [p for p in paths if os.path.exists(p)]
+                    if valid_paths:
+                        return valid_paths
+                    else:
+                        print(f"Warning: No valid paths found for {folder_name}")
+        except Exception as e:
+            print(f"Error loading folder paths from settings: {e}")
+        
+        # Fallback to empty list if no paths found
+        return []
+    
+    @staticmethod
+    def get_temp_directory():
+        return os.path.join(os.path.dirname(__file__), 'temp')
+    
+    @staticmethod
+    def set_temp_directory(path):
+        os.makedirs(path, exist_ok=True)
+        return path
+
+# Create mock server module with PromptServer
+class MockPromptServer:
+    def __init__(self):
+        self.app = None
+        
+    def send_sync(self, *args, **kwargs):
+        pass
+
+# Create mock metadata_collector module
+class MockMetadataCollector:
+    def init(self):
+        pass
+    
+    def get_metadata(self, prompt_id=None):
+        return {}
+
+# Initialize basic mocks before any imports
+sys.modules['folder_paths'] = MockFolderPaths()
+sys.modules['server'] = type('server', (), {'PromptServer': MockPromptServer()})
+sys.modules['py.metadata_collector'] = MockMetadataCollector()
+
+# Now we can safely import modules that depend on folder_paths and server
+import argparse
+import asyncio
+import logging
+from aiohttp import web
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("lora-manager-standalone")
+
+# Configure aiohttp access logger to be less verbose
+logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+
+# Now we can import the global config from our local modules
+from py.config import config
+
+class StandaloneServer:
+    """Server implementation for standalone mode"""
+    
+    def __init__(self):
+        self.app = web.Application(logger=logger)
+        self.instance = self  # Make it compatible with PromptServer.instance pattern
+        
+        # Ensure the app's access logger is configured to reduce verbosity
+        self.app._subapps = []  # Ensure this exists to avoid AttributeError
+        
+        # Configure access logging for the app
+        self.app.on_startup.append(self._configure_access_logger)
+    
+    async def _configure_access_logger(self, app):
+        """Configure access logger to reduce verbosity"""
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+        
+        # If using aiohttp>=3.8.0, configure access logger through app directly
+        if hasattr(app, 'access_logger'):
+            app.access_logger.setLevel(logging.WARNING)
+    
+    async def setup(self):
+        """Set up the standalone server"""
+        # Create placeholders for compatibility with ComfyUI's implementation
+        self.last_prompt_id = None
+        self.last_node_id = None
+        self.client_id = None
+        
+        # Set up routes
+        self.setup_routes()
+        
+        # Add startup and shutdown handlers
+        self.app.on_startup.append(self.on_startup)
+        self.app.on_shutdown.append(self.on_shutdown)
+    
+    def setup_routes(self):
+        """Set up basic routes"""
+        # Add a simple status endpoint
+        self.app.router.add_get('/', self.handle_status)
+        
+        # Add static route for example images if the path exists in settings
+        settings_path = os.path.join(os.path.dirname(__file__), 'settings.json')
+        if os.path.exists(settings_path):
+            with open(settings_path, 'r', encoding='utf-8') as f:
+                settings = json.load(f)
+            example_images_path = settings.get('example_images_path')
+            logger.info(f"Example images path: {example_images_path}")
+            if example_images_path and os.path.exists(example_images_path):
+                self.app.router.add_static('/example_images_static', example_images_path)
+                logger.info(f"Added static route for example images: /example_images_static -> {example_images_path}")
+    
+    async def handle_status(self, request):
+        """Handle status request by redirecting to loras page"""
+        # Redirect to loras page instead of showing status
+        raise web.HTTPFound('/loras')
+        
+        # Original JSON response (commented out)
+        # return web.json_response({
+        #     "status": "running",
+        #     "mode": "standalone",
+        #     "loras_roots": config.loras_roots,
+        #     "checkpoints_roots": config.checkpoints_roots
+        # })
+    
+    async def on_startup(self, app):
+        """Startup handler"""
+        logger.info("LoRA Manager standalone server starting...")
+    
+    async def on_shutdown(self, app):
+        """Shutdown handler"""
+        logger.info("LoRA Manager standalone server shutting down...")
+    
+    def send_sync(self, event_type, data, sid=None):
+        """Stub for compatibility with PromptServer"""
+        # In standalone mode, we don't have the same websocket system
+        pass
+    
+    async def start(self, host='127.0.0.1', port=8188):
+        """Start the server"""
+        runner = web.AppRunner(self.app)
+        await runner.setup()
+        site = web.TCPSite(runner, host, port)
+        await site.start()
+
+        # Log the server address with a clickable localhost URL regardless of the actual binding
+        logger.info(f"Server started at http://127.0.0.1:{port}")
+        
+        # Keep the server running
+        while True:
+            await asyncio.sleep(3600)  # Sleep for a long time
+    
+    async def publish_loop(self):
+        """Stub for compatibility with PromptServer"""
+        # This method exists in ComfyUI's server but we don't need it
+        pass
+
+# After all mocks are in place, import LoraManager
+from py.lora_manager import LoraManager
+
+class StandaloneLoraManager(LoraManager):
+    """Extended LoraManager for standalone mode"""
+    
+    @classmethod
+    def add_routes(cls, server_instance):
+        """Initialize and register all routes for standalone mode"""
+        app = server_instance.app
+        
+        # Store app in a global-like location for compatibility
+        sys.modules['server'].PromptServer.instance = server_instance
+
+        # Configure aiohttp access logger to be less verbose
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+        
+        added_targets = set()  # Track already added target paths
+        
+        # Add static routes for each lora root
+        for idx, root in enumerate(config.loras_roots, start=1):
+            if not os.path.exists(root):
+                logger.warning(f"Lora root path does not exist: {root}")
+                continue
+                
+            preview_path = f'/loras_static/root{idx}/preview'
+            
+            # Check if this root is a link path in the mappings
+            real_root = root
+            for target, link in config._path_mappings.items():
+                if os.path.normpath(link) == os.path.normpath(root):
+                    # If so, route should point to the target (real path)
+                    real_root = target
+                    break
+            
+            # Normalize and standardize path display for consistency
+            display_root = real_root.replace('\\', '/')
+            
+            # Add static route for original path - use the normalized path
+            app.router.add_static(preview_path, real_root)
+            logger.info(f"Added static route {preview_path} -> {display_root}")
+            
+            # Record route mapping with normalized path
+            config.add_route_mapping(real_root, preview_path)
+            added_targets.add(os.path.normpath(real_root))
+        
+        # Add static routes for each checkpoint root
+        for idx, root in enumerate(config.checkpoints_roots, start=1):
+            if not os.path.exists(root):
+                logger.warning(f"Checkpoint root path does not exist: {root}")
+                continue
+                
+            preview_path = f'/checkpoints_static/root{idx}/preview'
+            
+            # Check if this root is a link path in the mappings
+            real_root = root
+            for target, link in config._path_mappings.items():
+                if os.path.normpath(link) == os.path.normpath(root):
+                    # If so, route should point to the target (real path)
+                    real_root = target
+                    break
+            
+            # Normalize and standardize path display for consistency
+            display_root = real_root.replace('\\', '/')
+            
+            # Add static route for original path
+            app.router.add_static(preview_path, real_root)
+            logger.info(f"Added static route {preview_path} -> {display_root}")
+            
+            # Record route mapping
+            config.add_route_mapping(real_root, preview_path)
+            added_targets.add(os.path.normpath(real_root))
+        
+        # Add static routes for symlink target paths that aren't already covered
+        link_idx = {
+            'lora': 1,
+            'checkpoint': 1
+        }
+        
+        for target_path, link_path in config._path_mappings.items():
+            norm_target = os.path.normpath(target_path)
+            if norm_target not in added_targets:
+                # Determine if this is a checkpoint or lora link based on path
+                is_checkpoint = any(os.path.normpath(cp_root) in os.path.normpath(link_path) for cp_root in config.checkpoints_roots)
+                is_checkpoint = is_checkpoint or any(os.path.normpath(cp_root) in norm_target for cp_root in config.checkpoints_roots)
+                
+                if is_checkpoint:
+                    route_path = f'/checkpoints_static/link_{link_idx["checkpoint"]}/preview'
+                    link_idx["checkpoint"] += 1
+                else:
+                    route_path = f'/loras_static/link_{link_idx["lora"]}/preview'
+                    link_idx["lora"] += 1
+                
+                # Display path with forward slashes for consistency
+                display_target = target_path.replace('\\', '/')
+                
+                app.router.add_static(route_path, target_path)
+                logger.info(f"Added static route for link target {route_path} -> {display_target}")
+                config.add_route_mapping(target_path, route_path)
+                added_targets.add(norm_target)
+        
+        # Add static route for plugin assets
+        app.router.add_static('/loras_static', config.static_path)
+        
+        # Setup feature routes
+        from py.routes.lora_routes import LoraRoutes
+        from py.routes.api_routes import ApiRoutes
+        from py.routes.recipe_routes import RecipeRoutes
+        from py.routes.checkpoints_routes import CheckpointsRoutes
+        from py.routes.update_routes import UpdateRoutes
+        from py.routes.misc_routes import MiscRoutes
+        
+        lora_routes = LoraRoutes()
+        checkpoints_routes = CheckpointsRoutes()
+        
+        # Initialize routes
+        lora_routes.setup_routes(app)
+        checkpoints_routes.setup_routes(app)
+        ApiRoutes.setup_routes(app)
+        RecipeRoutes.setup_routes(app)
+        UpdateRoutes.setup_routes(app)
+        MiscRoutes.setup_routes(app)
+        
+        # Schedule service initialization
+        app.on_startup.append(lambda app: cls._initialize_services())
+        
+        # Add cleanup
+        app.on_shutdown.append(cls._cleanup)
+        app.on_shutdown.append(ApiRoutes.cleanup)
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="LoRA Manager Standalone Server")
+    parser.add_argument("--host", type=str, default="0.0.0.0", 
+                        help="Host address to bind the server to (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8188,
+                        help="Port to bind the server to (default: 8188, access via http://localhost:8188/loras)")
+    # parser.add_argument("--loras", type=str, nargs="+", 
+    #                     help="Additional paths to LoRA model directories (optional if settings.json has paths)")
+    # parser.add_argument("--checkpoints", type=str, nargs="+",
+    #                     help="Additional paths to checkpoint model directories (optional if settings.json has paths)")
+    parser.add_argument("--log-level", type=str, default="INFO",
+                        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+                        help="Logging level")
+    return parser.parse_args()
+
+async def main():
+    """Main entry point for standalone mode"""
+    args = parse_args()
+    
+    # Set log level
+    logging.getLogger().setLevel(getattr(logging, args.log_level))
+    
+    # Explicitly configure aiohttp access logger regardless of selected log level
+    logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+    
+    # Create the server instance
+    server = StandaloneServer()
+    
+    # Initialize routes via the standalone lora manager
+    StandaloneLoraManager.add_routes(server)
+    
+    # Set up and start the server
+    await server.setup()
+    await server.start(host=args.host, port=args.port)
+
+if __name__ == "__main__":
+    try:
+        # Run the main function
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")

static/css/base.css

@@ -59,6 +59,16 @@ html, body {
     --scrollbar-width: 8px; /* 添加滚动条宽度变量 */
 }
 
+html[data-theme="dark"] {
+    background-color: #1a1a1a !important;
+    color-scheme: dark;
+}
+
+html[data-theme="light"] {
+    background-color: #ffffff !important;
+    color-scheme: light;
+}
+
 [data-theme="dark"] {
     --bg-color: #1a1a1a;
     --text-color: #e0e0e0;

static/css/components/alphabet-bar.css

@@ -0,0 +1,165 @@
+/* Alphabet Bar Component */
+.alphabet-bar-container {
+    position: fixed;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 100;
+    display: flex;
+    transition: transform 0.3s ease;
+}
+
+.alphabet-bar-container.collapsed {
+    transform: translateY(-50%) translateX(-90%);
+}
+
+/* New visual indicator for when a letter is active and bar is collapsed */
+.alphabet-bar-container.collapsed .toggle-alphabet-bar.has-active-letter {
+    border-color: var(--lora-accent);
+    background: oklch(var(--lora-accent) / 0.15);
+}
+
+.alphabet-bar-container.collapsed .toggle-alphabet-bar.has-active-letter::after {
+    content: '';
+    position: absolute;
+    top: 7px;
+    right: 7px;
+    width: 8px;
+    height: 8px;
+    background-color: var(--lora-accent);
+    border-radius: 50%;
+    animation: pulse-active 2s infinite;
+}
+
+@keyframes pulse-active {
+    0% { transform: scale(0.8); opacity: 0.7; }
+    50% { transform: scale(1.1); opacity: 1; }
+    100% { transform: scale(0.8); opacity: 0.7; }
+}
+
+.alphabet-bar {
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 0 var(--border-radius-xs) var(--border-radius-xs) 0;
+    padding: 8px 4px;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    align-items: center;
+    box-shadow: 2px 0 8px rgba(0, 0, 0, 0.1);
+    max-height: 80vh;
+    overflow-y: auto;
+    scrollbar-width: thin;
+}
+
+.alphabet-bar::-webkit-scrollbar {
+    width: 4px;
+}
+
+.alphabet-bar::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 4px;
+}
+
+.toggle-alphabet-bar {
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-left: none;
+    border-radius: 0 var(--border-radius-xs) var(--border-radius-xs) 0;
+    padding: 8px 4px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-color);
+    width: 20px;
+    height: 40px;
+    align-self: center;
+    box-shadow: 2px 0 8px rgba(0, 0, 0, 0.1);
+}
+
+.toggle-alphabet-bar:hover {
+    background: var(--bg-hover);
+}
+
+.toggle-alphabet-bar i {
+    transition: transform 0.3s ease;
+}
+
+.alphabet-bar-container.collapsed .toggle-alphabet-bar i {
+    transform: rotate(180deg);
+}
+
+.letter-chip {
+    padding: 4px 2px;
+    border-radius: var(--border-radius-xs);
+    background: var(--bg-color);
+    color: var(--text-color);
+    cursor: pointer;
+    min-width: 24px;
+    text-align: center;
+    font-size: 0.85em;
+    transition: all 0.2s ease;
+    border: 1px solid var(--border-color);
+}
+
+.letter-chip:hover {
+    background: var(--lora-accent);
+    color: white;
+    transform: scale(1.1);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.letter-chip.active {
+    background: var(--lora-accent);
+    color: white;
+    border-color: var(--lora-accent);
+}
+
+.letter-chip.disabled {
+    opacity: 0.5;
+    pointer-events: none;
+    cursor: default;
+}
+
+/* Hide the count by default, only show in tooltip */
+.letter-chip .count {
+    display: none;
+}
+
+.alphabet-bar-title {
+    font-size: 0.75em;
+    color: var(--text-color);
+    opacity: 0.7;
+    margin-bottom: 6px;
+    writing-mode: vertical-lr;
+    transform: rotate(180deg);
+    white-space: nowrap;
+}
+
+@media (max-width: 768px) {
+    .alphabet-bar-container {
+        transform: translateY(-50%) translateX(-90%);
+    }
+    
+    .alphabet-bar-container.active {
+        transform: translateY(-50%) translateX(0);
+    }
+    
+    .letter-chip {
+        padding: 3px 1px;
+        min-width: 20px;
+        font-size: 0.75em;
+    }
+}
+
+/* Keyframe animations for the active letter */
+@keyframes pulse {
+    0% { transform: scale(1); }
+    50% { transform: scale(1.1); }
+    100% { transform: scale(1); }
+}
+
+.letter-chip.active {
+    animation: pulse 1s ease-in-out 1;
+}

static/css/components/card.css

@@ -192,12 +192,43 @@
     margin-left: var(--space-1);
     cursor: pointer;
     color: white;
-    transition: opacity 0.2s;
-    font-size: 0.9em;
+    transition: opacity 0.2s, transform 0.15s ease;
+    font-size: 1.0em; /* Increased from 0.9em for better visibility */
+    width: 16px; /* Fixed width for consistent spacing */
+    height: 16px; /* Fixed height for larger touch target */
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    padding: 4px; /* Add padding to increase clickable area */
+    box-sizing: content-box; /* Ensure padding adds to dimensions */
+    position: relative; /* For proper positioning */
+    margin: 0; /* Reset margin */
+}
+
+.card-actions i::before {
+    position: absolute; /* Position the icon glyph */
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%); /* Center the icon */
+}
+
+.card-actions {
+    display: flex;
+    gap: var(--space-1); /* Use gap instead of margin for spacing between icons */
+    align-items: center;
 }
 
 .card-actions i:hover {
-    opacity: 0.8;
+    opacity: 0.9;
+    transform: scale(1.1);
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+/* Style for active favorites */
+.favorite-active {
+    color: #ffc107 !important; /* Gold color for favorites */
+    text-shadow: 0 0 5px rgba(255, 193, 7, 0.5);
 }
 
 /* 响应式设计 */

static/css/components/download-modal.css

@@ -190,14 +190,6 @@
     border-color: var(--lora-border);
 }
 
-/* Add disabled button styles */
-.primary-btn.disabled {
-    background-color: var(--border-color);
-    color: var(--text-color);
-    opacity: 0.7;
-    cursor: not-allowed;
-}
-
 /* Enhance the local badge to make it more noticeable */
 .version-item.exists-locally {
     background: oklch(var(--lora-accent) / 0.05);

static/css/components/lora-modal.css

@@ -1133,8 +1133,8 @@
     pointer-events: none;
 }
 
-/* Show metadata panel only on hover */
-.media-wrapper:hover .image-metadata-panel {
+/* Show metadata panel only when the 'visible' class is added */
+.media-wrapper .image-metadata-panel.visible {
     transform: translateY(0);
     opacity: 0.98;
     pointer-events: auto;

static/css/components/modal.css

@@ -44,26 +44,12 @@ body.modal-open {
 }
 
 /* Delete Modal specific styles */
-.delete-modal-content {
-    max-width: 500px;
-    text-align: center;
-}
 
 .delete-message {
     color: var(--text-color);
     margin: var(--space-2) 0;
 }
 
-.delete-model-info {
-    background: var(--lora-surface);
-    border: 1px solid var(--lora-border);
-    border-radius: var(--border-radius-sm);
-    padding: var(--space-2);
-    margin: var(--space-2) 0;
-    color: var(--text-color);
-    word-break: break-all;
-}
-
 /* Update delete modal styles */
 .delete-modal {
     display: none;  /* Set initial display to none */
@@ -92,7 +78,8 @@ body.modal-open {
     animation: modalFadeIn 0.2s ease-out;
 }
 
-.delete-model-info {
+.delete-model-info,
+.exclude-model-info {
     /* Update info display styling */
     background: var(--lora-surface);
     border: 1px solid var(--lora-border);
@@ -123,7 +110,7 @@ body.modal-open {
     margin-top: var(--space-3);
 }
 
-.cancel-btn, .delete-btn {
+.cancel-btn, .delete-btn, .exclude-btn {
     padding: 8px var(--space-2);
     border-radius: 6px;
     border: none;
@@ -143,6 +130,12 @@ body.modal-open {
     color: white;
 }
 
+/* Style for exclude button - different from delete button */
+.exclude-btn {
+    background: var(--lora-accent, #4f46e5);
+    color: white;
+}
+
 .cancel-btn:hover {
     background: var(--lora-border);
 }
@@ -151,6 +144,11 @@ body.modal-open {
     opacity: 0.9;
 }
 
+.exclude-btn:hover {
+    opacity: 0.9;
+    background: oklch(from var(--lora-accent, #4f46e5) l c h / 85%);
+}
+
 .modal-content h2 {
     color: var(--text-color);
     margin-bottom: var(--space-2);
@@ -496,6 +494,107 @@ input:checked + .toggle-slider:before {
     filter: blur(8px);
 }
 
+/* Example Images Settings Styles */
+.download-buttons {
+    justify-content: flex-start;
+    gap: var(--space-2);
+}
+
+.primary-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 16px;
+    background-color: var(--lora-accent);
+    color: var(--lora-text);
+    border: none;
+    border-radius: var(--border-radius-sm);
+    cursor: pointer;
+    transition: background-color 0.2s;
+    font-size: 0.95em;
+}
+
+.primary-btn:hover {
+    background-color: oklch(from var(--lora-accent) l c h / 85%);
+    color: var(--lora-text);
+}
+
+/* Secondary button styles */
+.secondary-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 16px;
+    background-color: var(--card-bg);
+    color: var(--text-color);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-sm);
+    cursor: pointer;
+    transition: all 0.2s;
+    font-size: 0.95em;
+}
+
+.secondary-btn:hover {
+    background-color: var(--border-color);
+    color: var(--text-color);
+}
+
+/* Disabled button styles */
+.primary-btn.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    background-color: var(--lora-accent);
+    color: var(--lora-text);
+    pointer-events: none;
+}
+
+.secondary-btn.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    pointer-events: none;
+}
+
+/* Dark theme specific button adjustments */
+[data-theme="dark"] .primary-btn:hover {
+    background-color: oklch(from var(--lora-accent) l c h / 75%);
+}
+
+[data-theme="dark"] .secondary-btn {
+    background-color: var(--lora-surface);
+}
+
+[data-theme="dark"] .secondary-btn:hover {
+    background-color: oklch(35% 0.02 256 / 0.98);
+}
+
+.primary-btn.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.path-control {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    width: 100%;
+}
+
+.path-control input[type="text"] {
+    flex: 1;
+    padding: 6px 10px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid var(--border-color);
+    background-color: var(--lora-surface);
+    color: var (--text-color);
+    font-size: 0.95em;
+    height: 32px;
+}
+
+.primary-btn.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
 /* Add styles for delete preview image */
 .delete-preview {
     max-width: 150px;

static/css/components/progress-panel.css

@@ -0,0 +1,215 @@
+/* Progress Panel Styles */
+.progress-panel {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    width: 350px;
+    background: var(--lora-surface);
+    border: 1px solid var(--lora-border);
+    border-radius: var(--border-radius-sm);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    z-index: calc(var(--z-modal) - 1);
+    transition: transform 0.3s ease, opacity 0.3s ease;
+    opacity: 0;
+    transform: translateY(20px);
+}
+
+.progress-panel.visible {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.progress-panel.collapsed .progress-panel-content {
+    display: none;
+}
+
+.progress-panel.collapsed .progress-panel-header {
+    border-bottom: none;
+    padding-bottom: calc(var(--space-2) + 12px);
+}
+
+.progress-panel-header {
+    padding: var(--space-2);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-bottom: 1px solid var(--lora-border);
+}
+
+.progress-panel-title {
+    font-weight: 500;
+    color: var(--text-color);
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.progress-panel-actions {
+    display: flex;
+    gap: 6px;
+}
+
+.icon-button {
+    background: none;
+    border: none;
+    color: var(--text-color);
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    opacity: 0.6;
+    transition: all 0.2s;
+    position: relative;
+}
+
+.icon-button:hover {
+    opacity: 1;
+    background: rgba(0, 0, 0, 0.05);
+}
+
+[data-theme="dark"] .icon-button:hover {
+    background: rgba(255, 255, 255, 0.1);
+}
+
+.progress-panel-content {
+    padding: var(--space-2);
+}
+
+.download-progress-info {
+    margin-bottom: var(--space-2);
+}
+
+.progress-status {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 8px;
+    font-size: 0.9em;
+    color: var(--text-color);
+}
+
+/* Use specific selectors to avoid conflicts with loading.css */
+.progress-panel .progress-container {
+    width: 100%;
+    background-color: var(--lora-border);
+    border-radius: 4px;
+    overflow: hidden;
+    height: var(--space-1);
+}
+
+.progress-panel .progress-bar {
+    width: 0%;
+    height: 100%;
+    background-color: var(--lora-accent);
+    transition: width 0.5s ease;
+}
+
+.current-model-info {
+    background: var(--bg-color);
+    border-radius: var(--border-radius-xs);
+    padding: 8px;
+    margin-bottom: var(--space-2);
+    font-size: 0.95em;
+}
+
+.current-label {
+    font-size: 0.85em;
+    color: var(--text-color);
+    opacity: 0.7;
+    margin-bottom: 4px;
+}
+
+.current-model-name {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    color: var(--text-color);
+}
+
+.download-stats {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: var(--space-2);
+}
+
+.stat-item {
+    font-size: 0.9em;
+    color: var(--text-color);
+}
+
+.stat-label {
+    opacity: 0.7;
+    margin-right: 4px;
+}
+
+.download-errors {
+    background: oklch(var(--lora-warning) / 0.1);
+    border: 1px solid var(--lora-warning);
+    border-radius: var(--border-radius-xs);
+    padding: var(--space-1);
+    max-height: 100px;
+    overflow-y: auto;
+    font-size: 0.85em;
+}
+
+.error-header {
+    color: var(--lora-warning);
+    font-weight: 500;
+    margin-bottom: 4px;
+}
+
+.error-list {
+    color: var(--text-color);
+    opacity: 0.85;
+}
+
+.hidden {
+    display: none !important;
+}
+
+/* Mini progress indicator on pause button when panel collapsed */
+.mini-progress-container {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    pointer-events: none;
+    opacity: 0; /* Hide by default */
+    transition: opacity 0.2s ease;
+}
+
+/* Show mini progress when panel is collapsed */
+.progress-panel.collapsed .mini-progress-container {
+    opacity: 1;
+}
+
+.mini-progress-circle {
+    stroke: var(--lora-accent);
+    fill: none;
+    stroke-width: 2.5;
+    stroke-linecap: round;
+    transform: rotate(-90deg);
+    transform-origin: center;
+    transition: stroke-dashoffset 0.3s ease;
+}
+
+.mini-progress-background {
+    stroke: var(--lora-border);
+    fill: none;
+    stroke-width: 2;
+}
+
+.progress-percent {
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 0.65em;
+    color: var(--text-color);
+    opacity: 0.8;
+    white-space: nowrap;
+}

static/css/components/support-modal.css

@@ -117,9 +117,50 @@
     box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
 }
 
+/* QR Code section styles */
+.qrcode-toggle {
+    width: 100%;
+    margin-top: var(--space-2);
+    justify-content: center;
+    position: relative;
+}
+
+.qrcode-toggle .toggle-icon {
+    margin-left: 8px;
+    transition: transform 0.3s ease;
+}
+
+.qrcode-toggle.active .toggle-icon {
+    transform: rotate(180deg);
+}
+
+.qrcode-container {
+    max-height: 0;
+    overflow: hidden;
+    transition: max-height 0.4s ease, opacity 0.3s ease;
+    opacity: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+
+.qrcode-container.show {
+    max-height: 500px;
+    opacity: 1;
+    margin-top: var(--space-3);
+}
+
+.qrcode-image {
+    max-width: 80%;
+    height: auto;
+    border-radius: var(--border-radius-sm);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--lora-border);
+    aspect-ratio: 1/1; /* Ensure proper aspect ratio for the square QR code */
+}
+
 .support-footer {
     text-align: center;
-    margin-top: var(--space-1);
     font-style: italic;
     color: var(--text-color);
 }

static/css/layout.css

@@ -81,6 +81,22 @@
     opacity: 1;
 }
 
+/* Controls */
+.control-group button.favorite-filter {
+    position: relative;
+    overflow: hidden;
+}
+
+.control-group button.favorite-filter.active {
+    background: var(--lora-accent);
+    color: white;
+}
+
+.control-group button.favorite-filter i {
+    margin-right: 4px;
+    color: #ffc107;
+}
+
 /* Active state for buttons that can be toggled */
 .control-group button.active {
     background: var(--lora-accent);
@@ -244,8 +260,8 @@
 /* Back to Top Button */
 .back-to-top {
     position: fixed;
-    bottom: 20px;
-    right: 20px;
+    bottom: 85px;
+    right: 30px;
     width: 36px;
     height: 36px;
     border-radius: 50%;

static/css/style.css

@@ -20,6 +20,8 @@
 @import 'components/shared.css';
 @import 'components/filter-indicator.css';
 @import 'components/initialization.css';
+@import 'components/progress-panel.css';
+@import 'components/alphabet-bar.css'; /* Add alphabet bar component */
 
 .initialization-notice {
     display: flex;

static/js/api/baseModelApi.js

@@ -2,7 +2,7 @@
 import { state, getCurrentPageState } from '../state/index.js';
 import { showToast } from '../utils/uiHelpers.js';
 import { showDeleteModal, confirmDelete } from '../utils/modalUtils.js';
-import { getSessionItem } from '../utils/storageHelpers.js';
+import { getSessionItem, saveMapToStorage } from '../utils/storageHelpers.js';
 
 /**
  * Shared functionality for handling models (loras and checkpoints)
@@ -45,6 +45,16 @@ export async function loadMoreModels(options = {}) {
             params.append('folder', pageState.activeFolder);
         }
 
+        // Add favorites filter parameter if enabled
+        if (pageState.showFavoritesOnly) {
+            params.append('favorites_only', 'true');
+        }
+        
+        // Add active letter filter if set
+        if (pageState.activeLetterFilter) {
+            params.append('first_letter', pageState.activeLetterFilter);
+        }
+
         // Add search parameters if there's a search term
         if (pageState.filters?.search) {
             params.append('search', pageState.filters.search);
@@ -198,13 +208,44 @@ export function replaceModelPreview(filePath, modelType = 'lora') {
 }
 
 // Delete a model (generic)
-export function deleteModel(filePath, modelType = 'lora') {
-    if (modelType === 'checkpoint') {
-        confirmDelete('Are you sure you want to delete this checkpoint?', () => {
-            performDelete(filePath, modelType);
+export async function deleteModel(filePath, modelType = 'lora') {
+    try {
+        const endpoint = modelType === 'checkpoint' 
+            ? '/api/checkpoints/delete' 
+            : '/api/delete_model';
+            
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                file_path: filePath
+            })
         });
-    } else {
-        showDeleteModal(filePath);
+        
+        if (!response.ok) {
+            throw new Error(`Failed to delete ${modelType}: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            // Remove the card from UI
+            const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+            if (card) {
+                card.remove();
+            }
+            
+            showToast(`${modelType} deleted successfully`, 'success');
+            return true;
+        } else {
+            throw new Error(data.error || `Failed to delete ${modelType}`);
+        }
+    } catch (error) {
+        console.error(`Error deleting ${modelType}:`, error);
+        showToast(`Failed to delete ${modelType}: ${error.message}`, 'error');
+        return false;
     }
 }
 
@@ -384,6 +425,48 @@ export async function refreshSingleModelMetadata(filePath, modelType = 'lora') {
     }
 }
 
+// Generic function to exclude a model
+export async function excludeModel(filePath, modelType = 'lora') {
+    try {
+        const endpoint = modelType === 'checkpoint' 
+            ? '/api/checkpoints/exclude' 
+            : '/api/loras/exclude';
+            
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                file_path: filePath
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to exclude ${modelType}: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            // Remove the card from UI
+            const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+            if (card) {
+                card.remove();
+            }
+            
+            showToast(`${modelType} excluded successfully`, 'success');
+            return true;
+        } else {
+            throw new Error(data.error || `Failed to exclude ${modelType}`);
+        }
+    } catch (error) {
+        console.error(`Error excluding ${modelType}:`, error);
+        showToast(`Failed to exclude ${modelType}: ${error.message}`, 'error');
+        return false;
+    }
+}
+
 // Private methods
 
 // Upload a preview image
@@ -424,12 +507,20 @@ async function uploadPreview(filePath, file, modelType = 'lora') {
             const previewContainer = card.querySelector('.card-preview');
             const oldPreview = previewContainer.querySelector('img, video');
             
-            // For LoRA models, use timestamp to prevent caching
-            if (modelType === 'lora') {
-                state.previewVersions?.set(filePath, Date.now());
+            // Get the current page's previewVersions Map based on model type
+            const pageType = modelType === 'checkpoint' ? 'checkpoints' : 'loras';
+            const previewVersions = state.pages[pageType].previewVersions;
+            
+            // Update the version timestamp
+            const timestamp = Date.now();
+            if (previewVersions) {
+                previewVersions.set(filePath, timestamp);
+                
+                // Save the updated Map to localStorage
+                const storageKey = modelType === 'checkpoint' ? 'checkpoint_preview_versions' : 'lora_preview_versions';
+                saveMapToStorage(storageKey, previewVersions);
             }
             
-            const timestamp = Date.now();
             const previewUrl = data.preview_url ? 
                 `${data.preview_url}?t=${timestamp}` : 
                 `/api/model/preview_image?path=${encodeURIComponent(filePath)}&t=${timestamp}`;

static/js/api/checkpointApi.js

@@ -5,7 +5,9 @@ import {
     refreshModels as baseRefreshModels,
     deleteModel as baseDeleteModel,
     replaceModelPreview,
-    fetchCivitaiMetadata
+    fetchCivitaiMetadata,
+    refreshSingleModelMetadata,
+    excludeModel as baseExcludeModel
 } from './baseModelApi.js';
 
 // Load more checkpoints with pagination
@@ -54,4 +56,43 @@ export async function fetchCivitai() {
         fetchEndpoint: '/api/checkpoints/fetch-all-civitai',
         resetAndReloadFunction: resetAndReload
     });
+}
+
+// Refresh single checkpoint metadata
+export async function refreshSingleCheckpointMetadata(filePath) {
+    return refreshSingleModelMetadata(filePath, 'checkpoint');
+}
+
+/**
+ * Save model metadata to the server
+ * @param {string} filePath - Path to the model file
+ * @param {Object} data - Metadata to save
+ * @returns {Promise} - Promise that resolves with the server response
+ */
+export async function saveModelMetadata(filePath, data) {
+    const response = await fetch('/api/checkpoints/save-metadata', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            file_path: filePath,
+            ...data
+        })
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to save metadata');
+    }
+    
+    return response.json();
+}
+
+/**
+ * Exclude a checkpoint model from being shown in the UI
+ * @param {string} filePath - File path of the checkpoint to exclude
+ * @returns {Promise<boolean>} Promise resolving to success status
+ */
+export function excludeCheckpoint(filePath) {
+    return baseExcludeModel(filePath, 'checkpoint');
 }

static/js/api/loraApi.js

@@ -6,9 +6,44 @@ import {
     deleteModel as baseDeleteModel,
     replaceModelPreview,
     fetchCivitaiMetadata,
-    refreshSingleModelMetadata
+    refreshSingleModelMetadata,
+    excludeModel as baseExcludeModel
 } from './baseModelApi.js';
 
+/**
+ * Save model metadata to the server
+ * @param {string} filePath - File path
+ * @param {Object} data - Data to save
+ * @returns {Promise} Promise of the save operation
+ */
+export async function saveModelMetadata(filePath, data) {
+    const response = await fetch('/api/loras/save-metadata', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            file_path: filePath,
+            ...data
+        })
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to save metadata');
+    }
+    
+    return response.json();
+}
+
+/**
+ * Exclude a lora model from being shown in the UI
+ * @param {string} filePath - File path of the model to exclude
+ * @returns {Promise<boolean>} Promise resolving to success status
+ */
+export async function excludeLora(filePath) {
+    return baseExcludeModel(filePath, 'lora');
+}
+
 export async function loadMoreLoras(resetPage = false, updateFolders = false) {
     return loadMoreModels({
         resetPage,

static/js/checkpoints.js

@@ -1,9 +1,10 @@
 import { appCore } from './core.js';
 import { initializeInfiniteScroll } from './utils/infiniteScroll.js';
-import { confirmDelete, closeDeleteModal } from './utils/modalUtils.js';
+import { confirmDelete, closeDeleteModal, confirmExclude, closeExcludeModal } from './utils/modalUtils.js';
 import { createPageControls } from './components/controls/index.js';
 import { loadMoreCheckpoints } from './api/checkpointApi.js';
 import { CheckpointDownloadManager } from './managers/CheckpointDownloadManager.js';
+import { CheckpointContextMenu } from './components/ContextMenu/index.js';
 
 // Initialize the Checkpoints page
 class CheckpointsPageManager {
@@ -22,6 +23,8 @@ class CheckpointsPageManager {
         // Minimal set of functions that need to remain global
         window.confirmDelete = confirmDelete;
         window.closeDeleteModal = closeDeleteModal;
+        window.confirmExclude = confirmExclude;
+        window.closeExcludeModal = closeExcludeModal;
         
         // Add loadCheckpoints function to window for FilterManager compatibility
         window.checkpointManager = {
@@ -34,6 +37,9 @@ class CheckpointsPageManager {
         this.pageControls.restoreFolderFilter();
         this.pageControls.initFolderTagsVisibility();
         
+        // Initialize context menu
+        new CheckpointContextMenu();
+        
         // Initialize infinite scroll
         initializeInfiniteScroll('checkpoints');
         

static/js/components/CheckpointCard.js

@@ -1,8 +1,9 @@
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { showCheckpointModal } from './checkpointModal/index.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
-import { replaceCheckpointPreview as apiReplaceCheckpointPreview } from '../api/checkpointApi.js';
+import { replaceCheckpointPreview as apiReplaceCheckpointPreview, saveModelMetadata } from '../api/checkpointApi.js';
+import { showDeleteModal } from '../utils/modalUtils.js';
 
 export function createCheckpointCard(checkpoint) {
     const card = document.createElement('div');
@@ -17,6 +18,7 @@ export function createCheckpointCard(checkpoint) {
     card.dataset.from_civitai = checkpoint.from_civitai;
     card.dataset.notes = checkpoint.notes || '';
     card.dataset.base_model = checkpoint.base_model || 'Unknown';
+    card.dataset.favorite = checkpoint.favorite ? 'true' : 'false';
 
     // Store metadata if available
     if (checkpoint.civitai) {
@@ -44,7 +46,10 @@ export function createCheckpointCard(checkpoint) {
 
     // Determine preview URL
     const previewUrl = checkpoint.preview_url || '/loras_static/images/no-preview.png';
-    const version = state.previewVersions ? state.previewVersions.get(checkpoint.file_path) : null;
+    
+    // Get the page-specific previewVersions map
+    const previewVersions = state.pages.checkpoints.previewVersions || new Map();
+    const version = previewVersions.get(checkpoint.file_path);
     const versionedPreviewUrl = version ? `${previewUrl}?t=${version}` : previewUrl;
 
     // Determine NSFW warning text based on level
@@ -62,6 +67,9 @@ export function createCheckpointCard(checkpoint) {
     const isVideo = previewUrl.endsWith('.mp4');
     const videoAttrs = autoplayOnHover ? 'controls muted loop' : 'controls autoplay muted loop';
 
+    // Get favorite status from checkpoint data
+    const isFavorite = checkpoint.favorite === true;
+
     card.innerHTML = `
         <div class="card-preview ${shouldBlur ? 'blurred' : ''}">
             ${isVideo ? 
@@ -79,6 +87,9 @@ export function createCheckpointCard(checkpoint) {
                     ${checkpoint.base_model}
                 </span>
                 <div class="card-actions">
+                    <i class="${isFavorite ? 'fas fa-star favorite-active' : 'far fa-star'}" 
+                       title="${isFavorite ? 'Remove from favorites' : 'Add to favorites'}">
+                    </i>
                     <i class="fas fa-globe" 
                        title="${checkpoint.from_civitai ? 'View on Civitai' : 'Not available from Civitai'}"
                        ${!checkpoint.from_civitai ? 'style="opacity: 0.5; cursor: not-allowed"' : ''}>
@@ -195,27 +206,46 @@ export function createCheckpointCard(checkpoint) {
         });
     }
 
+    // Favorite button click event
+    card.querySelector('.fa-star')?.addEventListener('click', async e => {
+        e.stopPropagation();
+        const starIcon = e.currentTarget;
+        const isFavorite = starIcon.classList.contains('fas');
+        const newFavoriteState = !isFavorite;
+        
+        try {
+            // Save the new favorite state to the server
+            await saveModelMetadata(card.dataset.filepath, { 
+                favorite: newFavoriteState 
+            });
+
+            // Update the UI
+            if (newFavoriteState) {
+                starIcon.classList.remove('far');
+                starIcon.classList.add('fas', 'favorite-active');
+                starIcon.title = 'Remove from favorites';
+                card.dataset.favorite = 'true';
+                showToast('Added to favorites', 'success');
+            } else {
+                starIcon.classList.remove('fas', 'favorite-active');
+                starIcon.classList.add('far');
+                starIcon.title = 'Add to favorites';
+                card.dataset.favorite = 'false';
+                showToast('Removed from favorites', 'success');
+            }
+        } catch (error) {
+            console.error('Failed to update favorite status:', error);
+            showToast('Failed to update favorite status', 'error');
+        }
+    });
+
     // Copy button click event
     card.querySelector('.fa-copy')?.addEventListener('click', async e => {
         e.stopPropagation();
         const checkpointName = card.dataset.file_name;
         
         try {
-            // Modern clipboard API
-            if (navigator.clipboard && window.isSecureContext) {
-                await navigator.clipboard.writeText(checkpointName);
-            } else {
-                // Fallback for older browsers
-                const textarea = document.createElement('textarea');
-                textarea.value = checkpointName;
-                textarea.style.position = 'absolute';
-                textarea.style.left = '-99999px';
-                document.body.appendChild(textarea);
-                textarea.select();
-                document.execCommand('copy');
-                document.body.removeChild(textarea);
-            }
-            showToast('Checkpoint name copied', 'success');
+            await copyToClipboard(checkpointName, 'Checkpoint name copied');
         } catch (err) {
             console.error('Copy failed:', err);
             showToast('Copy failed', 'error');
@@ -233,7 +263,7 @@ export function createCheckpointCard(checkpoint) {
     // Delete button click event
     card.querySelector('.fa-trash')?.addEventListener('click', e => {
         e.stopPropagation();
-        deleteCheckpoint(checkpoint.file_path);
+        showDeleteModal(checkpoint.file_path);
     });
 
     // Replace preview button click event
@@ -293,17 +323,6 @@ function openCivitai(modelName) {
     }
 }
 
-function deleteCheckpoint(filePath) {
-    if (window.deleteCheckpoint) {
-        window.deleteCheckpoint(filePath);
-    } else {
-        // Use the modal delete functionality
-        import('../utils/modalUtils.js').then(({ showDeleteModal }) => {
-            showDeleteModal(filePath, 'checkpoint');
-        });
-    }
-}
-
 function replaceCheckpointPreview(filePath) {
     if (window.replaceCheckpointPreview) {
         window.replaceCheckpointPreview(filePath);

static/js/components/ContextMenu.js

@@ -366,4 +366,7 @@ export class LoraContextMenu {
         this.menu.style.display = 'none';
         this.currentCard = null;
     }
-}
+}
+
+// For backward compatibility, re-export the LoraContextMenu class
+// export { LoraContextMenu } from './ContextMenu/LoraContextMenu.js';

static/js/components/ContextMenu/BaseContextMenu.js

@@ -0,0 +1,84 @@
+export class BaseContextMenu {
+    constructor(menuId, cardSelector) {
+        this.menu = document.getElementById(menuId);
+        this.cardSelector = cardSelector;
+        this.currentCard = null;
+        
+        if (!this.menu) {
+            console.error(`Context menu element with ID ${menuId} not found`);
+            return;
+        }
+        
+        this.init();
+    }
+
+    init() {
+        // Hide menu on regular clicks
+        document.addEventListener('click', () => this.hideMenu());
+        
+        // Show menu on right-click on cards
+        document.addEventListener('contextmenu', (e) => {
+            const card = e.target.closest(this.cardSelector);
+            if (!card) {
+                this.hideMenu();
+                return;
+            }
+            e.preventDefault();
+            this.showMenu(e.clientX, e.clientY, card);
+        });
+
+        // Handle menu item clicks
+        this.menu.addEventListener('click', (e) => {
+            const menuItem = e.target.closest('.context-menu-item');
+            if (!menuItem || !this.currentCard) return;
+
+            const action = menuItem.dataset.action;
+            if (!action) return;
+            
+            this.handleMenuAction(action, menuItem);
+            this.hideMenu();
+        });
+    }
+    
+    handleMenuAction(action, menuItem) {
+        // Override in subclass
+        console.warn('handleMenuAction not implemented');
+    }
+
+    showMenu(x, y, card) {
+        this.currentCard = card;
+        this.menu.style.display = 'block';
+
+        // Get menu dimensions
+        const menuRect = this.menu.getBoundingClientRect();
+        
+        // Get viewport dimensions
+        const viewportWidth = document.documentElement.clientWidth;
+        const viewportHeight = document.documentElement.clientHeight;
+        
+        // Calculate position
+        let finalX = x;
+        let finalY = y;
+        
+        // Ensure menu doesn't go offscreen right
+        if (x + menuRect.width > viewportWidth) {
+            finalX = x - menuRect.width;
+        }
+        
+        // Ensure menu doesn't go offscreen bottom
+        if (y + menuRect.height > viewportHeight) {
+            finalY = y - menuRect.height;
+        }
+        
+        // Position menu
+        this.menu.style.left = `${finalX}px`;
+        this.menu.style.top = `${finalY}px`;
+    }
+
+    hideMenu() {
+        if (this.menu) {
+            this.menu.style.display = 'none';
+        }
+        this.currentCard = null;
+    }
+}

static/js/components/ContextMenu/CheckpointContextMenu.js

@@ -0,0 +1,320 @@
+import { BaseContextMenu } from './BaseContextMenu.js';
+import { refreshSingleCheckpointMetadata, saveModelMetadata } from '../../api/checkpointApi.js';
+import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
+import { NSFW_LEVELS } from '../../utils/constants.js';
+import { getStorageItem } from '../../utils/storageHelpers.js';
+import { showExcludeModal } from '../../utils/modalUtils.js';
+
+export class CheckpointContextMenu extends BaseContextMenu {
+    constructor() {
+        super('checkpointContextMenu', '.lora-card');
+        this.nsfwSelector = document.getElementById('nsfwLevelSelector');
+        
+        // Initialize NSFW Level Selector events
+        if (this.nsfwSelector) {
+            this.initNSFWSelector();
+        }
+    }
+    
+    handleMenuAction(action) {
+        switch(action) {
+            case 'details':
+                // Show checkpoint details
+                this.currentCard.click();
+                break;
+            case 'preview':
+                // Replace checkpoint preview
+                if (this.currentCard.querySelector('.fa-image')) {
+                    this.currentCard.querySelector('.fa-image').click();
+                }
+                break;
+            case 'civitai':
+                // Open civitai page
+                if (this.currentCard.dataset.from_civitai === 'true') {
+                    if (this.currentCard.querySelector('.fa-globe')) {
+                        this.currentCard.querySelector('.fa-globe').click();
+                    }
+                } else {
+                    showToast('No CivitAI information available', 'info');
+                }
+                break;
+            case 'delete':
+                // Delete checkpoint
+                if (this.currentCard.querySelector('.fa-trash')) {
+                    this.currentCard.querySelector('.fa-trash').click();
+                }
+                break;
+            case 'copyname':
+                // Copy checkpoint name
+                if (this.currentCard.querySelector('.fa-copy')) {
+                    this.currentCard.querySelector('.fa-copy').click();
+                }
+                break;
+            case 'refresh-metadata':
+                // Refresh metadata from CivitAI
+                refreshSingleCheckpointMetadata(this.currentCard.dataset.filepath);
+                break;
+            case 'set-nsfw':
+                // Set NSFW level
+                this.showNSFWLevelSelector(null, null, this.currentCard);
+                break;
+            case 'move':
+                // Move to folder (placeholder)
+                showToast('Move to folder feature coming soon', 'info');
+                break;
+            case 'exclude':
+                showExcludeModal(this.currentCard.dataset.filepath, 'checkpoint');
+                break;
+
+        }
+    }
+
+    // NSFW Selector methods
+    initNSFWSelector() {
+        // Close button
+        const closeBtn = this.nsfwSelector.querySelector('.close-nsfw-selector');
+        closeBtn.addEventListener('click', () => {
+            this.nsfwSelector.style.display = 'none';
+        });
+
+        // Level buttons
+        const levelButtons = this.nsfwSelector.querySelectorAll('.nsfw-level-btn');
+        levelButtons.forEach(btn => {
+            btn.addEventListener('click', async () => {
+                const level = parseInt(btn.dataset.level);
+                const filePath = this.nsfwSelector.dataset.cardPath;
+                
+                if (!filePath) return;
+                
+                try {
+                    await saveModelMetadata(filePath, { preview_nsfw_level: level });
+                    
+                    // Update card data
+                    const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+                    if (card) {
+                        let metaData = {};
+                        try {
+                            metaData = JSON.parse(card.dataset.meta || '{}');
+                        } catch (err) {
+                            console.error('Error parsing metadata:', err);
+                        }
+                        
+                        metaData.preview_nsfw_level = level;
+                        card.dataset.meta = JSON.stringify(metaData);
+                        card.dataset.nsfwLevel = level.toString();
+                        
+                        // Apply blur effect immediately
+                        this.updateCardBlurEffect(card, level);
+                    }
+                    
+                    showToast(`Content rating set to ${getNSFWLevelName(level)}`, 'success');
+                    this.nsfwSelector.style.display = 'none';
+                } catch (error) {
+                    showToast(`Failed to set content rating: ${error.message}`, 'error');
+                }
+            });
+        });
+        
+        // Close when clicking outside
+        document.addEventListener('click', (e) => {
+            if (this.nsfwSelector.style.display === 'block' && 
+                !this.nsfwSelector.contains(e.target) && 
+                !e.target.closest('.context-menu-item[data-action="set-nsfw"]')) {
+                this.nsfwSelector.style.display = 'none';
+            }
+        });
+    }
+
+    updateCardBlurEffect(card, level) {
+        // Get user settings for blur threshold
+        const blurThreshold = parseInt(getStorageItem('nsfwBlurLevel') || '4');
+        
+        // Get card preview container
+        const previewContainer = card.querySelector('.card-preview');
+        if (!previewContainer) return;
+        
+        // Get preview media element
+        const previewMedia = previewContainer.querySelector('img') || previewContainer.querySelector('video');
+        if (!previewMedia) return;
+        
+        // Check if blur should be applied
+        if (level >= blurThreshold) {
+            // Add blur class to the preview container
+            previewContainer.classList.add('blurred');
+            
+            // Get or create the NSFW overlay
+            let nsfwOverlay = previewContainer.querySelector('.nsfw-overlay');
+            if (!nsfwOverlay) {
+                // Create new overlay
+                nsfwOverlay = document.createElement('div');
+                nsfwOverlay.className = 'nsfw-overlay';
+                
+                // Create and configure the warning content
+                const warningContent = document.createElement('div');
+                warningContent.className = 'nsfw-warning';
+                
+                // Determine NSFW warning text based on level
+                let nsfwText = "Mature Content";
+                if (level >= NSFW_LEVELS.XXX) {
+                    nsfwText = "XXX-rated Content";
+                } else if (level >= NSFW_LEVELS.X) {
+                    nsfwText = "X-rated Content";
+                } else if (level >= NSFW_LEVELS.R) {
+                    nsfwText = "R-rated Content";
+                }
+                
+                // Add warning text and show button
+                warningContent.innerHTML = `
+                    <p>${nsfwText}</p>
+                    <button class="show-content-btn">Show</button>
+                `;
+                
+                // Add click event to the show button
+                const showBtn = warningContent.querySelector('.show-content-btn');
+                showBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    previewContainer.classList.remove('blurred');
+                    nsfwOverlay.style.display = 'none';
+                    
+                    // Update toggle button icon if it exists
+                    const toggleBtn = card.querySelector('.toggle-blur-btn');
+                    if (toggleBtn) {
+                        toggleBtn.querySelector('i').className = 'fas fa-eye-slash';
+                    }
+                });
+                
+                nsfwOverlay.appendChild(warningContent);
+                previewContainer.appendChild(nsfwOverlay);
+            } else {
+                // Update existing overlay
+                const warningText = nsfwOverlay.querySelector('p');
+                if (warningText) {
+                    let nsfwText = "Mature Content";
+                    if (level >= NSFW_LEVELS.XXX) {
+                        nsfwText = "XXX-rated Content";
+                    } else if (level >= NSFW_LEVELS.X) {
+                        nsfwText = "X-rated Content";
+                    } else if (level >= NSFW_LEVELS.R) {
+                        nsfwText = "R-rated Content";
+                    }
+                    warningText.textContent = nsfwText;
+                }
+                nsfwOverlay.style.display = 'flex';
+            }
+            
+            // Get or create the toggle button in the header
+            const cardHeader = previewContainer.querySelector('.card-header');
+            if (cardHeader) {
+                let toggleBtn = cardHeader.querySelector('.toggle-blur-btn');
+                
+                if (!toggleBtn) {
+                    toggleBtn = document.createElement('button');
+                    toggleBtn.className = 'toggle-blur-btn';
+                    toggleBtn.title = 'Toggle blur';
+                    toggleBtn.innerHTML = '<i class="fas fa-eye"></i>';
+                    
+                    // Add click event to toggle button
+                    toggleBtn.addEventListener('click', (e) => {
+                        e.stopPropagation();
+                        const isBlurred = previewContainer.classList.toggle('blurred');
+                        const icon = toggleBtn.querySelector('i');
+                        
+                        // Update icon and overlay visibility
+                        if (isBlurred) {
+                            icon.className = 'fas fa-eye';
+                            nsfwOverlay.style.display = 'flex';
+                        } else {
+                            icon.className = 'fas fa-eye-slash';
+                            nsfwOverlay.style.display = 'none';
+                        }
+                    });
+                    
+                    // Add to the beginning of header
+                    cardHeader.insertBefore(toggleBtn, cardHeader.firstChild);
+                    
+                    // Update base model label class
+                    const baseModelLabel = cardHeader.querySelector('.base-model-label');
+                    if (baseModelLabel && !baseModelLabel.classList.contains('with-toggle')) {
+                        baseModelLabel.classList.add('with-toggle');
+                    }
+                } else {
+                    // Update existing toggle button
+                    toggleBtn.querySelector('i').className = 'fas fa-eye';
+                }
+            }
+        } else {
+            // Remove blur
+            previewContainer.classList.remove('blurred');
+            
+            // Hide overlay if it exists
+            const overlay = previewContainer.querySelector('.nsfw-overlay');
+            if (overlay) overlay.style.display = 'none';
+            
+            // Remove toggle button when content is set to PG or PG13
+            const cardHeader = previewContainer.querySelector('.card-header');
+            if (cardHeader) {
+                const toggleBtn = cardHeader.querySelector('.toggle-blur-btn');
+                if (toggleBtn) {
+                    // Remove the toggle button completely
+                    toggleBtn.remove();
+                    
+                    // Update base model label class if it exists
+                    const baseModelLabel = cardHeader.querySelector('.base-model-label');
+                    if (baseModelLabel && baseModelLabel.classList.contains('with-toggle')) {
+                        baseModelLabel.classList.remove('with-toggle');
+                    }
+                }
+            }
+        }
+    }
+
+    showNSFWLevelSelector(x, y, card) {
+        const selector = document.getElementById('nsfwLevelSelector');
+        const currentLevelEl = document.getElementById('currentNSFWLevel');
+        
+        // Get current NSFW level
+        let currentLevel = 0;
+        try {
+            const metaData = JSON.parse(card.dataset.meta || '{}');
+            currentLevel = metaData.preview_nsfw_level || 0;
+            
+            // Update if we have no recorded level but have a dataset attribute
+            if (!currentLevel && card.dataset.nsfwLevel) {
+                currentLevel = parseInt(card.dataset.nsfwLevel) || 0;
+            }
+        } catch (err) {
+            console.error('Error parsing metadata:', err);
+        }
+        
+        currentLevelEl.textContent = getNSFWLevelName(currentLevel);
+        
+        // Position the selector
+        if (x && y) {
+            const viewportWidth = document.documentElement.clientWidth;
+            const viewportHeight = document.documentElement.clientHeight;
+            const selectorRect = selector.getBoundingClientRect();
+            
+            // Center the selector if no coordinates provided
+            let finalX = (viewportWidth - selectorRect.width) / 2;
+            let finalY = (viewportHeight - selectorRect.height) / 2;
+            
+            selector.style.left = `${finalX}px`;
+            selector.style.top = `${finalY}px`;
+        }
+        
+        // Highlight current level button
+        document.querySelectorAll('.nsfw-level-btn').forEach(btn => {
+            if (parseInt(btn.dataset.level) === currentLevel) {
+                btn.classList.add('active');
+            } else {
+                btn.classList.remove('active');
+            }
+        });
+        
+        // Store reference to current card
+        selector.dataset.cardPath = card.dataset.filepath;
+        
+        // Show selector
+        selector.style.display = 'block';
+    }
+}

static/js/components/ContextMenu/LoraContextMenu.js

@@ -0,0 +1,313 @@
+import { BaseContextMenu } from './BaseContextMenu.js';
+import { refreshSingleLoraMetadata, saveModelMetadata } from '../../api/loraApi.js';
+import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
+import { NSFW_LEVELS } from '../../utils/constants.js';
+import { getStorageItem } from '../../utils/storageHelpers.js';
+import { showExcludeModal } from '../../utils/modalUtils.js';
+
+export class LoraContextMenu extends BaseContextMenu {
+    constructor() {
+        super('loraContextMenu', '.lora-card');
+        this.nsfwSelector = document.getElementById('nsfwLevelSelector');
+        
+        // Initialize NSFW Level Selector events
+        if (this.nsfwSelector) {
+            this.initNSFWSelector();
+        }
+    }
+
+    handleMenuAction(action, menuItem) {
+        switch(action) {
+            case 'detail':
+                // Trigger the main card click which shows the modal
+                this.currentCard.click();
+                break;
+            case 'civitai':
+                // Only trigger if the card is from civitai
+                if (this.currentCard.dataset.from_civitai === 'true') {
+                    if (this.currentCard.dataset.meta === '{}') {
+                        showToast('Please fetch metadata from CivitAI first', 'info');
+                    } else {
+                        this.currentCard.querySelector('.fa-globe')?.click();
+                    }
+                } else {
+                    showToast('No CivitAI information available', 'info');
+                }
+                break;
+            case 'copyname':
+                this.currentCard.querySelector('.fa-copy')?.click();
+                break;
+            case 'preview':
+                this.currentCard.querySelector('.fa-image')?.click();
+                break;
+            case 'delete':
+                this.currentCard.querySelector('.fa-trash')?.click();
+                break;
+            case 'move':
+                moveManager.showMoveModal(this.currentCard.dataset.filepath);
+                break;
+            case 'refresh-metadata':
+                refreshSingleLoraMetadata(this.currentCard.dataset.filepath);
+                break;
+            case 'set-nsfw':
+                this.showNSFWLevelSelector(null, null, this.currentCard);
+                break;
+            case 'exclude':
+                showExcludeModal(this.currentCard.dataset.filepath);
+                break;
+        }
+    }
+
+    // NSFW Selector methods from the original context menu
+    initNSFWSelector() {
+        // Close button
+        const closeBtn = this.nsfwSelector.querySelector('.close-nsfw-selector');
+        closeBtn.addEventListener('click', () => {
+            this.nsfwSelector.style.display = 'none';
+        });
+
+        // Level buttons
+        const levelButtons = this.nsfwSelector.querySelectorAll('.nsfw-level-btn');
+        levelButtons.forEach(btn => {
+            btn.addEventListener('click', async () => {
+                const level = parseInt(btn.dataset.level);
+                const filePath = this.nsfwSelector.dataset.cardPath;
+                
+                if (!filePath) return;
+                
+                try {
+                    await this.saveModelMetadata(filePath, { preview_nsfw_level: level });
+                    
+                    // Update card data
+                    const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+                    if (card) {
+                        let metaData = {};
+                        try {
+                            metaData = JSON.parse(card.dataset.meta || '{}');
+                        } catch (err) {
+                            console.error('Error parsing metadata:', err);
+                        }
+                        
+                        metaData.preview_nsfw_level = level;
+                        card.dataset.meta = JSON.stringify(metaData);
+                        card.dataset.nsfwLevel = level.toString();
+                        
+                        // Apply blur effect immediately
+                        this.updateCardBlurEffect(card, level);
+                    }
+                    
+                    showToast(`Content rating set to ${getNSFWLevelName(level)}`, 'success');
+                    this.nsfwSelector.style.display = 'none';
+                } catch (error) {
+                    showToast(`Failed to set content rating: ${error.message}`, 'error');
+                }
+            });
+        });
+        
+        // Close when clicking outside
+        document.addEventListener('click', (e) => {
+            if (this.nsfwSelector.style.display === 'block' && 
+                !this.nsfwSelector.contains(e.target) && 
+                !e.target.closest('.context-menu-item[data-action="set-nsfw"]')) {
+                this.nsfwSelector.style.display = 'none';
+            }
+        });
+    }
+
+    async saveModelMetadata(filePath, data) {
+        return saveModelMetadata(filePath, data);
+    }
+
+    updateCardBlurEffect(card, level) {
+        // Get user settings for blur threshold
+        const blurThreshold = parseInt(getStorageItem('nsfwBlurLevel') || '4');
+        
+        // Get card preview container
+        const previewContainer = card.querySelector('.card-preview');
+        if (!previewContainer) return;
+        
+        // Get preview media element
+        const previewMedia = previewContainer.querySelector('img') || previewContainer.querySelector('video');
+        if (!previewMedia) return;
+        
+        // Check if blur should be applied
+        if (level >= blurThreshold) {
+            // Add blur class to the preview container
+            previewContainer.classList.add('blurred');
+            
+            // Get or create the NSFW overlay
+            let nsfwOverlay = previewContainer.querySelector('.nsfw-overlay');
+            if (!nsfwOverlay) {
+                // Create new overlay
+                nsfwOverlay = document.createElement('div');
+                nsfwOverlay.className = 'nsfw-overlay';
+                
+                // Create and configure the warning content
+                const warningContent = document.createElement('div');
+                warningContent.className = 'nsfw-warning';
+                
+                // Determine NSFW warning text based on level
+                let nsfwText = "Mature Content";
+                if (level >= NSFW_LEVELS.XXX) {
+                    nsfwText = "XXX-rated Content";
+                } else if (level >= NSFW_LEVELS.X) {
+                    nsfwText = "X-rated Content";
+                } else if (level >= NSFW_LEVELS.R) {
+                    nsfwText = "R-rated Content";
+                }
+                
+                // Add warning text and show button
+                warningContent.innerHTML = `
+                    <p>${nsfwText}</p>
+                    <button class="show-content-btn">Show</button>
+                `;
+                
+                // Add click event to the show button
+                const showBtn = warningContent.querySelector('.show-content-btn');
+                showBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    previewContainer.classList.remove('blurred');
+                    nsfwOverlay.style.display = 'none';
+                    
+                    // Update toggle button icon if it exists
+                    const toggleBtn = card.querySelector('.toggle-blur-btn');
+                    if (toggleBtn) {
+                        toggleBtn.querySelector('i').className = 'fas fa-eye-slash';
+                    }
+                });
+                
+                nsfwOverlay.appendChild(warningContent);
+                previewContainer.appendChild(nsfwOverlay);
+            } else {
+                // Update existing overlay
+                const warningText = nsfwOverlay.querySelector('p');
+                if (warningText) {
+                    let nsfwText = "Mature Content";
+                    if (level >= NSFW_LEVELS.XXX) {
+                        nsfwText = "XXX-rated Content";
+                    } else if (level >= NSFW_LEVELS.X) {
+                        nsfwText = "X-rated Content";
+                    } else if (level >= NSFW_LEVELS.R) {
+                        nsfwText = "R-rated Content";
+                    }
+                    warningText.textContent = nsfwText;
+                }
+                nsfwOverlay.style.display = 'flex';
+            }
+            
+            // Get or create the toggle button in the header
+            const cardHeader = previewContainer.querySelector('.card-header');
+            if (cardHeader) {
+                let toggleBtn = cardHeader.querySelector('.toggle-blur-btn');
+                
+                if (!toggleBtn) {
+                    toggleBtn = document.createElement('button');
+                    toggleBtn.className = 'toggle-blur-btn';
+                    toggleBtn.title = 'Toggle blur';
+                    toggleBtn.innerHTML = '<i class="fas fa-eye"></i>';
+                    
+                    // Add click event to toggle button
+                    toggleBtn.addEventListener('click', (e) => {
+                        e.stopPropagation();
+                        const isBlurred = previewContainer.classList.toggle('blurred');
+                        const icon = toggleBtn.querySelector('i');
+                        
+                        // Update icon and overlay visibility
+                        if (isBlurred) {
+                            icon.className = 'fas fa-eye';
+                            nsfwOverlay.style.display = 'flex';
+                        } else {
+                            icon.className = 'fas fa-eye-slash';
+                            nsfwOverlay.style.display = 'none';
+                        }
+                    });
+                    
+                    // Add to the beginning of header
+                    cardHeader.insertBefore(toggleBtn, cardHeader.firstChild);
+                    
+                    // Update base model label class
+                    const baseModelLabel = cardHeader.querySelector('.base-model-label');
+                    if (baseModelLabel && !baseModelLabel.classList.contains('with-toggle')) {
+                        baseModelLabel.classList.add('with-toggle');
+                    }
+                } else {
+                    // Update existing toggle button
+                    toggleBtn.querySelector('i').className = 'fas fa-eye';
+                }
+            }
+        } else {
+            // Remove blur
+            previewContainer.classList.remove('blurred');
+            
+            // Hide overlay if it exists
+            const overlay = previewContainer.querySelector('.nsfw-overlay');
+            if (overlay) overlay.style.display = 'none';
+            
+            // Remove toggle button when content is set to PG or PG13
+            const cardHeader = previewContainer.querySelector('.card-header');
+            if (cardHeader) {
+                const toggleBtn = cardHeader.querySelector('.toggle-blur-btn');
+                if (toggleBtn) {
+                    // Remove the toggle button completely
+                    toggleBtn.remove();
+                    
+                    // Update base model label class if it exists
+                    const baseModelLabel = cardHeader.querySelector('.base-model-label');
+                    if (baseModelLabel && baseModelLabel.classList.contains('with-toggle')) {
+                        baseModelLabel.classList.remove('with-toggle');
+                    }
+                }
+            }
+        }
+    }
+
+    showNSFWLevelSelector(x, y, card) {
+        const selector = document.getElementById('nsfwLevelSelector');
+        const currentLevelEl = document.getElementById('currentNSFWLevel');
+        
+        // Get current NSFW level
+        let currentLevel = 0;
+        try {
+            const metaData = JSON.parse(card.dataset.meta || '{}');
+            currentLevel = metaData.preview_nsfw_level || 0;
+            
+            // Update if we have no recorded level but have a dataset attribute
+            if (!currentLevel && card.dataset.nsfwLevel) {
+                currentLevel = parseInt(card.dataset.nsfwLevel) || 0;
+            }
+        } catch (err) {
+            console.error('Error parsing metadata:', err);
+        }
+        
+        currentLevelEl.textContent = getNSFWLevelName(currentLevel);
+        
+        // Position the selector
+        if (x && y) {
+            const viewportWidth = document.documentElement.clientWidth;
+            const viewportHeight = document.documentElement.clientHeight;
+            const selectorRect = selector.getBoundingClientRect();
+            
+            // Center the selector if no coordinates provided
+            let finalX = (viewportWidth - selectorRect.width) / 2;
+            let finalY = (viewportHeight - selectorRect.height) / 2;
+            
+            selector.style.left = `${finalX}px`;
+            selector.style.top = `${finalY}px`;
+        }
+        
+        // Highlight current level button
+        document.querySelectorAll('.nsfw-level-btn').forEach(btn => {
+            if (parseInt(btn.dataset.level) === currentLevel) {
+                btn.classList.add('active');
+            } else {
+                btn.classList.remove('active');
+            }
+        });
+        
+        // Store reference to current card
+        selector.dataset.cardPath = card.dataset.filepath;
+        
+        // Show selector
+        selector.style.display = 'block';
+    }
+}

static/js/components/ContextMenu/RecipeContextMenu.js

@@ -0,0 +1,205 @@
+import { BaseContextMenu } from './BaseContextMenu.js';
+import { showToast } from '../../utils/uiHelpers.js';
+import { setSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
+import { state } from '../../state/index.js';
+
+export class RecipeContextMenu extends BaseContextMenu {
+    constructor() {
+        super('recipeContextMenu', '.lora-card');
+    }
+    
+    showMenu(x, y, card) {
+        // Call the parent method first to handle basic positioning
+        super.showMenu(x, y, card);
+        
+        // Get recipe data to check for missing LoRAs
+        const recipeId = card.dataset.id;
+        const missingLorasItem = this.menu.querySelector('.download-missing-item');
+        
+        if (recipeId && missingLorasItem) {
+            // Check if this card has missing LoRAs
+            const loraCountElement = card.querySelector('.lora-count');
+            const hasMissingLoras = loraCountElement && loraCountElement.classList.contains('missing');
+            
+            // Show/hide the download missing LoRAs option based on missing status
+            if (hasMissingLoras) {
+                missingLorasItem.style.display = 'flex';
+            } else {
+                missingLorasItem.style.display = 'none';
+            }
+        }
+    }
+    
+    handleMenuAction(action) {
+        const recipeId = this.currentCard.dataset.id;
+        
+        switch(action) {
+            case 'details':
+                // Show recipe details
+                this.currentCard.click();
+                break;
+            case 'copy':
+                // Copy recipe to clipboard
+                this.currentCard.querySelector('.fa-copy')?.click();
+                break;
+            case 'share':
+                // Share recipe
+                this.currentCard.querySelector('.fa-share-alt')?.click();
+                break;
+            case 'delete':
+                // Delete recipe
+                this.currentCard.querySelector('.fa-trash')?.click();
+                break;
+            case 'viewloras':
+                // View all LoRAs in the recipe
+                this.viewRecipeLoRAs(recipeId);
+                break;
+            case 'download-missing':
+                // Download missing LoRAs
+                this.downloadMissingLoRAs(recipeId);
+                break;
+        }
+    }
+    
+    // View all LoRAs in the recipe
+    viewRecipeLoRAs(recipeId) {
+        if (!recipeId) {
+            showToast('Cannot view LoRAs: Missing recipe ID', 'error');
+            return;
+        }
+        
+        // First get the recipe details to access its LoRAs
+        fetch(`/api/recipe/${recipeId}`)
+            .then(response => response.json())
+            .then(recipe => {
+                // Clear any previous filters first
+                removeSessionItem('recipe_to_lora_filterLoraHash');
+                removeSessionItem('recipe_to_lora_filterLoraHashes');
+                removeSessionItem('filterRecipeName');
+                removeSessionItem('viewLoraDetail');
+                
+                // Collect all hashes from the recipe's LoRAs
+                const loraHashes = recipe.loras
+                    .filter(lora => lora.hash)
+                    .map(lora => lora.hash.toLowerCase());
+                    
+                if (loraHashes.length > 0) {
+                    // Store the LoRA hashes and recipe name in session storage
+                    setSessionItem('recipe_to_lora_filterLoraHashes', JSON.stringify(loraHashes));
+                    setSessionItem('filterRecipeName', recipe.title);
+                    
+                    // Navigate to the LoRAs page
+                    window.location.href = '/loras';
+                } else {
+                    showToast('No LoRAs found in this recipe', 'info');
+                }
+            })
+            .catch(error => {
+                console.error('Error loading recipe LoRAs:', error);
+                showToast('Error loading recipe LoRAs: ' + error.message, 'error');
+            });
+    }
+    
+    // Download missing LoRAs
+    async downloadMissingLoRAs(recipeId) {
+        if (!recipeId) {
+            showToast('Cannot download LoRAs: Missing recipe ID', 'error');
+            return;
+        }
+        
+        try {
+            // First get the recipe details
+            const response = await fetch(`/api/recipe/${recipeId}`);
+            const recipe = await response.json();
+            
+            // Get missing LoRAs
+            const missingLoras = recipe.loras.filter(lora => !lora.inLibrary && !lora.isDeleted);
+            
+            if (missingLoras.length === 0) {
+                showToast('No missing LoRAs to download', 'info');
+                return;
+            }
+            
+            // Show loading toast
+            state.loadingManager.showSimpleLoading('Getting version info for missing LoRAs...');
+            
+            // Get version info for each missing LoRA
+            const missingLorasWithVersionInfoPromises = missingLoras.map(async lora => {
+                let endpoint;
+                
+                // Determine which endpoint to use based on available data
+                if (lora.modelVersionId) {
+                    endpoint = `/api/civitai/model/version/${lora.modelVersionId}`;
+                } else if (lora.hash) {
+                    endpoint = `/api/civitai/model/hash/${lora.hash}`;
+                } else {
+                    console.error("Missing both hash and modelVersionId for lora:", lora);
+                    return null;
+                }
+                
+                const versionResponse = await fetch(endpoint);
+                const versionInfo = await versionResponse.json();
+                
+                // Return original lora data combined with version info
+                return {
+                    ...lora,
+                    civitaiInfo: versionInfo
+                };
+            });
+            
+            // Wait for all API calls to complete
+            const lorasWithVersionInfo = await Promise.all(missingLorasWithVersionInfoPromises);
+            
+            // Filter out null values (failed requests)
+            const validLoras = lorasWithVersionInfo.filter(lora => lora !== null);
+            
+            if (validLoras.length === 0) {
+                showToast('Failed to get information for missing LoRAs', 'error');
+                return;
+            }
+            
+            // Prepare data for import manager using the retrieved information
+            const recipeData = {
+                loras: validLoras.map(lora => {
+                    const civitaiInfo = lora.civitaiInfo;
+                    const modelFile = civitaiInfo.files ? 
+                        civitaiInfo.files.find(file => file.type === 'Model') : null;
+                    
+                    return {
+                        // Basic lora info
+                        name: civitaiInfo.model?.name || lora.name,
+                        version: civitaiInfo.name || '',
+                        strength: lora.strength || 1.0,
+                        
+                        // Model identifiers
+                        hash: modelFile?.hashes?.SHA256?.toLowerCase() || lora.hash,
+                        modelVersionId: civitaiInfo.id || lora.modelVersionId,
+                        
+                        // Metadata
+                        thumbnailUrl: civitaiInfo.images?.[0]?.url || '',
+                        baseModel: civitaiInfo.baseModel || '',
+                        downloadUrl: civitaiInfo.downloadUrl || '',
+                        size: modelFile ? (modelFile.sizeKB * 1024) : 0,
+                        file_name: modelFile ? modelFile.name.split('.')[0] : '',
+                        
+                        // Status flags
+                        existsLocally: false,
+                        isDeleted: civitaiInfo.error === "Model not found",
+                        isEarlyAccess: !!civitaiInfo.earlyAccessEndsAt,
+                        earlyAccessEndsAt: civitaiInfo.earlyAccessEndsAt || ''
+                    };
+                })
+            };
+            
+            // Call ImportManager's download missing LoRAs method
+            window.importManager.downloadMissingLoras(recipeData, recipeId);
+        } catch (error) {
+            console.error('Error downloading missing LoRAs:', error);
+            showToast('Error preparing LoRAs for download: ' + error.message, 'error');
+        } finally {
+            if (state.loadingManager) {
+                state.loadingManager.hide();
+            }
+        }
+    }
+}

static/js/components/ContextMenu/index.js

@@ -0,0 +1,3 @@
+export { LoraContextMenu } from './LoraContextMenu.js';
+export { RecipeContextMenu } from './RecipeContextMenu.js';
+export { CheckpointContextMenu } from './CheckpointContextMenu.js';

static/js/components/Header.js

@@ -78,5 +78,33 @@ export class HeaderManager {
           // Handle support panel logic
         });
       }
+
+      // Handle QR code toggle
+      const qrToggle = document.getElementById('toggleQRCode');
+      const qrContainer = document.getElementById('qrCodeContainer');
+      
+      if (qrToggle && qrContainer) {
+          qrToggle.addEventListener('click', function() {
+              qrContainer.classList.toggle('show');
+              qrToggle.classList.toggle('active');
+              
+              const toggleText = qrToggle.querySelector('.toggle-text');
+              if (qrContainer.classList.contains('show')) {
+                  toggleText.textContent = 'Hide WeChat QR Code';
+                  // Add small delay to ensure DOM is updated before scrolling
+                  setTimeout(() => {
+                      const supportModal = document.querySelector('.support-modal');
+                      if (supportModal) {
+                          supportModal.scrollTo({
+                              top: supportModal.scrollHeight,
+                              behavior: 'smooth'
+                          });
+                      }
+                  }, 250);
+              } else {
+                  toggleText.textContent = 'Show WeChat QR Code';
+              }
+          });
+      }
     }
 }

static/js/components/LoraCard.js

@@ -1,9 +1,10 @@
-import { showToast, openCivitai } from '../utils/uiHelpers.js';
+import { showToast, openCivitai, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { showLoraModal } from './loraModal/index.js';
 import { bulkManager } from '../managers/BulkManager.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
-import { replacePreview, deleteModel } from '../api/loraApi.js'
+import { replacePreview, saveModelMetadata } from '../api/loraApi.js'
+import { showDeleteModal } from '../utils/modalUtils.js';
 
 export function createLoraCard(lora) {
     const card = document.createElement('div');
@@ -20,6 +21,7 @@ export function createLoraCard(lora) {
     card.dataset.usage_tips = lora.usage_tips;
     card.dataset.notes = lora.notes;
     card.dataset.meta = JSON.stringify(lora.civitai || {});
+    card.dataset.favorite = lora.favorite ? 'true' : 'false';
     
     // Store tags and model description
     if (lora.tags && Array.isArray(lora.tags)) {
@@ -44,7 +46,9 @@ export function createLoraCard(lora) {
         card.classList.add('selected');
     }
 
-    const version = state.previewVersions.get(lora.file_path);
+    // Get the page-specific previewVersions map
+    const previewVersions = state.pages.loras.previewVersions || new Map();
+    const version = previewVersions.get(lora.file_path);
     const previewUrl = lora.preview_url || '/loras_static/images/no-preview.png';
     const versionedPreviewUrl = version ? `${previewUrl}?t=${version}` : previewUrl;
 
@@ -63,6 +67,9 @@ export function createLoraCard(lora) {
     const isVideo = previewUrl.endsWith('.mp4');
     const videoAttrs = autoplayOnHover ? 'controls muted loop' : 'controls autoplay muted loop';
 
+    // Get favorite status from the lora data
+    const isFavorite = lora.favorite === true;
+
     card.innerHTML = `
         <div class="card-preview ${shouldBlur ? 'blurred' : ''}">
             ${isVideo ? 
@@ -80,6 +87,9 @@ export function createLoraCard(lora) {
                     ${lora.base_model}
                 </span>
                 <div class="card-actions">
+                    <i class="${isFavorite ? 'fas fa-star favorite-active' : 'far fa-star'}" 
+                       title="${isFavorite ? 'Remove from favorites' : 'Add to favorites'}">
+                    </i>
                     <i class="fas fa-globe" 
                        title="${lora.from_civitai ? 'View on Civitai' : 'Not available from Civitai'}"
                        ${!lora.from_civitai ? 'style="opacity: 0.5; cursor: not-allowed"' : ''}>
@@ -133,6 +143,7 @@ export function createLoraCard(lora) {
                 base_model: card.dataset.base_model,
                 usage_tips: card.dataset.usage_tips,
                 notes: card.dataset.notes,
+                favorite: card.dataset.favorite === 'true',
                 // Parse civitai metadata from the card's dataset
                 civitai: (() => {
                     try {
@@ -196,6 +207,39 @@ export function createLoraCard(lora) {
         });
     }
 
+    // Favorite button click event
+    card.querySelector('.fa-star')?.addEventListener('click', async e => {
+        e.stopPropagation();
+        const starIcon = e.currentTarget;
+        const isFavorite = starIcon.classList.contains('fas');
+        const newFavoriteState = !isFavorite;
+        
+        try {
+            // Save the new favorite state to the server
+            await saveModelMetadata(card.dataset.filepath, { 
+                favorite: newFavoriteState 
+            });
+
+            // Update the UI
+            if (newFavoriteState) {
+                starIcon.classList.remove('far');
+                starIcon.classList.add('fas', 'favorite-active');
+                starIcon.title = 'Remove from favorites';
+                card.dataset.favorite = 'true';
+                showToast('Added to favorites', 'success');
+            } else {
+                starIcon.classList.remove('fas', 'favorite-active');
+                starIcon.classList.add('far');
+                starIcon.title = 'Add to favorites';
+                card.dataset.favorite = 'false';
+                showToast('Removed from favorites', 'success');
+            }
+        } catch (error) {
+            console.error('Failed to update favorite status:', error);
+            showToast('Failed to update favorite status', 'error');
+        }
+    });
+
     // Copy button click event
     card.querySelector('.fa-copy')?.addEventListener('click', async e => {
         e.stopPropagation();
@@ -203,26 +247,7 @@ export function createLoraCard(lora) {
         const strength = usageTips.strength || 1;
         const loraSyntax = `<lora:${card.dataset.file_name}:${strength}>`;
         
-        try {
-            // Modern clipboard API
-            if (navigator.clipboard && window.isSecureContext) {
-                await navigator.clipboard.writeText(loraSyntax);
-            } else {
-                // Fallback for older browsers
-                const textarea = document.createElement('textarea');
-                textarea.value = loraSyntax;
-                textarea.style.position = 'absolute';
-                textarea.style.left = '-99999px';
-                document.body.appendChild(textarea);
-                textarea.select();
-                document.execCommand('copy');
-                document.body.removeChild(textarea);
-            }
-            showToast('LoRA syntax copied', 'success');
-        } catch (err) {
-            console.error('Copy failed:', err);
-            showToast('Copy failed', 'error');
-        }
+        await copyToClipboard(loraSyntax, 'LoRA syntax copied');
     });
 
     // Civitai button click event
@@ -236,7 +261,7 @@ export function createLoraCard(lora) {
     // Delete button click event
     card.querySelector('.fa-trash')?.addEventListener('click', e => {
         e.stopPropagation();
-        deleteModel(lora.file_path);
+        showDeleteModal(lora.file_path);
     });
 
     // Replace preview button click event

static/js/components/RecipeCard.js

@@ -1,5 +1,5 @@
 // Recipe Card Component
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { modalManager } from '../managers/ModalManager.js';
 
 class RecipeCard {
@@ -109,14 +109,11 @@ class RecipeCard {
                 .then(response => response.json())
                 .then(data => {
                     if (data.success && data.syntax) {
-                        return navigator.clipboard.writeText(data.syntax);
+                        return copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
                     } else {
                         throw new Error(data.error || 'No syntax returned');
                     }
                 })
-                .then(() => {
-                    showToast('Recipe syntax copied to clipboard', 'success');
-                })
                 .catch(err => {
                     console.error('Failed to copy: ', err);
                     showToast('Failed to copy recipe syntax', 'error');
@@ -279,4 +276,4 @@ class RecipeCard {
     }
 }
 
-export { RecipeCard }; 
+export { RecipeCard };

static/js/components/RecipeModal.js

@@ -1,5 +1,5 @@
 // Recipe Modal Component
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { setSessionItem, removeSessionItem } from '../utils/storageHelpers.js';
 
@@ -747,9 +747,8 @@ class RecipeModal {
             const data = await response.json();
             
             if (data.success && data.syntax) {
-                // Copy to clipboard
-                await navigator.clipboard.writeText(data.syntax);
-                showToast('Recipe syntax copied to clipboard', 'success');
+                // Use the centralized copyToClipboard utility function
+                await copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
             } else {
                 throw new Error(data.error || 'No syntax returned from server');
             }
@@ -761,12 +760,7 @@ class RecipeModal {
     
     // Helper method to copy text to clipboard
     copyToClipboard(text, successMessage) {
-        navigator.clipboard.writeText(text).then(() => {
-            showToast(successMessage, 'success');
-        }).catch(err => {
-            console.error('Failed to copy text: ', err);
-            showToast('Failed to copy text', 'error');
-        });
+        copyToClipboard(text, successMessage);
     }
 
     // Add new method to handle downloading missing LoRAs
@@ -790,9 +784,9 @@ class RecipeModal {
                 
                 // Determine which endpoint to use based on available data
                 if (lora.modelVersionId) {
-                    endpoint = `/api/civitai/model/${lora.modelVersionId}`;
+                    endpoint = `/api/civitai/model/version/${lora.modelVersionId}`;
                 } else if (lora.hash) {
-                    endpoint = `/api/civitai/model/${lora.hash}`;
+                    endpoint = `/api/civitai/model/hash/${lora.hash}`;
                 } else {
                     console.error("Missing both hash and modelVersionId for lora:", lora);
                     return null;

static/js/components/alphabet/AlphabetBar.js

@@ -0,0 +1,319 @@
+// AlphabetBar.js - Component for alphabet filtering
+import { getCurrentPageState, setCurrentPageType } from '../../state/index.js';
+import { getStorageItem, setStorageItem } from '../../utils/storageHelpers.js';
+import { resetAndReload } from '../../api/loraApi.js';
+
+/**
+ * AlphabetBar class - Handles the alphabet filtering UI and interactions
+ */
+export class AlphabetBar {
+    constructor(pageType = 'loras') {
+        // Store the page type
+        this.pageType = pageType;
+        
+        // Get the current page state
+        this.pageState = getCurrentPageState();
+        
+        // Initialize letter counts
+        this.letterCounts = {};
+        
+        // Initialize the component
+        this.initializeComponent();
+    }
+    
+    /**
+     * Initialize the alphabet bar component
+     */
+    async initializeComponent() {
+        // Get letter counts from API
+        await this.fetchLetterCounts();
+        
+        // Initialize event listeners
+        this.initEventListeners();
+        
+        // Restore the active letter filter from storage if available
+        this.restoreActiveLetterFilter();
+        
+        // Restore collapse state from storage
+        this.restoreCollapseState();
+
+        // Update the toggle button indicator if there's an active letter filter
+        this.updateToggleIndicator();
+    }
+    
+    /**
+     * Fetch letter counts from the API
+     */
+    async fetchLetterCounts() {
+        try {
+            const response = await fetch('/api/loras/letter-counts');
+            
+            if (!response.ok) {
+                throw new Error(`Failed to fetch letter counts: ${response.statusText}`);
+            }
+            
+            const data = await response.json();
+            
+            if (data.success && data.letter_counts) {
+                this.letterCounts = data.letter_counts;
+                
+                // Update the count display in the UI
+                this.updateLetterCountsDisplay();
+            }
+        } catch (error) {
+            console.error('Error fetching letter counts:', error);
+        }
+    }
+    
+    /**
+     * Update the letter counts display in the UI
+     */
+    updateLetterCountsDisplay() {
+        const letterChips = document.querySelectorAll('.letter-chip');
+        
+        letterChips.forEach(chip => {
+            const letter = chip.dataset.letter;
+            const count = this.letterCounts[letter] || 0;
+            
+            // Update the title attribute for tooltip display
+            if (count > 0) {
+                chip.title = `${letter}: ${count} LoRAs`;
+                chip.classList.remove('disabled');
+            } else {
+                chip.title = `${letter}: No LoRAs`;
+                chip.classList.add('disabled');
+            }
+            
+            // Keep the count span for backward compatibility
+            const countSpan = chip.querySelector('.count');
+            if (countSpan) {
+                countSpan.textContent = ` (${count})`;
+            }
+        });
+    }
+    
+    /**
+     * Initialize event listeners for the alphabet bar
+     */
+    initEventListeners() {
+        const alphabetBar = document.querySelector('.alphabet-bar');
+        const toggleButton = document.querySelector('.toggle-alphabet-bar');
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        
+        if (alphabetBar) {
+            // Use event delegation for letter chips
+            alphabetBar.addEventListener('click', (e) => {
+                const letterChip = e.target.closest('.letter-chip');
+                
+                if (letterChip && !letterChip.classList.contains('disabled')) {
+                    this.handleLetterClick(letterChip);
+                }
+            });
+            
+            // Add toggle button listener
+            if (toggleButton && alphabetBarContainer) {
+                toggleButton.addEventListener('click', () => {
+                    alphabetBarContainer.classList.toggle('collapsed');
+                    
+                    // If expanding and there's an active letter, scroll it into view
+                    if (!alphabetBarContainer.classList.contains('collapsed')) {
+                        this.scrollActiveLetterIntoView();
+                    }
+                    
+                    // Save collapse state to storage
+                    setStorageItem(`${this.pageType}_alphabetBarCollapsed`, 
+                        alphabetBarContainer.classList.contains('collapsed'));
+
+                    // Update toggle indicator
+                    this.updateToggleIndicator();
+                });
+            }
+            
+            // Add keyboard shortcut listeners
+            document.addEventListener('keydown', (e) => {
+                // Alt + letter shortcuts
+                if (e.altKey && !e.ctrlKey && !e.metaKey) {
+                    const key = e.key.toUpperCase();
+                    
+                    // Check if it's a letter A-Z
+                    if (/^[A-Z]$/.test(key)) {
+                        const letterChip = document.querySelector(`.letter-chip[data-letter="${key}"]`);
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } 
+                    // Special cases for non-letter filters
+                    else if (e.key === '0' || e.key === ')') {
+                        // Alt+0 for numbers (#)
+                        const letterChip = document.querySelector('.letter-chip[data-letter="#"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } else if (e.key === '2' || e.key === '@') {
+                        // Alt+@ for special characters
+                        const letterChip = document.querySelector('.letter-chip[data-letter="@"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } else if (e.key === 'c' || e.key === 'C') {
+                        // Alt+C for CJK characters
+                        const letterChip = document.querySelector('.letter-chip[data-letter="漢"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    }
+                }
+            });
+        }
+    }
+    
+    /**
+     * Restore the collapse state from storage
+     */
+    restoreCollapseState() {
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        
+        if (alphabetBarContainer) {
+            const isCollapsed = getStorageItem(`${this.pageType}_alphabetBarCollapsed`);
+            
+            // If there's a stored preference, apply it
+            if (isCollapsed !== null) {
+                if (isCollapsed) {
+                    alphabetBarContainer.classList.add('collapsed');
+                } else {
+                    alphabetBarContainer.classList.remove('collapsed');
+                }
+            }
+        }
+    }
+    
+    /**
+     * Handle letter chip click
+     * @param {HTMLElement} letterChip - The letter chip that was clicked
+     */
+    handleLetterClick(letterChip) {
+        const letter = letterChip.dataset.letter;
+        const wasActive = letterChip.classList.contains('active');
+        
+        // Remove active class from all letter chips
+        document.querySelectorAll('.letter-chip').forEach(chip => {
+            chip.classList.remove('active');
+        });
+        
+        if (!wasActive) {
+            // Set the new active letter
+            letterChip.classList.add('active');
+            this.pageState.activeLetterFilter = letter;
+            
+            // Save to storage
+            setStorageItem(`${this.pageType}_activeLetterFilter`, letter);
+        } else {
+            // Clear the active letter filter
+            this.pageState.activeLetterFilter = null;
+            
+            // Remove from storage
+            setStorageItem(`${this.pageType}_activeLetterFilter`, null);
+        }
+        
+        // Update visual indicator on toggle button
+        this.updateToggleIndicator();
+        
+        // Trigger a reload with the new filter
+        resetAndReload(true);
+    }
+    
+    /**
+     * Restore the active letter filter from storage
+     */
+    restoreActiveLetterFilter() {
+        const activeLetterFilter = getStorageItem(`${this.pageType}_activeLetterFilter`);
+        
+        if (activeLetterFilter) {
+            const letterChip = document.querySelector(`.letter-chip[data-letter="${activeLetterFilter}"]`);
+            
+            if (letterChip && !letterChip.classList.contains('disabled')) {
+                letterChip.classList.add('active');
+                this.pageState.activeLetterFilter = activeLetterFilter;
+                
+                // Scroll the active letter into view if the alphabet bar is expanded
+                this.scrollActiveLetterIntoView();
+            }
+        }
+    }
+    
+    /**
+     * Clear the active letter filter
+     */
+    clearActiveLetterFilter() {
+        // Remove active class from all letter chips
+        document.querySelectorAll('.letter-chip').forEach(chip => {
+            chip.classList.remove('active');
+        });
+        
+        // Clear the active letter filter
+        this.pageState.activeLetterFilter = null;
+        
+        // Remove from storage
+        setStorageItem(`${this.pageType}_activeLetterFilter`, null);
+        
+        // Update the toggle button indicator
+        this.updateToggleIndicator();
+    }
+    
+    /**
+     * Update letter counts with new data
+     * @param {Object} newCounts - New letter count data
+     */
+    updateCounts(newCounts) {
+        this.letterCounts = { ...newCounts };
+        this.updateLetterCountsDisplay();
+    }
+    
+    /**
+     * Update the toggle button visual indicator based on active filter
+     */
+    updateToggleIndicator() {
+        const toggleButton = document.querySelector('.toggle-alphabet-bar');
+        const hasActiveFilter = this.pageState.activeLetterFilter !== null;
+        
+        if (toggleButton) {
+            if (hasActiveFilter) {
+                toggleButton.classList.add('has-active-letter');
+            } else {
+                toggleButton.classList.remove('has-active-letter');
+            }
+        }
+    }
+    
+    /**
+     * Scroll the active letter into view if the alphabet bar is expanded
+     */
+    scrollActiveLetterIntoView() {
+        if (!this.pageState.activeLetterFilter) return;
+
+        
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        if (alphabetBarContainer) {
+            const activeLetterChip = document.querySelector(`.letter-chip.active`);
+            
+            if (activeLetterChip) {
+                // Use a small timeout to ensure the alphabet bar is fully expanded
+                setTimeout(() => {
+                    activeLetterChip.scrollIntoView({
+                        behavior: 'smooth',
+                        block: 'center',
+                        inline: 'center'
+                    });
+                }, 300);
+            }
+        }
+    }
+}

static/js/components/alphabet/index.js

@@ -0,0 +1,14 @@
+// Alphabet component index file
+import { AlphabetBar } from './AlphabetBar.js';
+
+// Export the class
+export { AlphabetBar };
+
+/**
+ * Factory function to create the appropriate alphabet bar
+ * @param {string} pageType - The type of page ('loras' or 'checkpoints')
+ * @returns {AlphabetBar} - The alphabet bar instance
+ */
+export function createAlphabetBar(pageType) {
+    return new AlphabetBar(pageType);
+}

static/js/components/checkpointModal/ModelMetadata.js

@@ -5,31 +5,7 @@
 import { showToast } from '../../utils/uiHelpers.js';
 import { BASE_MODELS } from '../../utils/constants.js';
 import { updateCheckpointCard } from '../../utils/cardUpdater.js';
-
-/**
- * Save model metadata to the server
- * @param {string} filePath - Path to the model file
- * @param {Object} data - Metadata to save
- * @returns {Promise} - Promise that resolves with the server response
- */
-export async function saveModelMetadata(filePath, data) {
-    const response = await fetch('/api/checkpoints/save-metadata', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            file_path: filePath,
-            ...data
-        })
-    });
-
-    if (!response.ok) {
-        throw new Error('Failed to save metadata');
-    }
-    
-    return response.json();
-}
+import { saveModelMetadata } from '../../api/checkpointApi.js';
 
 /**
  * Set up model name editing functionality
@@ -195,12 +171,13 @@ export function setupBaseModelEditing(filePath) {
             'Stable Diffusion 2.x': [BASE_MODELS.SD_2_0, BASE_MODELS.SD_2_1],
             'Stable Diffusion 3.x': [BASE_MODELS.SD_3, BASE_MODELS.SD_3_5, BASE_MODELS.SD_3_5_MEDIUM, BASE_MODELS.SD_3_5_LARGE, BASE_MODELS.SD_3_5_LARGE_TURBO],
             'SDXL': [BASE_MODELS.SDXL, BASE_MODELS.SDXL_LIGHTNING, BASE_MODELS.SDXL_HYPER],
-            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
+            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.LTXV, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
             'Other Models': [
                 BASE_MODELS.FLUX_1_D, BASE_MODELS.FLUX_1_S, BASE_MODELS.AURAFLOW,
                 BASE_MODELS.PIXART_A, BASE_MODELS.PIXART_E, BASE_MODELS.HUNYUAN_1,
                 BASE_MODELS.LUMINA, BASE_MODELS.KOLORS, BASE_MODELS.NOOBAI,
-                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.UNKNOWN
+                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.HIDREAM,
+                BASE_MODELS.UNKNOWN
             ]
         };
         

static/js/components/checkpointModal/ShowcaseView.js

@@ -2,16 +2,44 @@
  * ShowcaseView.js
  * Handles showcase content (images, videos) display for checkpoint modal
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { state } from '../../state/index.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 
+/**
+ * Get the local URL for an example image if available
+ * @param {Object} img - Image object
+ * @param {number} index - Image index
+ * @param {string} modelHash - Model hash
+ * @returns {string|null} - Local URL or null if not available
+ */
+function getLocalExampleImageUrl(img, index, modelHash) {
+    if (!modelHash) return null;
+    
+    // Get remote extension
+    const remoteExt = (img.url || '').split('?')[0].split('.').pop().toLowerCase();
+    
+    // If it's a video (mp4), use that extension
+    if (remoteExt === 'mp4') {
+        return `/example_images_static/${modelHash}/image_${index + 1}.mp4`;
+    }
+    
+    // For images, check if optimization is enabled (defaults to true) 
+    const optimizeImages = state.settings.optimizeExampleImages !== false;
+    
+    // Use .webp for images if optimization enabled, otherwise use original extension
+    const extension = optimizeImages ? 'webp' : remoteExt;
+    
+    return `/example_images_static/${modelHash}/image_${index + 1}.${extension}`;
+}
+
 /**
  * Render showcase content
  * @param {Array} images - Array of images/videos to show
+ * @param {string} modelHash - Model hash for identifying local files
  * @returns {string} HTML content
  */
-export function renderShowcaseContent(images) {
+export function renderShowcaseContent(images, modelHash) {
     if (!images?.length) return '<div class="no-examples">No example images available</div>';
     
     // Filter images based on SFW setting
@@ -53,7 +81,11 @@ export function renderShowcaseContent(images) {
         <div class="carousel collapsed">
             ${hiddenNotification}
             <div class="carousel-container">
-                ${filteredImages.map(img => generateMediaWrapper(img)).join('')}
+                ${filteredImages.map((img, index) => {
+                    // Try to get local URL for the example image
+                    const localUrl = getLocalExampleImageUrl(img, index, modelHash);
+                    return generateMediaWrapper(img, localUrl);
+                }).join('')}
             </div>
         </div>
     `;
@@ -64,7 +96,7 @@ export function renderShowcaseContent(images) {
  * @param {Object} media - Media object with image or video data
  * @returns {string} HTML content
  */
-function generateMediaWrapper(media) {
+function generateMediaWrapper(media, localUrl = null) {
     // Calculate appropriate aspect ratio:
     // 1. Keep original aspect ratio
     // 2. Limit maximum height to 60% of viewport height
@@ -117,10 +149,10 @@ function generateMediaWrapper(media) {
     
     // Check if this is a video or image
     if (media.type === 'video') {
-        return generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel);
+        return generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl);
     }
     
-    return generateImageWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel);
+    return generateImageWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl);
 }
 
 /**
@@ -193,7 +225,7 @@ function generateMetadataPanel(hasParams, hasPrompts, prompt, negativePrompt, si
 /**
  * Generate video wrapper HTML
  */
-function generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+function generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl = null) {
     return `
         <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
             ${shouldBlur ? `
@@ -202,9 +234,11 @@ function generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metada
                 </button>
             ` : ''}
             <video controls autoplay muted loop crossorigin="anonymous" 
-                referrerpolicy="no-referrer" data-src="${media.url}"
+                referrerpolicy="no-referrer" 
+                data-local-src="${localUrl || ''}"
+                data-remote-src="${media.url}"
                 class="lazy ${shouldBlur ? 'blurred' : ''}">
-                <source data-src="${media.url}" type="video/mp4">
+                <source data-local-src="${localUrl || ''}" data-remote-src="${media.url}" type="video/mp4">
                 Your browser does not support video playback
             </video>
             ${shouldBlur ? `
@@ -223,7 +257,7 @@ function generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText, metada
 /**
  * Generate image wrapper HTML
  */
-function generateImageWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+function generateImageWrapper(media, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl = null) {
     return `
         <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
             ${shouldBlur ? `
@@ -231,7 +265,8 @@ function generateImageWrapper(media, heightPercent, shouldBlur, nsfwText, metada
                     <i class="fas fa-eye"></i>
                 </button>
             ` : ''}
-            <img data-src="${media.url}" 
+            <img data-local-src="${localUrl || ''}" 
+                data-remote-src="${media.url}"
                 alt="Preview" 
                 crossorigin="anonymous" 
                 referrerpolicy="no-referrer"
@@ -287,8 +322,72 @@ function initMetadataPanelHandlers(container) {
     const mediaWrappers = container.querySelectorAll('.media-wrapper');
     
     mediaWrappers.forEach(wrapper => {
+        // Get the metadata panel and media element (img or video)
         const metadataPanel = wrapper.querySelector('.image-metadata-panel');
-        if (!metadataPanel) return;
+        const mediaElement = wrapper.querySelector('img, video');
+        
+        if (!metadataPanel || !mediaElement) return;
+        
+        let isOverMetadataPanel = false;
+        
+        // Add event listeners to the wrapper for mouse tracking
+        wrapper.addEventListener('mousemove', (e) => {
+            // Get mouse position relative to wrapper
+            const rect = wrapper.getBoundingClientRect();
+            const mouseX = e.clientX - rect.left;
+            const mouseY = e.clientY - rect.top;
+            
+            // Get the actual displayed dimensions of the media element
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            
+            // Check if mouse is over the actual media content
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            // Show metadata panel when over media content or metadata panel itself
+            if (isOverMedia || isOverMetadataPanel) {
+                metadataPanel.classList.add('visible');
+            } else {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        wrapper.addEventListener('mouseleave', () => {
+            // Only hide panel when mouse leaves the wrapper and not over the metadata panel
+            if (!isOverMetadataPanel) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        // Add mouse enter/leave events for the metadata panel itself
+        metadataPanel.addEventListener('mouseenter', () => {
+            isOverMetadataPanel = true;
+            metadataPanel.classList.add('visible');
+        });
+        
+        metadataPanel.addEventListener('mouseleave', () => {
+            isOverMetadataPanel = false;
+            // Only hide if mouse is not over the media
+            const rect = wrapper.getBoundingClientRect();
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            const mouseX = event.clientX - rect.left;
+            const mouseY = event.clientY - rect.top;
+            
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            if (!isOverMedia) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
         
         // Prevent events from bubbling
         metadataPanel.addEventListener('click', (e) => {
@@ -307,8 +406,7 @@ function initMetadataPanelHandlers(container) {
                 if (!promptElement) return;
                 
                 try {
-                    await navigator.clipboard.writeText(promptElement.textContent);
-                    showToast('Prompt copied to clipboard', 'success');
+                    await copyToClipboard(promptElement.textContent, 'Prompt copied to clipboard');
                 } catch (err) {
                     console.error('Copy failed:', err);
                     showToast('Copy failed', 'error');
@@ -318,11 +416,61 @@ function initMetadataPanelHandlers(container) {
         
         // Prevent panel scroll from causing modal scroll
         metadataPanel.addEventListener('wheel', (e) => {
-            e.stopPropagation();
-        });
+            const isAtTop = metadataPanel.scrollTop === 0;
+            const isAtBottom = metadataPanel.scrollHeight - metadataPanel.scrollTop === metadataPanel.clientHeight;
+            
+            // Only prevent default if scrolling would cause the panel to scroll
+            if ((e.deltaY < 0 && !isAtTop) || (e.deltaY > 0 && !isAtBottom)) {
+                e.stopPropagation();
+            }
+        }, { passive: true });
     });
 }
 
+/**
+ * Get the actual rendered rectangle of a media element with object-fit: contain
+ * @param {HTMLElement} mediaElement - The img or video element
+ * @param {number} containerWidth - Width of the container
+ * @param {number} containerHeight - Height of the container
+ * @returns {Object} - Rect with left, top, right, bottom coordinates
+ */
+function getRenderedMediaRect(mediaElement, containerWidth, containerHeight) {
+    // Get natural dimensions of the media
+    const naturalWidth = mediaElement.naturalWidth || mediaElement.videoWidth || mediaElement.clientWidth;
+    const naturalHeight = mediaElement.naturalHeight || mediaElement.videoHeight || mediaElement.clientHeight;
+    
+    if (!naturalWidth || !naturalHeight) {
+        // Fallback if dimensions cannot be determined
+        return { left: 0, top: 0, right: containerWidth, bottom: containerHeight };
+    }
+    
+    // Calculate aspect ratios
+    const containerRatio = containerWidth / containerHeight;
+    const mediaRatio = naturalWidth / naturalHeight;
+    
+    let renderedWidth, renderedHeight, left = 0, top = 0;
+    
+    // Apply object-fit: contain logic
+    if (containerRatio > mediaRatio) {
+        // Container is wider than media - will have empty space on sides
+        renderedHeight = containerHeight;
+        renderedWidth = renderedHeight * mediaRatio;
+        left = (containerWidth - renderedWidth) / 2;
+    } else {
+        // Container is taller than media - will have empty space top/bottom
+        renderedWidth = containerWidth;
+        renderedHeight = renderedWidth / mediaRatio;
+        top = (containerHeight - renderedHeight) / 2;
+    }
+    
+    return {
+        left,
+        top,
+        right: left + renderedWidth,
+        bottom: top + renderedHeight
+    };
+}
+
 /**
  * Initialize blur toggle handlers
  */
@@ -383,15 +531,73 @@ function initLazyLoading(container) {
     const lazyElements = container.querySelectorAll('.lazy');
     
     const lazyLoad = (element) => {
+        const localSrc = element.dataset.localSrc;
+        const remoteSrc = element.dataset.remoteSrc;
+        
+        // Check if element is an image or video
         if (element.tagName.toLowerCase() === 'video') {
-            element.src = element.dataset.src;
-            element.querySelector('source').src = element.dataset.src;
-            element.load();
+            // Try local first, then remote
+            tryLocalOrFallbackToRemote(element, localSrc, remoteSrc);
         } else {
-            element.src = element.dataset.src;
+            // For images, we'll use an Image object to test if local file exists
+            tryLocalImageOrFallbackToRemote(element, localSrc, remoteSrc);
         }
+        
         element.classList.remove('lazy');
     };
+    
+    // Try to load local image first, fall back to remote if local fails
+    const tryLocalImageOrFallbackToRemote = (imgElement, localSrc, remoteSrc) => {
+        // Only try local if we have a local path
+        if (localSrc) {
+            const testImg = new Image();
+            testImg.onload = () => {
+                // Local image loaded successfully
+                imgElement.src = localSrc;
+            };
+            testImg.onerror = () => {
+                // Local image failed, use remote
+                imgElement.src = remoteSrc;
+            };
+            // Start loading test image
+            testImg.src = localSrc;
+        } else {
+            // No local path, use remote directly
+            imgElement.src = remoteSrc;
+        }
+    };
+    
+    // Try to load local video first, fall back to remote if local fails
+    const tryLocalOrFallbackToRemote = (videoElement, localSrc, remoteSrc) => {
+        // Only try local if we have a local path
+        if (localSrc) {
+            // Try to fetch local file headers to see if it exists
+            fetch(localSrc, { method: 'HEAD' })
+                .then(response => {
+                    if (response.ok) {
+                        // Local video exists, use it
+                        videoElement.src = localSrc;
+                        videoElement.querySelector('source').src = localSrc;
+                    } else {
+                        // Local video doesn't exist, use remote
+                        videoElement.src = remoteSrc;
+                        videoElement.querySelector('source').src = remoteSrc;
+                    }
+                    videoElement.load();
+                })
+                .catch(() => {
+                    // Error fetching, use remote
+                    videoElement.src = remoteSrc;
+                    videoElement.querySelector('source').src = remoteSrc;
+                    videoElement.load();
+                });
+        } else {
+            // No local path, use remote directly
+            videoElement.src = remoteSrc;
+            videoElement.querySelector('source').src = remoteSrc;
+            videoElement.load();
+        }
+    };
 
     const observer = new IntersectionObserver((entries) => {
         entries.forEach(entry => {
@@ -486,4 +692,4 @@ export function scrollToTop(button) {
             behavior: 'smooth'
         });
     }
-}
+}

static/js/components/checkpointModal/index.js

@@ -11,9 +11,9 @@ import { setupTabSwitching, loadModelDescription } from './ModelDescription.js';
 import { 
     setupModelNameEditing, 
     setupBaseModelEditing, 
-    setupFileNameEditing,
-    saveModelMetadata
+    setupFileNameEditing
 } from './ModelMetadata.js';
+import { saveModelMetadata } from '../../api/checkpointApi.js';
 import { renderCompactTags, setupTagTooltip, formatFileSize } from './utils.js';
 import { updateCheckpointCard } from '../../utils/cardUpdater.js';
 
@@ -96,7 +96,7 @@ export function showCheckpointModal(checkpoint) {
                     
                     <div class="tab-content">
                         <div id="showcase-tab" class="tab-pane active">
-                            ${renderShowcaseContent(checkpoint.civitai?.images || [])}
+                            ${renderShowcaseContent(checkpoint.civitai?.images || [], checkpoint.sha256)}
                         </div>
                         
                         <div id="description-tab" class="tab-pane">

static/js/components/controls/LorasControls.js

@@ -2,7 +2,7 @@
 import { PageControls } from './PageControls.js';
 import { loadMoreLoras, fetchCivitai, resetAndReload, refreshLoras } from '../../api/loraApi.js';
 import { getSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
-import { showToast } from '../../utils/uiHelpers.js';
+import { createAlphabetBar } from '../alphabet/index.js';
 
 /**
  * LorasControls class - Extends PageControls for LoRA-specific functionality
@@ -17,6 +17,9 @@ export class LorasControls extends PageControls {
         
         // Check for custom filters (e.g., from recipe navigation)
         this.checkCustomFilters();
+        
+        // Initialize alphabet bar component
+        this.initAlphabetBar();
     }
     
     /**
@@ -143,4 +146,15 @@ export class LorasControls extends PageControls {
     _truncateText(text, maxLength) {
         return text.length > maxLength ? text.substring(0, maxLength - 3) + '...' : text;
     }
+    
+    /**
+     * Initialize the alphabet bar component
+     */
+    initAlphabetBar() {
+        // Create the alphabet bar component
+        this.alphabetBar = createAlphabetBar('loras');
+        
+        // Expose the alphabet bar to the global scope for debugging
+        window.alphabetBar = this.alphabetBar;
+    }
 }

static/js/components/controls/PageControls.js

@@ -1,6 +1,6 @@
 // PageControls.js - Manages controls for both LoRAs and Checkpoints pages
 import { state, getCurrentPageState, setCurrentPageType } from '../../state/index.js';
-import { getStorageItem, setStorageItem } from '../../utils/storageHelpers.js';
+import { getStorageItem, setStorageItem, getSessionItem, setSessionItem } from '../../utils/storageHelpers.js';
 import { showToast } from '../../utils/uiHelpers.js';
 
 /**
@@ -26,6 +26,9 @@ export class PageControls {
         // Initialize event listeners
         this.initEventListeners();
         
+        // Initialize favorites filter button state
+        this.initFavoritesFilter();
+        
         console.log(`PageControls initialized for ${pageType} page`);
     }
     
@@ -121,6 +124,12 @@ export class PageControls {
                 bulkButton.addEventListener('click', () => this.toggleBulkMode());
             }
         }
+        
+        // Favorites filter button handler
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        if (favoriteFilterBtn) {
+            favoriteFilterBtn.addEventListener('click', () => this.toggleFavoritesOnly());
+        }
     }
     
     /**
@@ -385,4 +394,50 @@ export class PageControls {
             showToast('Failed to clear custom filter: ' + error.message, 'error');
         }
     }
+    
+    /**
+     * Initialize the favorites filter button state
+     */
+    initFavoritesFilter() {
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        if (favoriteFilterBtn) {
+            // Get current state from session storage with page-specific key
+            const storageKey = `show_favorites_only_${this.pageType}`;
+            const showFavoritesOnly = getSessionItem(storageKey, false);
+            
+            // Update button state
+            if (showFavoritesOnly) {
+                favoriteFilterBtn.classList.add('active');
+            }
+            
+            // Update app state
+            this.pageState.showFavoritesOnly = showFavoritesOnly;
+        }
+    }
+    
+    /**
+     * Toggle favorites-only filter and reload models
+     */
+    async toggleFavoritesOnly() {
+        const favoriteFilterBtn = document.getElementById('favoriteFilterBtn');
+        
+        // Toggle the filter state in storage
+        const storageKey = `show_favorites_only_${this.pageType}`;
+        const currentState = this.pageState.showFavoritesOnly;
+        const newState = !currentState;
+        
+        // Update session storage
+        setSessionItem(storageKey, newState);
+        
+        // Update state
+        this.pageState.showFavoritesOnly = newState;
+        
+        // Update button appearance
+        if (favoriteFilterBtn) {
+            favoriteFilterBtn.classList.toggle('active', newState);
+        }
+        
+        // Reload models with new filter
+        await this.resetAndReload(true);
+    }
 }

static/js/components/loraModal/ModelMetadata.js

@@ -5,31 +5,7 @@
 import { showToast } from '../../utils/uiHelpers.js';
 import { BASE_MODELS } from '../../utils/constants.js';
 import { updateLoraCard } from '../../utils/cardUpdater.js';
-
-/**
- * 保存模型元数据到服务器
- * @param {string} filePath - 文件路径
- * @param {Object} data - 要保存的数据
- * @returns {Promise} 保存操作的Promise
- */
-export async function saveModelMetadata(filePath, data) {
-    const response = await fetch('/api/loras/save-metadata', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            file_path: filePath,
-            ...data
-        })
-    });
-
-    if (!response.ok) {
-        throw new Error('Failed to save metadata');
-    }
-    
-    return response.json();
-}
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 设置模型名称编辑功能
@@ -197,12 +173,13 @@ export function setupBaseModelEditing(filePath) {
             'Stable Diffusion 2.x': [BASE_MODELS.SD_2_0, BASE_MODELS.SD_2_1],
             'Stable Diffusion 3.x': [BASE_MODELS.SD_3, BASE_MODELS.SD_3_5, BASE_MODELS.SD_3_5_MEDIUM, BASE_MODELS.SD_3_5_LARGE, BASE_MODELS.SD_3_5_LARGE_TURBO],
             'SDXL': [BASE_MODELS.SDXL, BASE_MODELS.SDXL_LIGHTNING, BASE_MODELS.SDXL_HYPER],
-            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
+            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.LTXV, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
             'Other Models': [
                 BASE_MODELS.FLUX_1_D, BASE_MODELS.FLUX_1_S, BASE_MODELS.AURAFLOW,
                 BASE_MODELS.PIXART_A, BASE_MODELS.PIXART_E, BASE_MODELS.HUNYUAN_1,
                 BASE_MODELS.LUMINA, BASE_MODELS.KOLORS, BASE_MODELS.NOOBAI,
-                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.UNKNOWN
+                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.HIDREAM,
+                BASE_MODELS.UNKNOWN
             ]
         };
         

static/js/components/loraModal/PresetTags.js

@@ -2,8 +2,7 @@
  * PresetTags.js
  * 处理LoRA模型预设参数标签相关的功能模块
  */
-import { saveModelMetadata } from './ModelMetadata.js';
-import { showToast } from '../../utils/uiHelpers.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 解析预设参数

static/js/components/loraModal/RecipeTab.js

@@ -1,7 +1,7 @@
 /**
  * RecipeTab - Handles the recipes tab in the Lora Modal
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { setSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
 
 /**
@@ -172,14 +172,11 @@ function copyRecipeSyntax(recipeId) {
         .then(response => response.json())
         .then(data => {
             if (data.success && data.syntax) {
-                return navigator.clipboard.writeText(data.syntax);
+                return copyToClipboard(data.syntax, 'Recipe syntax copied to clipboard');
             } else {
                 throw new Error(data.error || 'No syntax returned');
             }
         })
-        .then(() => {
-            showToast('Recipe syntax copied to clipboard', 'success');
-        })
         .catch(err => {
             console.error('Failed to copy: ', err);
             showToast('Failed to copy recipe syntax', 'error');

static/js/components/loraModal/ShowcaseView.js

@@ -2,16 +2,44 @@
  * ShowcaseView.js
  * 处理LoRA模型展示内容（图片、视频）的功能模块
  */
-import { showToast } from '../../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { state } from '../../state/index.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 
+/**
+ * Get the local URL for an example image if available
+ * @param {Object} img - Image object
+ * @param {number} index - Image index
+ * @param {string} modelHash - Model hash
+ * @returns {string|null} - Local URL or null if not available
+ */
+function getLocalExampleImageUrl(img, index, modelHash) {
+    if (!modelHash) return null;
+    
+    // Get remote extension
+    const remoteExt = (img.url || '').split('?')[0].split('.').pop().toLowerCase();
+    
+    // If it's a video (mp4), use that extension
+    if (remoteExt === 'mp4') {
+        return `/example_images_static/${modelHash}/image_${index + 1}.mp4`;
+    }
+    
+    // For images, check if optimization is enabled (defaults to true) 
+    const optimizeImages = state.settings.optimizeExampleImages !== false;
+    
+    // Use .webp for images if optimization enabled, otherwise use original extension
+    const extension = optimizeImages ? 'webp' : remoteExt;
+    
+    return `/example_images_static/${modelHash}/image_${index + 1}.${extension}`;
+}
+
 /**
  * 渲染展示内容
  * @param {Array} images - 要展示的图片/视频数组
+ * @param {string} modelHash - Model hash for identifying local files
  * @returns {string} HTML内容
  */
-export function renderShowcaseContent(images) {
+export function renderShowcaseContent(images, modelHash) {
     if (!images?.length) return '<div class="no-examples">No example images available</div>';
     
     // Filter images based on SFW setting
@@ -53,7 +81,15 @@ export function renderShowcaseContent(images) {
         <div class="carousel collapsed">
             ${hiddenNotification}
             <div class="carousel-container">
-                ${filteredImages.map(img => {
+                ${filteredImages.map((img, index) => {
+                    // Try to get local URL for the example image
+                    const localUrl = getLocalExampleImageUrl(img, index, modelHash);
+                    
+                    // Create data attributes for both remote and local URLs
+                    const remoteUrl = img.url;
+                    const dataRemoteSrc = remoteUrl;
+                    const dataLocalSrc = localUrl;
+                    
                     // 计算适当的展示高度：
                     // 1. 保持原始宽高比
                     // 2. 限制最大高度为视窗高度的60%
@@ -111,9 +147,9 @@ export function renderShowcaseContent(images) {
                         `;
                         
                         if (img.type === 'video') {
-                            return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                            return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, dataLocalSrc, dataRemoteSrc);
                         }
-                        return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                        return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, dataLocalSrc, dataRemoteSrc);
                     }
                     
                     // Create a data attribute with the prompt for copying instead of trying to handle it in the onclick
@@ -174,9 +210,9 @@ export function renderShowcaseContent(images) {
                     `;
                     
                     if (img.type === 'video') {
-                        return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                        return generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, dataLocalSrc, dataRemoteSrc);
                     }
-                    return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel);
+                    return generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, dataLocalSrc, dataRemoteSrc);
                 }).join('')}
             </div>
         </div>
@@ -186,7 +222,7 @@ export function renderShowcaseContent(images) {
 /**
  * 生成视频包装HTML
  */
-function generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+function generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl, remoteUrl) {
     return `
         <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
             ${shouldBlur ? `
@@ -195,9 +231,11 @@ function generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadata
                 </button>
             ` : ''}
             <video controls autoplay muted loop crossorigin="anonymous" 
-                referrerpolicy="no-referrer" data-src="${img.url}"
+                referrerpolicy="no-referrer" 
+                data-local-src="${localUrl || ''}"
+                data-remote-src="${remoteUrl}"
                 class="lazy ${shouldBlur ? 'blurred' : ''}">
-                <source data-src="${img.url}" type="video/mp4">
+                <source data-local-src="${localUrl || ''}" data-remote-src="${remoteUrl}" type="video/mp4">
                 Your browser does not support video playback
             </video>
             ${shouldBlur ? `
@@ -216,7 +254,7 @@ function generateVideoWrapper(img, heightPercent, shouldBlur, nsfwText, metadata
 /**
  * 生成图片包装HTML
  */
-function generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel) {
+function generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadataPanel, localUrl, remoteUrl) {
     return `
         <div class="media-wrapper ${shouldBlur ? 'nsfw-media-wrapper' : ''}" style="padding-bottom: ${heightPercent}%">
             ${shouldBlur ? `
@@ -224,7 +262,8 @@ function generateImageWrapper(img, heightPercent, shouldBlur, nsfwText, metadata
                     <i class="fas fa-eye"></i>
                 </button>
             ` : ''}
-            <img data-src="${img.url}" 
+            <img data-local-src="${localUrl || ''}" 
+                data-remote-src="${remoteUrl}"
                 alt="Preview" 
                 crossorigin="anonymous" 
                 referrerpolicy="no-referrer"
@@ -290,9 +329,72 @@ function initMetadataPanelHandlers(container) {
     const mediaWrappers = container.querySelectorAll('.media-wrapper');
     
     mediaWrappers.forEach(wrapper => {
-        // Get the metadata panel
+        // Get the metadata panel and media element (img or video)
         const metadataPanel = wrapper.querySelector('.image-metadata-panel');
-        if (!metadataPanel) return;
+        const mediaElement = wrapper.querySelector('img, video');
+        
+        if (!metadataPanel || !mediaElement) return;
+        
+        let isOverMetadataPanel = false;
+        
+        // Add event listeners to the wrapper for mouse tracking
+        wrapper.addEventListener('mousemove', (e) => {
+            // Get mouse position relative to wrapper
+            const rect = wrapper.getBoundingClientRect();
+            const mouseX = e.clientX - rect.left;
+            const mouseY = e.clientY - rect.top;
+            
+            // Get the actual displayed dimensions of the media element
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            
+            // Check if mouse is over the actual media content
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            // Show metadata panel when over media content
+            if (isOverMedia || isOverMetadataPanel) {
+                metadataPanel.classList.add('visible');
+            } else {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        wrapper.addEventListener('mouseleave', () => {
+            // Only hide panel when mouse leaves the wrapper and not over the metadata panel
+            if (!isOverMetadataPanel) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        // Add mouse enter/leave events for the metadata panel itself
+        metadataPanel.addEventListener('mouseenter', () => {
+            isOverMetadataPanel = true;
+            metadataPanel.classList.add('visible');
+        });
+        
+        metadataPanel.addEventListener('mouseleave', () => {
+            isOverMetadataPanel = false;
+            // Only hide if mouse is not over the media
+            const rect = wrapper.getBoundingClientRect();
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            const mouseX = event.clientX - rect.left;
+            const mouseY = event.clientY - rect.top;
+            
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            if (!isOverMedia) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
         
         // Prevent events from the metadata panel from bubbling
         metadataPanel.addEventListener('click', (e) => {
@@ -311,8 +413,7 @@ function initMetadataPanelHandlers(container) {
                 if (!promptElement) return;
                 
                 try {
-                    await navigator.clipboard.writeText(promptElement.textContent);
-                    showToast('Prompt copied to clipboard', 'success');
+                    await copyToClipboard(promptElement.textContent, 'Prompt copied to clipboard');
                 } catch (err) {
                     console.error('Copy failed:', err);
                     showToast('Copy failed', 'error');
@@ -333,6 +434,50 @@ function initMetadataPanelHandlers(container) {
     });
 }
 
+/**
+ * Get the actual rendered rectangle of a media element with object-fit: contain
+ * @param {HTMLElement} mediaElement - The img or video element
+ * @param {number} containerWidth - Width of the container
+ * @param {number} containerHeight - Height of the container
+ * @returns {Object} - Rect with left, top, right, bottom coordinates
+ */
+function getRenderedMediaRect(mediaElement, containerWidth, containerHeight) {
+    // Get natural dimensions of the media
+    const naturalWidth = mediaElement.naturalWidth || mediaElement.videoWidth || mediaElement.clientWidth;
+    const naturalHeight = mediaElement.naturalHeight || mediaElement.videoHeight || mediaElement.clientHeight;
+    
+    if (!naturalWidth || !naturalHeight) {
+        // Fallback if dimensions cannot be determined
+        return { left: 0, top: 0, right: containerWidth, bottom: containerHeight };
+    }
+    
+    // Calculate aspect ratios
+    const containerRatio = containerWidth / containerHeight;
+    const mediaRatio = naturalWidth / naturalHeight;
+    
+    let renderedWidth, renderedHeight, left = 0, top = 0;
+    
+    // Apply object-fit: contain logic
+    if (containerRatio > mediaRatio) {
+        // Container is wider than media - will have empty space on sides
+        renderedHeight = containerHeight;
+        renderedWidth = renderedHeight * mediaRatio;
+        left = (containerWidth - renderedWidth) / 2;
+    } else {
+        // Container is taller than media - will have empty space top/bottom
+        renderedWidth = containerWidth;
+        renderedHeight = renderedWidth / mediaRatio;
+        top = (containerHeight - renderedHeight) / 2;
+    }
+    
+    return {
+        left,
+        top,
+        right: left + renderedWidth,
+        bottom: top + renderedHeight
+    };
+}
+
 /**
  * 初始化模糊切换处理
  */
@@ -393,15 +538,73 @@ function initLazyLoading(container) {
     const lazyElements = container.querySelectorAll('.lazy');
     
     const lazyLoad = (element) => {
+        const localSrc = element.dataset.localSrc;
+        const remoteSrc = element.dataset.remoteSrc;
+        
+        // Check if element is an image or video
         if (element.tagName.toLowerCase() === 'video') {
-            element.src = element.dataset.src;
-            element.querySelector('source').src = element.dataset.src;
-            element.load();
+            // Try local first, then remote
+            tryLocalOrFallbackToRemote(element, localSrc, remoteSrc);
         } else {
-            element.src = element.dataset.src;
+            // For images, we'll use an Image object to test if local file exists
+            tryLocalImageOrFallbackToRemote(element, localSrc, remoteSrc);
         }
+        
         element.classList.remove('lazy');
     };
+    
+    // Try to load local image first, fall back to remote if local fails
+    const tryLocalImageOrFallbackToRemote = (imgElement, localSrc, remoteSrc) => {
+        // Only try local if we have a local path
+        if (localSrc) {
+            const testImg = new Image();
+            testImg.onload = () => {
+                // Local image loaded successfully
+                imgElement.src = localSrc;
+            };
+            testImg.onerror = () => {
+                // Local image failed, use remote
+                imgElement.src = remoteSrc;
+            };
+            // Start loading test image
+            testImg.src = localSrc;
+        } else {
+            // No local path, use remote directly
+            imgElement.src = remoteSrc;
+        }
+    };
+    
+    // Try to load local video first, fall back to remote if local fails
+    const tryLocalOrFallbackToRemote = (videoElement, localSrc, remoteSrc) => {
+        // Only try local if we have a local path
+        if (localSrc) {
+            // Try to fetch local file headers to see if it exists
+            fetch(localSrc, { method: 'HEAD' })
+                .then(response => {
+                    if (response.ok) {
+                        // Local video exists, use it
+                        videoElement.src = localSrc;
+                        videoElement.querySelector('source').src = localSrc;
+                    } else {
+                        // Local video doesn't exist, use remote
+                        videoElement.src = remoteSrc;
+                        videoElement.querySelector('source').src = remoteSrc;
+                    }
+                    videoElement.load();
+                })
+                .catch(() => {
+                    // Error fetching, use remote
+                    videoElement.src = remoteSrc;
+                    videoElement.querySelector('source').src = remoteSrc;
+                    videoElement.load();
+                });
+        } else {
+            // No local path, use remote directly
+            videoElement.src = remoteSrc;
+            videoElement.querySelector('source').src = remoteSrc;
+            videoElement.load();
+        }
+    };
 
     const observer = new IntersectionObserver((entries) => {
         entries.forEach(entry => {
@@ -498,4 +701,4 @@ export function scrollToTop(button) {
             behavior: 'smooth'
         });
     }
-}
+}

static/js/components/loraModal/TriggerWords.js

@@ -2,8 +2,8 @@
  * TriggerWords.js
  * 处理LoRA模型触发词相关的功能模块
  */
-import { showToast } from '../../utils/uiHelpers.js';
-import { saveModelMetadata } from './ModelMetadata.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 
 /**
  * 渲染触发词
@@ -235,8 +235,8 @@ function addNewTriggerWord(word) {
     
     // Validation: Check total number
     const currentTags = tagsContainer.querySelectorAll('.trigger-word-tag');
-    if (currentTags.length >= 10) {
-        showToast('Maximum 10 trigger words allowed', 'error');
+    if (currentTags.length >= 30) {
+        showToast('Maximum 30 trigger words allowed', 'error');
         return;
     }
     
@@ -336,8 +336,7 @@ async function saveTriggerWords() {
  */
 window.copyTriggerWord = async function(word) {
     try {
-        await navigator.clipboard.writeText(word);
-        showToast('Trigger word copied', 'success');
+        await copyToClipboard(word, 'Trigger word copied');
     } catch (err) {
         console.error('Copy failed:', err);
         showToast('Copy failed', 'error');

static/js/components/loraModal/index.js

@@ -3,8 +3,7 @@
  * 
  * 将原始的LoraModal.js拆分成多个功能模块后的主入口文件
  */
-import { showToast } from '../../utils/uiHelpers.js';
-import { state } from '../../state/index.js';
+import { showToast, copyToClipboard } from '../../utils/uiHelpers.js';
 import { modalManager } from '../../managers/ModalManager.js';
 import { renderShowcaseContent, toggleShowcase, setupShowcaseScroll, scrollToTop } from './ShowcaseView.js';
 import { setupTabSwitching, loadModelDescription } from './ModelDescription.js';
@@ -14,9 +13,9 @@ import { loadRecipesForLora } from './RecipeTab.js'; // Add import for recipe ta
 import { 
     setupModelNameEditing, 
     setupBaseModelEditing, 
-    setupFileNameEditing,
-    saveModelMetadata
+    setupFileNameEditing
 } from './ModelMetadata.js';
+import { saveModelMetadata } from '../../api/loraApi.js';
 import { renderCompactTags, setupTagTooltip, formatFileSize } from './utils.js';
 import { updateLoraCard } from '../../utils/cardUpdater.js';
 
@@ -123,7 +122,7 @@ export function showLoraModal(lora) {
                     
                     <div class="tab-content">
                         <div id="showcase-tab" class="tab-pane active">
-                            ${renderShowcaseContent(lora.civitai?.images)}
+                            ${renderShowcaseContent(lora.civitai?.images, lora.sha256)}
                         </div>
                         
                         <div id="description-tab" class="tab-pane">
@@ -174,8 +173,7 @@ export function showLoraModal(lora) {
 // Copy file name function
 window.copyFileName = async function(fileName) {
     try {
-        await navigator.clipboard.writeText(fileName);
-        showToast('File name copied', 'success');
+        await copyToClipboard(fileName, 'File name copied');
     } catch (err) {
         console.error('Copy failed:', err);
         showToast('Copy failed', 'error');

static/js/core.js

@@ -5,6 +5,7 @@ import { modalManager } from './managers/ModalManager.js';
 import { updateService } from './managers/UpdateService.js';
 import { HeaderManager } from './components/Header.js';
 import { settingsManager } from './managers/SettingsManager.js';
+import { exampleImagesManager } from './managers/ExampleImagesManager.js';
 import { showToast, initTheme, initBackToTop, lazyLoadImages } from './utils/uiHelpers.js';
 import { initializeInfiniteScroll } from './utils/infiniteScroll.js';
 import { migrateStorageItems } from './utils/storageHelpers.js';
@@ -27,12 +28,16 @@ export class AppCore {
         updateService.initialize();
         window.modalManager = modalManager;
         window.settingsManager = settingsManager;
+        window.exampleImagesManager = exampleImagesManager;
         
         // Initialize UI components
         window.headerManager = new HeaderManager();
         initTheme();
         initBackToTop();
         
+        // Initialize the example images manager
+        exampleImagesManager.initialize();
+        
         // Mark as initialized
         this.initialized = true;
         

static/js/loras.js

@@ -6,9 +6,9 @@ import { updateCardsForBulkMode } from './components/LoraCard.js';
 import { bulkManager } from './managers/BulkManager.js';
 import { DownloadManager } from './managers/DownloadManager.js';
 import { moveManager } from './managers/MoveManager.js';
-import { LoraContextMenu } from './components/ContextMenu.js';
+import { LoraContextMenu } from './components/ContextMenu/index.js';
 import { createPageControls } from './components/controls/index.js';
-import { confirmDelete, closeDeleteModal } from './utils/modalUtils.js';
+import { confirmDelete, closeDeleteModal, confirmExclude, closeExcludeModal } from './utils/modalUtils.js';
 
 // Initialize the LoRA page
 class LoraPageManager {
@@ -35,6 +35,8 @@ class LoraPageManager {
         window.showLoraModal = showLoraModal;
         window.confirmDelete = confirmDelete;
         window.closeDeleteModal = closeDeleteModal;
+        window.confirmExclude = confirmExclude;
+        window.closeExcludeModal = closeExcludeModal;
         window.downloadManager = this.downloadManager;
         window.moveManager = moveManager;
         window.toggleShowcase = toggleShowcase;

static/js/managers/BulkManager.js

@@ -1,5 +1,5 @@
 import { state } from '../state/index.js';
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { updateCardsForBulkMode } from '../components/LoraCard.js';
 
 export class BulkManager {
@@ -205,13 +205,7 @@ export class BulkManager {
             return;
         }
         
-        try {
-            await navigator.clipboard.writeText(loraSyntaxes.join(', '));
-            showToast(`Copied ${loraSyntaxes.length} LoRA syntaxes to clipboard`, 'success');
-        } catch (err) {
-            console.error('Copy failed:', err);
-            showToast('Copy failed', 'error');
-        }
+        await copyToClipboard(loraSyntaxes.join(', '), `Copied ${loraSyntaxes.length} LoRA syntaxes to clipboard`);
     }
     
     // Create and show the thumbnail strip of selected LoRAs

static/js/managers/ExampleImagesManager.js

@@ -0,0 +1,602 @@
+import { showToast } from '../utils/uiHelpers.js';
+import { getStorageItem, setStorageItem } from '../utils/storageHelpers.js';
+
+// ExampleImagesManager.js
+class ExampleImagesManager {
+    constructor() {
+        this.isDownloading = false;
+        this.isPaused = false;
+        this.progressUpdateInterval = null;
+        this.startTime = null;
+        this.progressPanel = null;
+        this.isProgressPanelCollapsed = false;
+        this.pauseButton = null; // Store reference to the pause button
+        
+        // Initialize download path field and check download status
+        this.initializePathOptions();
+        this.checkDownloadStatus();
+    }
+    
+    // Initialize the manager
+    initialize() {
+        // Initialize event listeners
+        this.initEventListeners();
+        
+        // Initialize progress panel reference
+        this.progressPanel = document.getElementById('exampleImagesProgress');
+        
+        // Load collapse state from storage
+        this.isProgressPanelCollapsed = getStorageItem('progress_panel_collapsed', false);
+        if (this.progressPanel && this.isProgressPanelCollapsed) {
+            this.progressPanel.classList.add('collapsed');
+            const icon = document.querySelector('#collapseProgressBtn i');
+            if (icon) {
+                icon.className = 'fas fa-chevron-up';
+            }
+        }
+        
+        // Initialize progress panel button handlers
+        this.pauseButton = document.getElementById('pauseExampleDownloadBtn');
+        const collapseBtn = document.getElementById('collapseProgressBtn');
+        
+        if (this.pauseButton) {
+            this.pauseButton.onclick = () => this.pauseDownload();
+        }
+        
+        if (collapseBtn) {
+            collapseBtn.onclick = () => this.toggleProgressPanel();
+        }
+    }
+    
+    // Initialize event listeners for buttons
+    initEventListeners() {
+        const downloadBtn = document.getElementById('exampleImagesDownloadBtn');
+        if (downloadBtn) {
+            downloadBtn.onclick = () => this.handleDownloadButton();
+        }
+    }
+    
+    async initializePathOptions() {
+        try {
+            // Get custom path input element
+            const pathInput = document.getElementById('exampleImagesPath');
+
+            // Set path from storage if available
+            const savedPath = getStorageItem('example_images_path', '');
+            if (savedPath) {
+                pathInput.value = savedPath;
+                // Enable download button if path is set
+                this.updateDownloadButtonState(true);
+            } else {
+                // Disable download button if no path is set
+                this.updateDownloadButtonState(false);
+            }
+            
+            // Add event listener to validate path input
+            pathInput.addEventListener('input', async () => {
+                const hasPath = pathInput.value.trim() !== '';
+                this.updateDownloadButtonState(hasPath);
+                
+                // Save path to storage when changed
+                if (hasPath) {
+                    setStorageItem('example_images_path', pathInput.value);
+                    
+                    // Update path in backend settings
+                    try {
+                        const response = await fetch('/api/settings', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                example_images_path: pathInput.value
+                            })
+                        });
+                        
+                        if (!response.ok) {
+                            throw new Error(`HTTP error! Status: ${response.status}`);
+                        }
+                        
+                        const data = await response.json();
+                        if (!data.success) {
+                            console.error('Failed to update example images path in backend:', data.error);
+                        } else {
+                            showToast('Example images path updated successfully', 'success');
+                        }
+                    } catch (error) {
+                        console.error('Failed to update example images path:', error);
+                    }
+                }
+            });
+        } catch (error) {
+            console.error('Failed to initialize path options:', error);
+        }
+    }
+    
+    // Method to update download button state
+    updateDownloadButtonState(enabled) {
+        const downloadBtn = document.getElementById('exampleImagesDownloadBtn');
+        if (downloadBtn) {
+            if (enabled) {
+                downloadBtn.classList.remove('disabled');
+                downloadBtn.disabled = false;
+            } else {
+                downloadBtn.classList.add('disabled');
+                downloadBtn.disabled = true;
+            }
+        }
+    }
+    
+    // Method to handle download button click based on current state
+    async handleDownloadButton() {
+        if (this.isDownloading && this.isPaused) {
+            // If download is paused, resume it
+            this.resumeDownload();
+        } else if (!this.isDownloading) {
+            // If no download in progress, start a new one
+            this.startDownload();
+        } else {
+            // If download is in progress, show info toast
+            showToast('Download already in progress', 'info');
+        }
+    }
+    
+    async checkDownloadStatus() {
+        try {
+            const response = await fetch('/api/example-images-status');
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isDownloading = data.is_downloading;
+                this.isPaused = data.status.status === 'paused';
+                
+                // Update download button text based on status
+                this.updateDownloadButtonText();
+                
+                if (this.isDownloading) {
+                    // Ensure progress panel exists before updating UI
+                    if (!this.progressPanel) {
+                        this.progressPanel = document.getElementById('exampleImagesProgress');
+                    }
+                    
+                    if (this.progressPanel) {
+                        this.updateUI(data.status);
+                        this.showProgressPanel();
+                        
+                        // Start the progress update interval if downloading
+                        if (!this.progressUpdateInterval) {
+                            this.startProgressUpdates();
+                        }
+                    } else {
+                        console.warn('Progress panel not found, will retry on next update');
+                        // Set a shorter timeout to try again
+                        setTimeout(() => this.checkDownloadStatus(), 500);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error('Failed to check download status:', error);
+        }
+    }
+    
+    // Update download button text based on current state
+    updateDownloadButtonText() {
+        const btnTextElement = document.getElementById('exampleDownloadBtnText');
+        if (btnTextElement) {
+            if (this.isDownloading && this.isPaused) {
+                btnTextElement.textContent = "Resume";
+            } else if (!this.isDownloading) {
+                btnTextElement.textContent = "Download";
+            }
+        }
+    }
+    
+    async startDownload() {
+        if (this.isDownloading) {
+            showToast('Download already in progress', 'warning');
+            return;
+        }
+        
+        try {
+            const outputDir = document.getElementById('exampleImagesPath').value || '';
+            
+            if (!outputDir) {
+                showToast('Please enter a download location first', 'warning');
+                return;
+            }
+            
+            const optimize = document.getElementById('optimizeExampleImages').checked;
+            
+            const response = await fetch('/api/download-example-images', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    output_dir: outputDir,
+                    optimize: optimize,
+                    model_types: ['lora', 'checkpoint']
+                })
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isDownloading = true;
+                this.isPaused = false;
+                this.startTime = new Date();
+                this.updateUI(data.status);
+                this.showProgressPanel();
+                this.startProgressUpdates();
+                this.updateDownloadButtonText();
+                showToast('Example images download started', 'success');
+                
+                // Close settings modal
+                modalManager.closeModal('settingsModal');
+            } else {
+                showToast(data.error || 'Failed to start download', 'error');
+            }
+        } catch (error) {
+            console.error('Failed to start download:', error);
+            showToast('Failed to start download', 'error');
+        }
+    }
+    
+    async pauseDownload() {
+        if (!this.isDownloading || this.isPaused) {
+            return;
+        }
+        
+        try {
+            const response = await fetch('/api/pause-example-images', {
+                method: 'POST'
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isPaused = true;
+                document.getElementById('downloadStatusText').textContent = 'Paused';
+                
+                // Only update the icon element, not the entire innerHTML
+                if (this.pauseButton) {
+                    const iconElement = this.pauseButton.querySelector('i');
+                    if (iconElement) {
+                        iconElement.className = 'fas fa-play';
+                    }
+                    this.pauseButton.onclick = () => this.resumeDownload();
+                }
+                
+                this.updateDownloadButtonText();
+                showToast('Download paused', 'info');
+            } else {
+                showToast(data.error || 'Failed to pause download', 'error');
+            }
+        } catch (error) {
+            console.error('Failed to pause download:', error);
+            showToast('Failed to pause download', 'error');
+        }
+    }
+    
+    async resumeDownload() {
+        if (!this.isDownloading || !this.isPaused) {
+            return;
+        }
+        
+        try {
+            const response = await fetch('/api/resume-example-images', {
+                method: 'POST'
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isPaused = false;
+                document.getElementById('downloadStatusText').textContent = 'Downloading';
+                
+                // Only update the icon element, not the entire innerHTML
+                if (this.pauseButton) {
+                    const iconElement = this.pauseButton.querySelector('i');
+                    if (iconElement) {
+                        iconElement.className = 'fas fa-pause';
+                    }
+                    this.pauseButton.onclick = () => this.pauseDownload();
+                }
+                
+                this.updateDownloadButtonText();
+                showToast('Download resumed', 'success');
+            } else {
+                showToast(data.error || 'Failed to resume download', 'error');
+            }
+        } catch (error) {
+            console.error('Failed to resume download:', error);
+            showToast('Failed to resume download', 'error');
+        }
+    }
+    
+    startProgressUpdates() {
+        // Clear any existing interval
+        if (this.progressUpdateInterval) {
+            clearInterval(this.progressUpdateInterval);
+        }
+        
+        // Set new interval to update progress every 2 seconds
+        this.progressUpdateInterval = setInterval(async () => {
+            await this.updateProgress();
+        }, 2000);
+    }
+    
+    async updateProgress() {
+        try {
+            const response = await fetch('/api/example-images-status');
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isDownloading = data.is_downloading;
+                this.isPaused = data.status.status === 'paused';
+                
+                // Update download button text
+                this.updateDownloadButtonText();
+                
+                if (this.isDownloading) {
+                    this.updateUI(data.status);
+                } else {
+                    // Download completed or failed
+                    clearInterval(this.progressUpdateInterval);
+                    this.progressUpdateInterval = null;
+                    
+                    if (data.status.status === 'completed') {
+                        showToast('Example images download completed', 'success');
+                        // Hide the panel after a delay
+                        setTimeout(() => this.hideProgressPanel(), 5000);
+                    } else if (data.status.status === 'error') {
+                        showToast('Example images download failed', 'error');
+                    }
+                }
+            }
+        } catch (error) {
+            console.error('Failed to update progress:', error);
+        }
+    }
+    
+    updateUI(status) {
+        // Ensure progress panel exists
+        if (!this.progressPanel) {
+            this.progressPanel = document.getElementById('exampleImagesProgress');
+            if (!this.progressPanel) {
+                console.error('Progress panel element not found in DOM');
+                return;
+            }
+        }
+        
+        // Update status text
+        const statusText = document.getElementById('downloadStatusText');
+        if (statusText) {
+            statusText.textContent = this.getStatusText(status.status);
+        }
+        
+        // Update progress counts and bar
+        const progressCounts = document.getElementById('downloadProgressCounts');
+        if (progressCounts) {
+            progressCounts.textContent = `${status.completed}/${status.total}`;
+        }
+        
+        const progressBar = document.getElementById('downloadProgressBar');
+        if (progressBar) {
+            const progressPercent = status.total > 0 ? (status.completed / status.total) * 100 : 0;
+            progressBar.style.width = `${progressPercent}%`;
+            
+            // Update mini progress circle
+            this.updateMiniProgress(progressPercent);
+        }
+        
+        // Update current model
+        const currentModel = document.getElementById('currentModelName');
+        if (currentModel) {
+            currentModel.textContent = status.current_model || '-';
+        }
+        
+        // Update time stats
+        this.updateTimeStats(status);
+        
+        // Update errors
+        this.updateErrors(status);
+        
+        // Update pause/resume button
+        if (!this.pauseButton) {
+            this.pauseButton = document.getElementById('pauseExampleDownloadBtn');
+        }
+        
+        if (this.pauseButton) {
+            // Check if the button already has the SVG elements
+            let hasProgressElements = !!this.pauseButton.querySelector('.mini-progress-circle');
+            
+            if (!hasProgressElements) {
+                // If elements don't exist, add them
+                this.pauseButton.innerHTML = `
+                    <i class="${status.status === 'paused' ? 'fas fa-play' : 'fas fa-pause'}"></i>
+                    <svg class="mini-progress-container" width="24" height="24" viewBox="0 0 24 24">
+                        <circle class="mini-progress-background" cx="12" cy="12" r="10"></circle>
+                        <circle class="mini-progress-circle" cx="12" cy="12" r="10" stroke-dasharray="62.8" stroke-dashoffset="62.8"></circle>
+                    </svg>
+                    <span class="progress-percent"></span>
+                `;
+            } else {
+                // If elements exist, just update the icon
+                const iconElement = this.pauseButton.querySelector('i');
+                if (iconElement) {
+                    iconElement.className = status.status === 'paused' ? 'fas fa-play' : 'fas fa-pause';
+                }
+            }
+            
+            // Update click handler
+            this.pauseButton.onclick = status.status === 'paused' 
+                ? () => this.resumeDownload() 
+                : () => this.pauseDownload();
+            
+            // Update progress immediately
+            const progressBar = document.getElementById('downloadProgressBar');
+            if (progressBar) {
+                const progressPercent = status.total > 0 ? (status.completed / status.total) * 100 : 0;
+                this.updateMiniProgress(progressPercent);
+            }
+        }
+    }
+    
+    // Update the mini progress circle in the pause button
+    updateMiniProgress(percent) {
+        // Ensure we have the pause button reference
+        if (!this.pauseButton) {
+            this.pauseButton = document.getElementById('pauseExampleDownloadBtn');
+            if (!this.pauseButton) {
+                console.error('Pause button not found');
+                return;
+            }
+        }
+        
+        // Query elements within the context of the pause button
+        const miniProgressCircle = this.pauseButton.querySelector('.mini-progress-circle');
+        const percentText = this.pauseButton.querySelector('.progress-percent');
+        
+        if (miniProgressCircle && percentText) {
+            // Circle circumference = 2πr = 2 * π * 10 = 62.8
+            const circumference = 62.8;
+            const offset = circumference - (percent / 100) * circumference;
+            
+            miniProgressCircle.style.strokeDashoffset = offset;
+            percentText.textContent = `${Math.round(percent)}%`;
+            
+            // Only show percent text when panel is collapsed
+            percentText.style.display = this.isProgressPanelCollapsed ? 'block' : 'none';
+        } else {
+            console.warn('Mini progress elements not found within pause button', 
+                         this.pauseButton,
+                         'mini-progress-circle:', !!miniProgressCircle, 
+                         'progress-percent:', !!percentText);
+        }
+    }
+    
+    updateTimeStats(status) {
+        const elapsedTime = document.getElementById('elapsedTime');
+        const remainingTime = document.getElementById('remainingTime');
+        
+        if (!elapsedTime || !remainingTime) return;
+        
+        // Calculate elapsed time
+        let elapsed;
+        if (status.start_time) {
+            const now = new Date();
+            const startTime = new Date(status.start_time * 1000);
+            elapsed = Math.floor((now - startTime) / 1000);
+        } else {
+            elapsed = 0;
+        }
+        
+        elapsedTime.textContent = this.formatTime(elapsed);
+        
+        // Calculate remaining time
+        if (status.total > 0 && status.completed > 0 && status.status === 'running') {
+            const rate = status.completed / elapsed; // models per second
+            const remaining = Math.floor((status.total - status.completed) / rate);
+            remainingTime.textContent = this.formatTime(remaining);
+        } else {
+            remainingTime.textContent = '--:--:--';
+        }
+    }
+    
+    updateErrors(status) {
+        const errorContainer = document.getElementById('downloadErrorContainer');
+        const errorList = document.getElementById('downloadErrors');
+        
+        if (!errorContainer || !errorList) return;
+        
+        if (status.errors && status.errors.length > 0) {
+            // Show only the last 3 errors
+            const recentErrors = status.errors.slice(-3);
+            errorList.innerHTML = recentErrors.map(error => 
+                `<div class="error-item">${error}</div>`
+            ).join('');
+            
+            errorContainer.classList.remove('hidden');
+        } else {
+            errorContainer.classList.add('hidden');
+        }
+    }
+    
+    formatTime(seconds) {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+        
+        return [
+            hours.toString().padStart(2, '0'),
+            minutes.toString().padStart(2, '0'),
+            secs.toString().padStart(2, '0')
+        ].join(':');
+    }
+    
+    getStatusText(status) {
+        switch (status) {
+            case 'running': return 'Downloading';
+            case 'paused': return 'Paused';
+            case 'completed': return 'Completed';
+            case 'error': return 'Error';
+            default: return 'Initializing';
+        }
+    }
+    
+    showProgressPanel() {
+        // Ensure progress panel exists
+        if (!this.progressPanel) {
+            this.progressPanel = document.getElementById('exampleImagesProgress');
+            if (!this.progressPanel) {
+                console.error('Progress panel element not found in DOM');
+                return;
+            }
+        }
+        this.progressPanel.classList.add('visible');
+    }
+    
+    hideProgressPanel() {
+        if (!this.progressPanel) {
+            this.progressPanel = document.getElementById('exampleImagesProgress');
+            if (!this.progressPanel) return;
+        }
+        this.progressPanel.classList.remove('visible');
+    }
+    
+    toggleProgressPanel() {
+        if (!this.progressPanel) {
+            this.progressPanel = document.getElementById('exampleImagesProgress');
+            if (!this.progressPanel) return;
+        }
+        
+        this.isProgressPanelCollapsed = !this.isProgressPanelCollapsed;
+        this.progressPanel.classList.toggle('collapsed');
+        
+        // Save collapsed state to storage
+        setStorageItem('progress_panel_collapsed', this.isProgressPanelCollapsed);
+        
+        // Update icon
+        const icon = document.querySelector('#collapseProgressBtn i');
+        if (icon) {
+            if (this.isProgressPanelCollapsed) {
+                icon.className = 'fas fa-chevron-up';
+            } else {
+                icon.className = 'fas fa-chevron-down';
+            }
+        }
+        
+        // Force update mini progress if panel is collapsed
+        if (this.isProgressPanelCollapsed) {
+            const progressBar = document.getElementById('downloadProgressBar');
+            if (progressBar) {
+                const progressPercent = parseFloat(progressBar.style.width) || 0;
+                this.updateMiniProgress(progressPercent);
+            }
+        }
+    }
+}
+
+// Create singleton instance
+export const exampleImagesManager = new ExampleImagesManager();

static/js/managers/ImportManager.js

@@ -146,6 +146,18 @@ export class ImportManager {
         if (totalSizeDisplay) {
             totalSizeDisplay.textContent = 'Calculating...';
         }
+        
+        // Remove any existing deleted LoRAs warning
+        const deletedLorasWarning = document.getElementById('deletedLorasWarning');
+        if (deletedLorasWarning) {
+            deletedLorasWarning.remove();
+        }
+        
+        // Remove any existing early access warning
+        const earlyAccessWarning = document.getElementById('earlyAccessWarning');
+        if (earlyAccessWarning) {
+            earlyAccessWarning.remove();
+        }
     }
 
     toggleImportMode(mode) {
@@ -532,17 +544,17 @@ export class ImportManager {
         const nextButton = document.querySelector('#detailsStep .primary-btn');
         if (!nextButton) return;
         
+        // Always clean up previous warnings first
+        const existingWarning = document.getElementById('deletedLorasWarning');
+        if (existingWarning) {
+            existingWarning.remove();
+        }
+        
         // Count deleted LoRAs
         const deletedLoras = this.recipeData.loras.filter(lora => lora.isDeleted).length;
         
         // If we have deleted LoRAs, show a warning and update button text
         if (deletedLoras > 0) {
-            // Remove any existing warning
-            const existingWarning = document.getElementById('deletedLorasWarning');
-            if (existingWarning) {
-                existingWarning.remove();
-            }
-            
             // Create a new warning container above the buttons
             const buttonsContainer = document.querySelector('#detailsStep .modal-actions') || nextButton.parentNode;
             const warningContainer = document.createElement('div');

static/js/managers/ModalManager.js

@@ -59,6 +59,19 @@ export class ModalManager {
                 }
             });
         }
+        
+        // Add excludeModal registration
+        const excludeModal = document.getElementById('excludeModal');
+        if (excludeModal) {
+            this.registerModal('excludeModal', {
+                element: excludeModal,
+                onClose: () => {
+                    this.getModal('excludeModal').element.classList.remove('show');
+                    document.body.classList.remove('modal-open');
+                },
+                closeOnOutsideClick: true
+            });
+        }
 
         // Add downloadModal registration
         const downloadModal = document.getElementById('downloadModal');
@@ -208,7 +221,7 @@ export class ModalManager {
         // Store current scroll position before showing modal
         this.scrollPosition = window.scrollY;
 
-        if (id === 'deleteModal') {
+        if (id === 'deleteModal' || id === 'excludeModal') {
             modal.element.classList.add('show');
         } else {
             modal.element.style.display = 'block';

static/js/managers/SettingsManager.js

@@ -147,6 +147,8 @@ export class SettingsManager {
             state.global.settings.show_only_sfw = value;
         } else if (settingKey === 'autoplay_on_hover') {
             state.global.settings.autoplayOnHover = value;
+        } else if (settingKey === 'optimize_example_images') {
+            state.global.settings.optimizeExampleImages = value;
         } else {
             // For any other settings that might be added in the future
             state.global.settings[settingKey] = value;

static/js/recipes.js

@@ -5,6 +5,7 @@ import { RecipeCard } from './components/RecipeCard.js';
 import { RecipeModal } from './components/RecipeModal.js';
 import { getCurrentPageState } from './state/index.js';
 import { getSessionItem, removeSessionItem } from './utils/storageHelpers.js';
+import { RecipeContextMenu } from './components/ContextMenu/index.js';
 
 class RecipeManager {
     constructor() {
@@ -37,6 +38,9 @@ class RecipeManager {
         // Set default search options if not already defined
         this._initSearchOptions();
         
+        // Initialize context menu
+        new RecipeContextMenu();
+        
         // Check for custom filter parameters in session storage
         this._checkCustomFilter();
         
@@ -264,6 +268,32 @@ class RecipeManager {
         }
     }
     
+    /**
+     * Refreshes the recipe list by first rebuilding the cache and then loading recipes
+     */
+    async refreshRecipes() {
+        try {           
+            // Call the new endpoint to rebuild the recipe cache
+            const response = await fetch('/api/recipes/scan');
+            
+            if (!response.ok) {
+                const data = await response.json();
+                throw new Error(data.error || 'Failed to refresh recipe cache');
+            }
+            
+            // After successful cache rebuild, load the recipes
+            await this.loadRecipes(true);
+            
+            appCore.showToast('Refresh complete', 'success');
+        } catch (error) {
+            console.error('Error refreshing recipes:', error);
+            appCore.showToast(error.message || 'Failed to refresh recipes', 'error');
+            
+            // Still try to load recipes even if scan failed
+            await this.loadRecipes(true);
+        }
+    }
+    
     async _loadSpecificRecipe(recipeId) {
         try {
             // Fetch specific recipe by ID

static/js/state/index.js

@@ -1,5 +1,5 @@
 // Create the new hierarchical state structure
-import { getStorageItem } from '../utils/storageHelpers.js';
+import { getStorageItem, getMapFromStorage } from '../utils/storageHelpers.js';
 
 // Load settings from localStorage or use defaults
 const savedSettings = getStorageItem('settings', {
@@ -7,6 +7,10 @@ const savedSettings = getStorageItem('settings', {
     show_only_sfw: false
 });
 
+// Load preview versions from localStorage
+const loraPreviewVersions = getMapFromStorage('lora_preview_versions');
+const checkpointPreviewVersions = getMapFromStorage('checkpoint_preview_versions');
+
 export const state = {
     // Global state
     global: {
@@ -23,7 +27,8 @@ export const state = {
             hasMore: true,
             sortBy: 'name',
             activeFolder: null,
-            previewVersions: new Map(),
+            activeLetterFilter: null, // New property for letter filtering
+            previewVersions: loraPreviewVersions,
             searchManager: null,
             searchOptions: {
                 filename: true,
@@ -38,6 +43,7 @@ export const state = {
             bulkMode: false,
             selectedLoras: new Set(),
             loraMetadataCache: new Map(),
+            showFavoritesOnly: false,
         },
         
         recipes: {
@@ -57,7 +63,8 @@ export const state = {
                 tags: [],
                 search: ''
             },
-            pageSize: 20
+            pageSize: 20,
+            showFavoritesOnly: false,
         },
         
         checkpoints: {
@@ -66,6 +73,7 @@ export const state = {
             hasMore: true,
             sortBy: 'name',
             activeFolder: null,
+            previewVersions: checkpointPreviewVersions,
             searchManager: null,
             searchOptions: {
                 filename: true,
@@ -75,7 +83,8 @@ export const state = {
             filters: {
                 baseModel: [],
                 tags: []
-            }
+            },
+            showFavoritesOnly: false,
         }
     },
     

static/js/utils/constants.js

@@ -33,9 +33,11 @@ export const BASE_MODELS = {
     NOOBAI: "NoobAI",
     ILLUSTRIOUS: "Illustrious",
     PONY: "Pony",
+    HIDREAM: "HiDream",
     
     // Video models
     SVD: "SVD",
+    LTXV: "LTXV",
     WAN_VIDEO: "Wan Video",
     HUNYUAN_VIDEO: "Hunyuan Video",
     
@@ -69,6 +71,7 @@ export const BASE_MODEL_CLASSES = {
     
     // Video models
     [BASE_MODELS.SVD]: "svd",
+    [BASE_MODELS.LTXV]: "ltxv",
     [BASE_MODELS.WAN_VIDEO]: "wan-video",
     [BASE_MODELS.HUNYUAN_VIDEO]: "hunyuan-video",
     
@@ -84,6 +87,7 @@ export const BASE_MODEL_CLASSES = {
     [BASE_MODELS.NOOBAI]: "noobai",
     [BASE_MODELS.ILLUSTRIOUS]: "il",
     [BASE_MODELS.PONY]: "pony",
+    [BASE_MODELS.HIDREAM]: "hidream",
     
     // Default
     [BASE_MODELS.UNKNOWN]: "unknown"

static/js/utils/infiniteScroll.js

@@ -4,6 +4,7 @@ import { loadMoreCheckpoints } from '../api/checkpointApi.js';
 import { debounce } from './debounce.js';
 
 export function initializeInfiniteScroll(pageType = 'loras') {
+    // Clean up any existing observer
     if (state.observer) {
         state.observer.disconnect();
     }
@@ -47,53 +48,53 @@ export function initializeInfiniteScroll(pageType = 'loras') {
     }
 
     const debouncedLoadMore = debounce(loadMoreFunction, 100);
-
-    // Create a more robust observer with lower threshold and root margin
-    state.observer = new IntersectionObserver(
-        (entries) => {
-            const target = entries[0];
-            if (target.isIntersecting && !pageState.isLoading && pageState.hasMore) {
-                debouncedLoadMore();
-            }
-        },
-        { 
-            threshold: 0.01,  // Lower threshold to detect even minimal visibility
-            rootMargin: '0px 0px 300px 0px' // Increase bottom margin to trigger earlier
-        }
-    );
-
+    
     const grid = document.getElementById(gridId);
     if (!grid) {
         console.warn(`Grid with ID "${gridId}" not found for infinite scroll`);
         return;
     }
-
+    
+    // Remove any existing sentinel
     const existingSentinel = document.getElementById('scroll-sentinel');
     if (existingSentinel) {
-        state.observer.observe(existingSentinel);
-    } else {
-        // Create a wrapper div that will be placed after the grid
-        const sentinelWrapper = document.createElement('div');
-        sentinelWrapper.style.width = '100%';
-        sentinelWrapper.style.height = '30px'; // Increased height for better visibility
-        sentinelWrapper.style.margin = '0';
-        sentinelWrapper.style.padding = '0';
-        
-        // Create the actual sentinel element
-        const sentinel = document.createElement('div');
-        sentinel.id = 'scroll-sentinel';
-        sentinel.style.height = '30px'; // Match wrapper height
-        
-        // Add the sentinel to the wrapper
-        sentinelWrapper.appendChild(sentinel);
-        
-        // Insert the wrapper after the grid instead of inside it
-        grid.parentNode.insertBefore(sentinelWrapper, grid.nextSibling);
-        
-        state.observer.observe(sentinel);
+        existingSentinel.remove();
     }
     
-    // Add a scroll event backup to handle edge cases
+    // Create a sentinel element after the grid (not inside it)
+    const sentinel = document.createElement('div');
+    sentinel.id = 'scroll-sentinel';
+    sentinel.style.width = '100%';
+    sentinel.style.height = '20px';
+    sentinel.style.visibility = 'hidden'; // Make it invisible but still affect layout
+    
+    // Insert after grid instead of inside
+    grid.parentNode.insertBefore(sentinel, grid.nextSibling);
+    
+    // Create observer with appropriate settings, slightly different for checkpoints page
+    const observerOptions = {
+        threshold: 0.1,
+        rootMargin: pageType === 'checkpoints' ? '0px 0px 200px 0px' : '0px 0px 100px 0px'
+    };
+    
+    // Initialize the observer
+    state.observer = new IntersectionObserver((entries) => {
+        const target = entries[0];
+        if (target.isIntersecting && !pageState.isLoading && pageState.hasMore) {
+            debouncedLoadMore();
+        }
+    }, observerOptions);
+    
+    // Start observing
+    state.observer.observe(sentinel);
+    
+    // Clean up any existing scroll event listener
+    if (state.scrollHandler) {
+        window.removeEventListener('scroll', state.scrollHandler);
+        state.scrollHandler = null;
+    }
+    
+    // Add a simple backup scroll handler
     const handleScroll = debounce(() => {
         if (pageState.isLoading || !pageState.hasMore) return;
         
@@ -103,26 +104,17 @@ export function initializeInfiniteScroll(pageType = 'loras') {
         const rect = sentinel.getBoundingClientRect();
         const windowHeight = window.innerHeight;
         
-        // If sentinel is within 500px of viewport bottom, load more
-        if (rect.top < windowHeight + 500) {
+        if (rect.top < windowHeight + 200) {
             debouncedLoadMore();
         }
     }, 200);
     
-    // Clean up existing scroll listener if any
-    if (state.scrollHandler) {
-        window.removeEventListener('scroll', state.scrollHandler);
-    }
-    
-    // Save reference to the handler for cleanup
     state.scrollHandler = handleScroll;
     window.addEventListener('scroll', state.scrollHandler);
     
-    // Check position immediately in case content is already visible
-    setTimeout(() => {
-        const sentinel = document.getElementById('scroll-sentinel');
-        if (sentinel && sentinel.getBoundingClientRect().top < window.innerHeight) {
-            debouncedLoadMore();
-        }
-    }, 100);
+    // Clear any existing interval
+    if (state.scrollCheckInterval) {
+        clearInterval(state.scrollCheckInterval);
+        state.scrollCheckInterval = null;
+    }
 }

static/js/utils/modalUtils.js

@@ -1,15 +1,18 @@
 import { modalManager } from '../managers/ModalManager.js';
+import { excludeLora, deleteModel as deleteLora } from '../api/loraApi.js';
+import { excludeCheckpoint, deleteCheckpoint } from '../api/checkpointApi.js';
 
 let pendingDeletePath = null;
 let pendingModelType = null;
+let pendingExcludePath = null;
+let pendingExcludeModelType = null;
 
 export function showDeleteModal(filePath, modelType = 'lora') {
-    // event.stopPropagation();
     pendingDeletePath = filePath;
     pendingModelType = modelType;
     
     const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
-    const modelName = card.dataset.name;
+    const modelName = card ? card.dataset.name : filePath.split('/').pop();
     const modal = modalManager.getModal('deleteModal').element;
     const modelInfo = modal.querySelector('.delete-model-info');
     
@@ -28,31 +31,19 @@ export async function confirmDelete() {
     const card = document.querySelector(`.lora-card[data-filepath="${pendingDeletePath}"]`);
     
     try {
-        // Use the appropriate endpoint based on model type
-        const endpoint = pendingModelType === 'checkpoint' ? 
-            '/api/checkpoints/delete' : 
-            '/api/delete_model';
-        
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ 
-                file_path: pendingDeletePath
-            })
-        });
-
-        if (response.ok) {
-            if (card) {
-                card.remove();
-            }
-            closeDeleteModal();
+        // Use appropriate delete function based on model type
+        if (pendingModelType === 'checkpoint') {
+            await deleteCheckpoint(pendingDeletePath);
         } else {
-            const error = await response.text();
-            alert(`Failed to delete model: ${error}`);
+            await deleteLora(pendingDeletePath);
         }
+
+        if (card) {
+            card.remove();
+        }
+        closeDeleteModal();
     } catch (error) {
+        console.error('Error deleting model:', error);
         alert(`Error deleting model: ${error}`);
     }
 }
@@ -61,4 +52,46 @@ export function closeDeleteModal() {
     modalManager.closeModal('deleteModal');
     pendingDeletePath = null;
     pendingModelType = null;
+}
+
+// Functions for the exclude modal
+export function showExcludeModal(filePath, modelType = 'lora') {
+    pendingExcludePath = filePath;
+    pendingExcludeModelType = modelType;
+    
+    const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+    const modelName = card ? card.dataset.name : filePath.split('/').pop();
+    const modal = modalManager.getModal('excludeModal').element;
+    const modelInfo = modal.querySelector('.exclude-model-info');
+    
+    modelInfo.innerHTML = `
+        <strong>Model:</strong> ${modelName}
+        <br>
+        <strong>File:</strong> ${filePath}
+    `;
+    
+    modalManager.showModal('excludeModal');
+}
+
+export function closeExcludeModal() {
+    modalManager.closeModal('excludeModal');
+    pendingExcludePath = null;
+    pendingExcludeModelType = null;
+}
+
+export async function confirmExclude() {
+    if (!pendingExcludePath) return;
+    
+    try {
+        // Use appropriate exclude function based on model type
+        if (pendingExcludeModelType === 'checkpoint') {
+            await excludeCheckpoint(pendingExcludePath);
+        } else {
+            await excludeLora(pendingExcludePath);
+        }
+        
+        closeExcludeModal();
+    } catch (error) {
+        console.error('Error excluding model:', error);
+    }
 }

static/js/utils/storageHelpers.js

@@ -171,4 +171,45 @@ export function migrateStorageItems() {
     localStorage.setItem(STORAGE_PREFIX + 'migration_completed', 'true');
     
     console.log('Lora Manager: Storage migration completed');
+}
+
+/**
+ * Save a Map to localStorage
+ * @param {string} key - The localStorage key
+ * @param {Map} map - The Map to save
+ */
+export function saveMapToStorage(key, map) {
+    if (!(map instanceof Map)) {
+        console.error('Cannot save non-Map object:', map);
+        return;
+    }
+
+    try {
+        const prefixedKey = STORAGE_PREFIX + key;
+        // Convert Map to array of entries and save as JSON
+        const entries = Array.from(map.entries());
+        localStorage.setItem(prefixedKey, JSON.stringify(entries));
+    } catch (error) {
+        console.error(`Error saving Map to localStorage (${key}):`, error);
+    }
+}
+
+/**
+ * Load a Map from localStorage
+ * @param {string} key - The localStorage key
+ * @returns {Map} - The loaded Map or a new empty Map
+ */
+export function getMapFromStorage(key) {
+    try {
+        const prefixedKey = STORAGE_PREFIX + key;
+        const data = localStorage.getItem(prefixedKey);
+        if (!data) return new Map();
+        
+        // Parse JSON and convert back to Map
+        const entries = JSON.parse(data);
+        return new Map(entries);
+    } catch (error) {
+        console.error(`Error loading Map from localStorage (${key}):`, error);
+        return new Map();
+    }
 }

static/js/utils/uiHelpers.js

@@ -2,6 +2,40 @@ import { state } from '../state/index.js';
 import { resetAndReload } from '../api/loraApi.js';
 import { getStorageItem, setStorageItem } from './storageHelpers.js';
 
+/**
+ * Utility function to copy text to clipboard with fallback for older browsers
+ * @param {string} text - The text to copy to clipboard
+ * @param {string} successMessage - Optional success message to show in toast
+ * @returns {Promise<boolean>} - Promise that resolves to true if copy was successful
+ */
+export async function copyToClipboard(text, successMessage = 'Copied to clipboard') {
+    try {
+        // Modern clipboard API
+        if (navigator.clipboard && window.isSecureContext) {
+            await navigator.clipboard.writeText(text);
+        } else {
+            // Fallback for older browsers
+            const textarea = document.createElement('textarea');
+            textarea.value = text;
+            textarea.style.position = 'absolute';
+            textarea.style.left = '-99999px';
+            document.body.appendChild(textarea);
+            textarea.select();
+            document.execCommand('copy');
+            document.body.removeChild(textarea);
+        }
+        
+        if (successMessage) {
+            showToast(successMessage, 'success');
+        }
+        return true;
+    } catch (err) {
+        console.error('Copy failed:', err);
+        showToast('Copy failed', 'error');
+        return false;
+    }
+}
+
 export function showToast(message, type = 'info') {
     const toast = document.createElement('div');
     toast.className = `toast toast-${type}`;
@@ -80,13 +114,55 @@ export function restoreFolderFilter() {
 }
 
 export function initTheme() {
-    document.body.dataset.theme = getStorageItem('theme') || 'dark';
+    const savedTheme = getStorageItem('theme') || 'auto';
+    applyTheme(savedTheme);
+    
+    // Update theme when system preference changes (for 'auto' mode)
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+        const currentTheme = getStorageItem('theme') || 'auto';
+        if (currentTheme === 'auto') {
+            applyTheme('auto');
+        }
+    });
 }
 
 export function toggleTheme() {
-    const theme = document.body.dataset.theme === 'light' ? 'dark' : 'light';
-    document.body.dataset.theme = theme;
-    setStorageItem('theme', theme);
+    const currentTheme = getStorageItem('theme') || 'auto';
+    let newTheme;
+    
+    if (currentTheme === 'dark') {
+        newTheme = 'light';
+    } else {
+        newTheme = 'dark';
+    }
+    
+    setStorageItem('theme', newTheme);
+    applyTheme(newTheme);
+    
+    // Force a repaint to ensure theme changes are applied immediately
+    document.body.style.display = 'none';
+    document.body.offsetHeight; // Trigger a reflow
+    document.body.style.display = '';
+    
+    return newTheme;
+}
+
+// Add a new helper function to apply the theme
+function applyTheme(theme) {
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const htmlElement = document.documentElement;
+    
+    // Remove any existing theme attributes
+    htmlElement.removeAttribute('data-theme');
+    
+    // Apply the appropriate theme
+    if (theme === 'dark' || (theme === 'auto' && prefersDark)) {
+        htmlElement.setAttribute('data-theme', 'dark');
+        document.body.dataset.theme = 'dark';
+    } else {
+        htmlElement.setAttribute('data-theme', 'light');
+        document.body.dataset.theme = 'light';
+    }
 }
 
 export function toggleFolder(tag) {
@@ -108,12 +184,6 @@ export function toggleFolder(tag) {
     resetAndReload();
 }
 
-export function copyTriggerWord(word) {
-    navigator.clipboard.writeText(word).then(() => {
-        showToast('Trigger word copied', 'success');
-    });
-}
-
 function filterByFolder(folderPath) {
     document.querySelectorAll('.lora-card').forEach(card => {
         card.style.display = card.dataset.folder === folderPath ? '' : 'none';
@@ -241,15 +311,12 @@ export function initFolderTagsVisibility() {
 }
 
 export function initBackToTop() {
-    const button = document.createElement('button');
-    button.className = 'back-to-top';
-    button.innerHTML = '<i class="fas fa-chevron-up"></i>';
-    button.title = 'Back to top';
-    document.body.appendChild(button);
+    const button = document.getElementById('backToTopBtn');
+    if (!button) return;
 
     // Get the scrollable container
     const scrollContainer = document.querySelector('.page-content');
-
+    
     // Show/hide button based on scroll position
     const toggleBackToTop = () => {
         const scrollThreshold = window.innerHeight * 0.3;