Merge branch 'master' into range-type

.ci/windows_amd_base_files/README_VERY_IMPORTANT.txt

@@ -1,4 +1,5 @@
-As of the time of writing this you need a recent driver. Updating to the latest driver is recommended.
+As of the time of writing this you need this driver for best results:
+https://www.amd.com/en/resources/support-articles/release-notes/RN-AMDGPU-WINDOWS-PYTORCH-7-1-1.html
 
 HOW TO RUN:
 
@@ -6,9 +7,9 @@ If you have a AMD gpu:
 
 run_amd_gpu.bat
 
-If you have memory issues you can try enabling the new dynamic memory management by running comfyui with:
+If you have memory issues you can try disabling the smart memory management by running comfyui with:
 
-run_amd_gpu_enable_dynamic_vram.bat
+run_amd_gpu_disable_smart_memory.bat
 
 IF YOU GET A RED ERROR IN THE UI MAKE SURE YOU HAVE A MODEL/CHECKPOINT IN: ComfyUI\models\checkpoints
 

.ci/windows_amd_base_files/run_amd_gpu_disable_smart_memory.bat

@@ -1,2 +1,2 @@
-.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --enable-dynamic-vram
+.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --disable-smart-memory
 pause

.coderabbit.yaml

@@ -4,12 +4,12 @@ early_access: false
 tone_instructions: "Only comment on issues introduced by this PR's changes. Do not flag pre-existing problems in moved, re-indented, or reformatted code."
 
 reviews:
-  profile: "assertive"
-  request_changes_workflow: true
+  profile: "chill"
+  request_changes_workflow: false
   high_level_summary: false
   poem: false
   review_status: false
-  review_details: true
+  review_details: false
   commit_status: true
   collapse_walkthrough: true
   changed_files_summary: false
@@ -39,14 +39,6 @@ reviews:
     - path: "**"
       instructions: |
         IMPORTANT: Only comment on issues directly introduced by this PR's code changes.
-        Treat AGENTS.md as mandatory repository policy, not optional style guidance.
-        Flag PR changes that violate AGENTS.md even when the code is otherwise functional.
-        In particular, enforce architecture boundaries, dtype/device/memory rules,
-        interface contracts, import style, no unnecessary try/except blocks, no inline
-        imports, no outbound internet paths in core ComfyUI, and narrow scoped fixes.
-        Prefer direct findings over suggestions when a rule is violated. Only ignore
-        AGENTS.md when it clearly conflicts with a newer explicit maintainer instruction
-        in the PR.
         Do NOT flag pre-existing issues in code that was merely moved, re-indented,
         de-indented, or reformatted without logic changes. If code appears in the diff
         only due to whitespace or structural reformatting (e.g., removing a `with:` block),
@@ -131,10 +123,5 @@ chat:
 
 knowledge_base:
   opt_out: false
-  code_guidelines:
-    enabled: true
-    filePatterns:
-      - files: "AGENTS.md"
-        applyTo: "**"
   learnings:
     scope: "auto"

.github/workflows/backport_release.yaml

@@ -1,519 +0,0 @@
-name: Backport Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      commit:
-        description: 'Full 40-char SHA of the tip commit of the backport source branch (the PR head commit that passed tests). The branch is resolved from this SHA and must be unique.'
-        required: true
-        type: string
-
-permissions:
-  contents: read
-  pull-requests: read
-  checks: read
-
-jobs:
-  backport-release:
-    name: Create backport release
-    runs-on: ubuntu-latest
-    environment: backport release
-
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1
-        with:
-          app-id: ${{ secrets.FEN_RELEASE_APP_ID }}
-          private-key: ${{ secrets.FEN_RELEASE_PRIVATE_KEY }}
-
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          fetch-depth: 0
-          fetch-tags: true
-
-      - name: Configure git
-        run: |
-          git config user.name  "fen-release[bot]"
-          git config user.email "fen-release[bot]@users.noreply.github.com"
-
-      - name: Resolve source branch from commit SHA
-        id: resolve
-        env:
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-
-          # Require a full 40-char lowercase-hex SHA. Short SHAs are ambiguous
-          # and we will be comparing this value against API responses (PR head
-          # SHA, ref tips) that always return the full form.
-          if [[ ! "${SOURCE_COMMIT}" =~ ^[0-9a-f]{40}$ ]]; then
-            echo "::error::Input commit '${SOURCE_COMMIT}' is not a full 40-char lowercase hex SHA."
-            exit 1
-          fi
-
-          # Fetch all remote branches so we can search for which one(s) point
-          # at this SHA. `actions/checkout` with fetch-depth: 0 fetches full
-          # history of the checked-out ref but does not necessarily populate
-          # every refs/remotes/origin/*, so do it explicitly.
-          git fetch --prune origin '+refs/heads/*:refs/remotes/origin/*'
-
-          # Verify the commit actually exists in this repo's object DB.
-          if ! git cat-file -e "${SOURCE_COMMIT}^{commit}" 2>/dev/null; then
-            echo "::error::Commit ${SOURCE_COMMIT} was not found in the repository."
-            exit 1
-          fi
-
-          # Find every remote branch whose tip == SOURCE_COMMIT. Exactly one
-          # branch must point at it. If zero, the commit isn't anyone's tip
-          # (likely stale, force-pushed past, or never the PR head). If more
-          # than one, the (branch -> SHA) mapping is ambiguous and we refuse
-          # to guess — the operator must give us a unique branch to release.
-          mapfile -t matching_branches < <(
-            git for-each-ref \
-              --format='%(refname:strip=3)' \
-              --points-at="${SOURCE_COMMIT}" \
-              refs/remotes/origin/ \
-              | grep -vx 'HEAD' || true
-          )
-
-          if [[ "${#matching_branches[@]}" -eq 0 ]]; then
-            echo "::error::No branch on origin has ${SOURCE_COMMIT} as its tip."
-            echo "::error::Either the branch was updated after you copied this SHA, or this commit was never the head of a branch."
-            exit 1
-          fi
-
-          if [[ "${#matching_branches[@]}" -gt 1 ]]; then
-            echo "::error::More than one branch on origin has ${SOURCE_COMMIT} as its tip; cannot pick one:"
-            for b in "${matching_branches[@]}"; do
-              echo "::error::  - ${b}"
-            done
-            echo "::error::Refusing to proceed with an ambiguous source branch."
-            exit 1
-          fi
-
-          source_branch="${matching_branches[0]}"
-
-          if [[ "${source_branch}" == "${DEFAULT_BRANCH}" ]]; then
-            echo "::error::Source branch must not be the default branch ('${DEFAULT_BRANCH}')."
-            exit 1
-          fi
-
-          echo "Resolved commit ${SOURCE_COMMIT} to branch '${source_branch}'."
-          echo "source_branch=${source_branch}" >> "$GITHUB_OUTPUT"
-
-      - name: Determine latest stable release
-        id: latest
-        env:
-          GH_TOKEN: ${{ steps.app-token.outputs.token }}
-        run: |
-          set -euo pipefail
-
-          # List all tags matching vMAJOR.MINOR.PATCH and pick the highest by numeric
-          # comparison of each component. We DO NOT use `sort -V` because it treats
-          # v0.19.99 as higher than v0.20.1.
-          latest_tag="$(
-            git tag --list 'v[0-9]*.[0-9]*.[0-9]*' \
-              | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' \
-              | awk -F'[v.]' '{ printf "%010d %010d %010d %s\n", $2, $3, $4, $0 }' \
-              | sort -k1,1n -k2,2n -k3,3n \
-              | tail -n1 \
-              | awk '{print $4}'
-          )"
-
-          if [[ -z "${latest_tag}" ]]; then
-            echo "::error::No stable release tags (vMAJOR.MINOR.PATCH) were found."
-            exit 1
-          fi
-
-          # Parse components
-          ver="${latest_tag#v}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
-
-          new_patch=$((patch + 1))
-          new_version="v${major}.${minor}.${new_patch}"
-          release_branch="release/v${major}.${minor}"
-
-          latest_sha="$(git rev-list -n 1 "refs/tags/${latest_tag}")"
-
-          echo "latest_tag=${latest_tag}"             >> "$GITHUB_OUTPUT"
-          echo "latest_sha=${latest_sha}"             >> "$GITHUB_OUTPUT"
-          echo "major=${major}"                       >> "$GITHUB_OUTPUT"
-          echo "minor=${minor}"                       >> "$GITHUB_OUTPUT"
-          echo "patch=${patch}"                       >> "$GITHUB_OUTPUT"
-          echo "new_version=${new_version}"           >> "$GITHUB_OUTPUT"
-          echo "new_version_no_v=${major}.${minor}.${new_patch}" >> "$GITHUB_OUTPUT"
-          echo "release_branch=${release_branch}"     >> "$GITHUB_OUTPUT"
-
-          echo "Latest stable release: ${latest_tag} (${latest_sha})"
-          echo "New version will be:   ${new_version}"
-          echo "Release branch:        ${release_branch}"
-
-      - name: Validate source branch is cut directly from the latest stable release
-        env:
-          SOURCE_BRANCH:   ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:   ${{ inputs.commit }}
-          LATEST_TAG_SHA:  ${{ steps.latest.outputs.latest_sha }}
-          LATEST_TAG:      ${{ steps.latest.outputs.latest_tag }}
-        run: |
-          set -euo pipefail
-
-          # Use the user-provided SHA directly rather than re-resolving the branch
-          # tip — the resolve step already proved the branch tip equals SOURCE_COMMIT,
-          # and pinning to the SHA here makes the rest of the job TOCTOU-safe against
-          # someone pushing to the branch mid-run.
-          source_sha="${SOURCE_COMMIT}"
-
-          # Walking first-parent from the source tip must reach LATEST_TAG_SHA.
-          # We capture rev-list into a variable and grep against a here-string
-          # rather than piping `rev-list | grep -q`: under `set -o pipefail`,
-          # `grep -q` would exit on first match and SIGPIPE the still-streaming
-          # `rev-list`, propagating exit 141 as a spurious "not found".
-          first_parent_chain="$(git rev-list --first-parent "${source_sha}")"
-          if ! grep -Fxq "${LATEST_TAG_SHA}" <<< "${first_parent_chain}"; then
-            echo "::error::Source branch '${SOURCE_BRANCH}' is not cut from '${LATEST_TAG}'."
-            echo "::error::Its first-parent history does not include ${LATEST_TAG_SHA}."
-            exit 1
-          fi
-
-          # Additionally, every commit added on top of the tag (the set we are
-          # about to publish) must itself be a descendant of the tag along
-          # first-parent — i.e. no sibling commits from master sneak in via a
-          # non-first-parent path. Enforce by requiring that the symmetric
-          # difference is empty in one direction: commits in source that are
-          # NOT first-parent-reachable from source starting at the tag.
-          # We do this by intersecting:
-          #   A = commits reachable from source but not from tag (full DAG)
-          #   B = commits on the first-parent chain from source down to tag
-          # and requiring A == B.
-          all_added="$(git rev-list "${LATEST_TAG_SHA}..${source_sha}" | sort)"
-          first_parent_added="$(
-            git rev-list --first-parent "${LATEST_TAG_SHA}..${source_sha}" | sort
-          )"
-
-          if [[ "${all_added}" != "${first_parent_added}" ]]; then
-            echo "::error::Source branch '${SOURCE_BRANCH}' contains commits not on its first-parent chain from '${LATEST_TAG}'."
-            echo "::error::This usually means the branch was cut from master (not from the tag) or contains a merge from master."
-            echo "Commits reachable but not on first-parent chain:"
-            comm -23 <(printf '%s\n' "${all_added}") <(printf '%s\n' "${first_parent_added}") \
-              | while read -r sha; do
-                  echo "  $(git log -1 --format='%h %s' "${sha}")"
-                done
-            exit 1
-          fi
-
-          added_count="$(printf '%s\n' "${all_added}" | grep -c . || true)"
-          echo "Source branch is cut directly from ${LATEST_TAG} with ${added_count} commit(s) on top."
-
-      - name: Validate PR exists, is open, named correctly, has latest commit, and checks pass
-        env:
-          GH_TOKEN:      ${{ steps.app-token.outputs.token }}
-          SOURCE_BRANCH: ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT: ${{ inputs.commit }}
-          NEW_VERSION:   ${{ steps.latest.outputs.new_version }}
-          REPO:          ${{ github.repository }}
-        run: |
-          set -euo pipefail
-
-          expected_title="ComfyUI backport release ${NEW_VERSION}"
-
-          # Find open PRs from this branch into master. The --state open filter
-          # is load-bearing: a closed/merged PR with passing checks must not be
-          # accepted as authorization for a new release.
-          pr_json="$(
-            gh pr list \
-              --repo "${REPO}" \
-              --state open \
-              --head "${SOURCE_BRANCH}" \
-              --base master \
-              --json number,title,headRefOid,state \
-              --limit 10
-          )"
-
-          pr_count="$(echo "${pr_json}" | jq 'length')"
-          if [[ "${pr_count}" -eq 0 ]]; then
-            echo "::error::No open PR found from '${SOURCE_BRANCH}' into 'master'. The PR must exist and be open."
-            exit 1
-          fi
-
-          # Pick the PR matching the expected title
-          pr_number="$(echo "${pr_json}" | jq -r --arg t "${expected_title}" '
-            map(select(.title == $t)) | .[0].number // empty
-          ')"
-          pr_head_sha="$(echo "${pr_json}" | jq -r --arg t "${expected_title}" '
-            map(select(.title == $t)) | .[0].headRefOid // empty
-          ')"
-
-          if [[ -z "${pr_number}" ]]; then
-            echo "::error::No open PR from '${SOURCE_BRANCH}' into 'master' is titled '${expected_title}'."
-            echo "Found PRs:"
-            echo "${pr_json}" | jq -r '.[] | "  #\(.number): \(.title)"'
-            exit 1
-          fi
-
-          # The PR's current head commit must equal the SHA the operator gave us.
-          # This is what closes the door on releasing stale code: if anyone has
-          # pushed to the branch since the operator validated tests passed, the
-          # PR head will have advanced past SOURCE_COMMIT and we abort. (The
-          # resolve step already proved the branch tip == SOURCE_COMMIT; this
-          # ties that same SHA to the PR that authorizes the release.)
-          if [[ "${pr_head_sha}" != "${SOURCE_COMMIT}" ]]; then
-            echo "::error::PR #${pr_number} head commit is ${pr_head_sha}, but the operator-provided commit is ${SOURCE_COMMIT}."
-            echo "::error::The PR has new commits since this release was authorized. Re-run with the new head SHA after verifying its checks."
-            exit 1
-          fi
-
-          echo "Found open PR #${pr_number} titled '${expected_title}' at head ${pr_head_sha} (matches operator-provided commit)."
-
-          # Verify all check runs on the head commit have completed successfully.
-          # A check is considered passing if conclusion is success, neutral, or skipped.
-          checks_json="$(
-            gh api \
-              --paginate \
-              "repos/${REPO}/commits/${pr_head_sha}/check-runs" \
-              --jq '.check_runs[] | {name: .name, status: .status, conclusion: .conclusion}'
-          )"
-
-          if [[ -z "${checks_json}" ]]; then
-            echo "::error::No check runs found on PR head commit ${pr_head_sha}."
-            exit 1
-          fi
-
-          echo "Check runs on ${pr_head_sha}:"
-          echo "${checks_json}" | jq -s '.'
-
-          failing="$(echo "${checks_json}" | jq -s '
-            map(select(
-              .status != "completed"
-              or (.conclusion as $c
-                  | ["success","neutral","skipped"]
-                  | index($c) | not)
-            ))
-          ')"
-
-          failing_count="$(echo "${failing}" | jq 'length')"
-          if [[ "${failing_count}" -gt 0 ]]; then
-            echo "::error::One or more checks have not passed on PR head commit ${pr_head_sha}:"
-            echo "${failing}" | jq -r '.[] | "  - \(.name): status=\(.status) conclusion=\(.conclusion)"'
-            exit 1
-          fi
-
-          echo "All checks have passed on ${pr_head_sha}."
-
-      - name: Prepare release branch
-        id: prepare
-        env:
-          GH_TOKEN:        ${{ steps.app-token.outputs.token }}
-          REPO:            ${{ github.repository }}
-          RELEASE_BRANCH:  ${{ steps.latest.outputs.release_branch }}
-          LATEST_TAG:      ${{ steps.latest.outputs.latest_tag }}
-          LATEST_TAG_SHA:  ${{ steps.latest.outputs.latest_sha }}
-          PATCH:           ${{ steps.latest.outputs.patch }}
-        run: |
-          set -euo pipefail
-
-          # Try to fetch the release branch. If patch == 0, it shouldn't exist yet
-          # and we'll create it from the latest stable tag. If patch > 0, it must
-          # already exist and its tip must equal the latest stable tag commit (i.e.
-          # the previous patch release).
-          if git ls-remote --exit-code --heads origin "${RELEASE_BRANCH}" >/dev/null 2>&1; then
-            echo "Release branch '${RELEASE_BRANCH}' already exists on origin."
-            git fetch origin "refs/heads/${RELEASE_BRANCH}:refs/remotes/origin/${RELEASE_BRANCH}"
-            git checkout -B "${RELEASE_BRANCH}" "refs/remotes/origin/${RELEASE_BRANCH}"
-
-            current_tip="$(git rev-parse HEAD)"
-            if [[ "${current_tip}" != "${LATEST_TAG_SHA}" ]]; then
-              echo "::error::Release branch '${RELEASE_BRANCH}' tip (${current_tip}) is not at the latest stable release '${LATEST_TAG}' (${LATEST_TAG_SHA})."
-              echo "::error::Refusing to release on top of a divergent branch."
-              exit 1
-            fi
-            echo "branch_existed=true" >> "$GITHUB_OUTPUT"
-          else
-            if [[ "${PATCH}" != "0" ]]; then
-              echo "::error::Release branch '${RELEASE_BRANCH}' does not exist on origin, but the latest stable release '${LATEST_TAG}' has patch=${PATCH} (>0). This is inconsistent."
-              exit 1
-            fi
-            echo "Release branch '${RELEASE_BRANCH}' does not exist. Creating from ${LATEST_TAG}."
-            git checkout -B "${RELEASE_BRANCH}" "refs/tags/${LATEST_TAG}"
-            echo "branch_existed=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Fast-forward merge source branch into release branch
-        env:
-          SOURCE_BRANCH:  ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-        run: |
-          set -euo pipefail
-
-          # --ff-only guarantees no merge commit is created. If a fast-forward is
-          # not possible (i.e. the release branch has commits the source branch
-          # doesn't), the merge will fail and we abort. Because we already validated
-          # that the source branch is rooted on the latest stable tag, and the
-          # release branch tip equals that same tag, this fast-forward should
-          # always succeed for a well-formed backport branch.
-          #
-          # We merge the operator-provided SHA, not the branch ref, so a push to
-          # the branch in the window between resolve and now cannot smuggle new
-          # commits into the release.
-          if ! git merge --ff-only "${SOURCE_COMMIT}"; then
-            echo "::error::Cannot fast-forward '${RELEASE_BRANCH}' to ${SOURCE_COMMIT} (tip of '${SOURCE_BRANCH}'). A merge commit would be required. Aborting."
-            exit 1
-          fi
-
-          echo "Fast-forwarded '${RELEASE_BRANCH}' to ${SOURCE_COMMIT} (tip of '${SOURCE_BRANCH}')."
-
-      - name: Bump version files
-        env:
-          NEW_VERSION_NO_V: ${{ steps.latest.outputs.new_version_no_v }}
-        run: |
-          set -euo pipefail
-
-          if [[ ! -f comfyui_version.py ]]; then
-            echo "::error::comfyui_version.py not found in repo root."
-            exit 1
-          fi
-          if [[ ! -f pyproject.toml ]]; then
-            echo "::error::pyproject.toml not found in repo root."
-            exit 1
-          fi
-
-          # Replace the version string in comfyui_version.py.
-          # Expected format:  __version__ = "X.Y.Z"
-          python3 - "$NEW_VERSION_NO_V" <<'PY'
-          import re, sys, pathlib
-          new = sys.argv[1]
-
-          p = pathlib.Path("comfyui_version.py")
-          src = p.read_text()
-          new_src, n = re.subn(
-              r'(__version__\s*=\s*[\'"])[^\'"]+([\'"])',
-              lambda m: f'{m.group(1)}{new}{m.group(2)}',
-              src,
-              count=1,
-          )
-          if n != 1:
-              sys.exit("Could not find __version__ assignment in comfyui_version.py")
-          p.write_text(new_src)
-
-          p = pathlib.Path("pyproject.toml")
-          src = p.read_text()
-          # Replace the first `version = "..."` inside [project] or [tool.poetry].
-          new_src, n = re.subn(
-              r'(?m)^(version\s*=\s*")[^"]+(")',
-              lambda m: f'{m.group(1)}{new}{m.group(2)}',
-              src,
-              count=1,
-          )
-          if n != 1:
-              sys.exit("Could not find version assignment in pyproject.toml")
-          p.write_text(new_src)
-          PY
-
-          echo "Updated version to ${NEW_VERSION_NO_V} in comfyui_version.py and pyproject.toml."
-          git --no-pager diff -- comfyui_version.py pyproject.toml
-
-      - name: Commit version bump and tag release
-        env:
-          NEW_VERSION: ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-
-          git add comfyui_version.py pyproject.toml
-          git commit -m "ComfyUI ${NEW_VERSION}"
-
-          if git rev-parse -q --verify "refs/tags/${NEW_VERSION}" >/dev/null; then
-            echo "::error::Tag ${NEW_VERSION} already exists locally."
-            exit 1
-          fi
-          git tag "${NEW_VERSION}"
-
-      - name: Verify tag does not already exist on origin
-        env:
-          NEW_VERSION: ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-          if git ls-remote --exit-code --tags origin "refs/tags/${NEW_VERSION}" >/dev/null 2>&1; then
-            echo "::error::Tag ${NEW_VERSION} already exists on origin. Aborting."
-            exit 1
-          fi
-
-      - name: Push release branch and tag
-        env:
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-          NEW_VERSION:    ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-
-          # Push the branch first, then the tag. Atomic-ish: if the branch push
-          # fails we never publish the tag.
-          git push origin "refs/heads/${RELEASE_BRANCH}:refs/heads/${RELEASE_BRANCH}"
-          git push origin "refs/tags/${NEW_VERSION}"
-
-          echo "Released ${NEW_VERSION} on ${RELEASE_BRANCH}."
-
-      - name: Delete remote source branch
-        env:
-          GH_TOKEN:        ${{ steps.app-token.outputs.token }}
-          REPO:            ${{ github.repository }}
-          SOURCE_BRANCH:   ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:   ${{ inputs.commit }}
-          RELEASE_BRANCH:  ${{ steps.latest.outputs.release_branch }}
-          DEFAULT_BRANCH:  ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-
-          # Belt-and-braces: the resolve step already refuses the default branch,
-          # but never delete the default or the release branch under any
-          # circumstances.
-          if [[ "${SOURCE_BRANCH}" == "${DEFAULT_BRANCH}" || "${SOURCE_BRANCH}" == "${RELEASE_BRANCH}" ]]; then
-            echo "::error::Refusing to delete '${SOURCE_BRANCH}' (matches default or release branch)."
-            exit 1
-          fi
-
-          # Delete the source branch on origin, but only if its tip is still the
-          # SHA we released from. If someone pushed new commits to it after we
-          # resolved it, leave it alone — those commits would be silently lost.
-          current_tip="$(git ls-remote origin "refs/heads/${SOURCE_BRANCH}" | awk '{print $1}')"
-          if [[ -z "${current_tip}" ]]; then
-            echo "Source branch '${SOURCE_BRANCH}' no longer exists on origin; nothing to delete."
-            exit 0
-          fi
-          if [[ "${current_tip}" != "${SOURCE_COMMIT}" ]]; then
-            echo "::warning::Source branch '${SOURCE_BRANCH}' tip (${current_tip}) no longer matches released commit (${SOURCE_COMMIT}). Leaving it in place."
-            exit 0
-          fi
-
-          git push origin --delete "refs/heads/${SOURCE_BRANCH}"
-          echo "Deleted remote branch '${SOURCE_BRANCH}'."
-
-      - name: Summary
-        if: always()
-        env:
-          NEW_VERSION:    ${{ steps.latest.outputs.new_version }}
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-          LATEST_TAG:     ${{ steps.latest.outputs.latest_tag }}
-          SOURCE_BRANCH:  ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-        run: |
-          # SOURCE_BRANCH is empty if the resolve step never produced an output
-          # (e.g. the workflow failed in or before that step). Show a placeholder
-          # in that case so the summary table still renders cleanly.
-          source_branch_display="${SOURCE_BRANCH:-(unresolved)}"
-          {
-            echo "## Backport release"
-            echo ""
-            echo "| Field | Value |"
-            echo "|---|---|"
-            echo "| Source commit | \`${SOURCE_COMMIT}\` |"
-            echo "| Source branch | \`${source_branch_display}\` |"
-            echo "| Previous stable | \`${LATEST_TAG}\` |"
-            echo "| New version | \`${NEW_VERSION}\` |"
-            echo "| Release branch | \`${RELEASE_BRANCH}\` |"
-          } >> "$GITHUB_STEP_SUMMARY"

.github/workflows/check-line-endings.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Check for Windows line endings (CRLF)
         run: |
           # Get the list of changed files in the PR
-          CHANGED_FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} -- ':!.ci')
+          CHANGED_FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }})
 
           # Flag to track if CRLF is found
           CRLF_FOUND=false

.github/workflows/ci-cursor-review.yml

@@ -1,38 +0,0 @@
-name: CI - Cursor Review
-
-# Thin caller for the shared reusable cursor-review workflow in
-# Comfy-Org/github-workflows. The review logic (panel matrix, judge
-# consolidation, prompts, extract/post/notify scripts) lives there as the
-# single source of truth, so this repo only carries the repo-specific diff
-# excludes.
-
-on:
-  pull_request:
-    types: [labeled, unlabeled]
-
-concurrency:
-  group: cursor-review-pr-${{ github.event.pull_request.number }}-${{ github.event.label.name }}
-  cancel-in-progress: true
-
-jobs:
-  cursor-review:
-    if: github.event.label.name == 'cursor-review'
-    permissions:
-      contents: read
-      pull-requests: write
-    # SHA-pinned per zizmor `unpinned-uses: hash-pin`. Bump this SHA to pick up
-    # upstream changes; keep `workflows_ref` matching so prompts/scripts load
-    # from the same commit as the workflow definition.
-    uses: Comfy-Org/github-workflows/.github/workflows/cursor-review.yml@047ca48febe3a6647608ed2e0c4331b491cb9d6a # github-workflows#9
-    with:
-      workflows_ref: 047ca48febe3a6647608ed2e0c4331b491cb9d6a
-      diff_excludes: >-
-        :!**/.claude/**
-        :!**/dist/**
-        :!**/vendor/**
-        :!**/*.generated.*
-        :!**/*.min.js
-        :!**/*.min.css
-    secrets:
-      CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
-      SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

.github/workflows/cla.yml

@@ -1,93 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, synchronize, closed]
-
-permissions:
-  actions: write
-  contents: read # 'read' is enough because signatures live in a REMOTE repo
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla-assistant:
-    runs-on: ubuntu-latest
-    steps:
-      # The CLA action normally requires every commit author in a PR to sign.
-      # We only want the PR author to sign, so we allowlist all other committers
-      # by computing them from the PR's commits and excluding the PR author.
-      - name: Build author-only allowlist
-        id: allowlist
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
-          BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
-        # For each commit emit the GitHub login when the author/committer email resolves to a GitHub account
-        # otherwise fall back to the raw git name.
-        run: |
-          others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
-            --jq '.[] | (.author.login // .commit.author.name // empty), (.committer.login // .commit.committer.name // empty)' \
-            | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
-          if [ -n "$others" ]; then
-            echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"
-          else
-            echo "allowlist=${BASE_ALLOWLIST}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: CLA Assistant
-        # Run on PR events, on "recheck" comment, or when someone posts the signing phrase.
-        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # PAT required to write to the centralized signatures repo.
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-        with:
-          # Where the CLA document lives (shown to contributors)
-          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
-
-          # Centralized signature storage
-          remote-organization-name: comfy-org
-          remote-repository-name: comfy-cla
-          path-to-signatures: signatures/cla.json
-          branch: main
-
-          # Only the PR author must sign: bots plus every non-author committer
-          # are allowlisted via the "Build author-only allowlist" step above.
-          # *[bot] is a catch-all for any GitHub App bot account.
-          allowlist: ${{ steps.allowlist.outputs.allowlist }}
-
-          # Custom PR comment messages
-          custom-notsigned-prcomment: |
-            🎉 Thank you for your contribution, we really appreciate it! 🎉
-
-            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
-
-            - Confirm that you own your contribution.
-            - Keep the right to reuse your own code.
-            - Grant us a copyright license to include and share it within our projects.
-
-            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
-
-            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
-
-          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
-
-          custom-allsigned-prcomment: |
-            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.

.github/workflows/detect-unreviewed-merge.yml

@@ -1,24 +0,0 @@
-name: Detect Unreviewed Merge
-
-# SOC 2 compliance — reusable workflow lives in Comfy-Org/github-workflows,
-# tracking issues are filed in Comfy-Org/unreviewed-merges.
-
-on:
-  push:
-    branches: [master]
-
-concurrency:
-  group: detect-unreviewed-merge-${{ github.sha }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-  pull-requests: read
-
-jobs:
-  detect:
-    uses: Comfy-Org/github-workflows/.github/workflows/detect-unreviewed-merge.yml@4d9cb6b87f953bb7cd69954280e1465fb9bd2040 # v1
-    with:
-      approval-mode: latest-per-reviewer
-    secrets:
-      UNREVIEWED_MERGES_TOKEN: ${{ secrets.UNREVIEWED_MERGES_TOKEN }}

.github/workflows/openapi-lint.yml

@@ -1,31 +0,0 @@
-name: OpenAPI Lint
-
-on:
-  pull_request:
-    paths:
-      - 'openapi.yaml'
-      - '.spectral.yaml'
-      - '.github/workflows/openapi-lint.yml'
-
-permissions:
-  contents: read
-
-jobs:
-  spectral:
-    name: Run Spectral
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Install Spectral
-        run: npm install -g @stoplight/spectral-cli@6
-
-      - name: Lint openapi.yaml
-        run: spectral lint openapi.yaml --ruleset .spectral.yaml --fail-severity=error

.github/workflows/stable-release.yml

@@ -145,8 +145,6 @@ jobs:
           cp -r ComfyUI/.ci/windows_${{ inputs.rel_name }}_base_files/* ./
           cp ../update_comfyui_and_python_dependencies.bat ./update/
 
-          echo 'local-portable' > ComfyUI/.comfy_environment
-
           cd ..
 
           "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=9 -mfb=128 -md=768m -ms=on -mf=BCJ2 ComfyUI_windows_portable.7z ComfyUI_windows_portable

.github/workflows/tag-dispatch-cloud.yml

@@ -1,45 +0,0 @@
-name: Tag Dispatch to Cloud
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  dispatch-cloud:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Send repository dispatch to cloud
-        env:
-          DISPATCH_TOKEN: ${{ secrets.CLOUD_REPO_DISPATCH_TOKEN }}
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-
-          if [ -z "${DISPATCH_TOKEN:-}" ]; then
-            echo "::error::CLOUD_REPO_DISPATCH_TOKEN is required but not set."
-            exit 1
-          fi
-
-          RELEASE_URL="https://github.com/${{ github.repository }}/releases/tag/${RELEASE_TAG}"
-
-          PAYLOAD="$(jq -n \
-            --arg release_tag "$RELEASE_TAG" \
-            --arg release_url "$RELEASE_URL" \
-            '{
-              event_type: "comfyui_tag_pushed",
-              client_payload: {
-                release_tag: $release_tag,
-                release_url: $release_url
-              }
-            }')"
-
-          curl -fsSL \
-            -X POST \
-            -H "Accept: application/vnd.github+json" \
-            -H "Content-Type: application/json" \
-            -H "Authorization: Bearer ${DISPATCH_TOKEN}" \
-            https://api.github.com/repos/Comfy-Org/cloud/dispatches \
-            -d "$PAYLOAD"
-
-          echo "✅ Dispatched ComfyUI tag ${RELEASE_TAG} to Comfy-Org/cloud"

.gitignore

@@ -21,6 +21,6 @@ venv*/
 *.log
 web_custom_versions/
 .DS_Store
+openapi.yaml
 filtered-openapi.yaml
 uv.lock
-.comfy_environment

.spectral.yaml

@@ -1,100 +0,0 @@
-extends:
-  - spectral:oas
-
-# Severity levels: error, warn, info, hint, off
-# Rules from the built-in "spectral:oas" ruleset are active by default.
-# Below we tune severity and add custom rules for our conventions.
-#
-# This ruleset mirrors Comfy-Org/cloud/.spectral.yaml so specs across the
-# organization are linted against a single consistent standard.
-
-rules:
-  # -----------------------------------------------------------------------
-  # Built-in rule severity overrides
-  # -----------------------------------------------------------------------
-  operation-operationId: error
-  operation-description: warn
-  operation-tag-defined: error
-  info-contact: off
-  info-description: warn
-  no-eval-in-markdown: error
-  no-$ref-siblings: error
-
-  # -----------------------------------------------------------------------
-  # Custom rules: naming conventions
-  # -----------------------------------------------------------------------
-
-  # Property names should be snake_case
-  property-name-snake-case:
-    description: Property names must be snake_case
-    severity: warn
-    given: "$.components.schemas.*.properties[*]~"
-    then:
-      function: pattern
-      functionOptions:
-        match: "^[a-z][a-z0-9]*(_[a-z0-9]+)*$"
-
-  # Operation IDs should be camelCase
-  operation-id-camel-case:
-    description: Operation IDs must be camelCase
-    severity: warn
-    given: "$.paths.*.*.operationId"
-    then:
-      function: pattern
-      functionOptions:
-        match: "^[a-z][a-zA-Z0-9]*$"
-
-  # -----------------------------------------------------------------------
-  # Custom rules: response conventions
-  # -----------------------------------------------------------------------
-
-  # Error responses (4xx, 5xx) should use a consistent shape
-  error-response-schema:
-    description: Error responses should reference a standard error schema
-    severity: hint
-    given: "$.paths.*.*.responses[?(@property >= '400' && @property < '600')].content['application/json'].schema"
-    then:
-      field: "$ref"
-      function: truthy
-
-  # All 2xx responses with JSON body should have a schema
-  response-schema-defined:
-    description: Success responses with JSON content should define a schema
-    severity: warn
-    given: "$.paths.*.*.responses[?(@property >= '200' && @property < '300')].content['application/json']"
-    then:
-      field: schema
-      function: truthy
-
-  # -----------------------------------------------------------------------
-  # Custom rules: best practices
-  # -----------------------------------------------------------------------
-
-  # Path parameters must have a description
-  path-param-description:
-    description: Path parameters should have a description
-    severity: warn
-    given:
-      - "$.paths.*.parameters[?(@.in == 'path')]"
-      - "$.paths.*.*.parameters[?(@.in == 'path')]"
-    then:
-      field: description
-      function: truthy
-
-  # Schemas should have a description
-  schema-description:
-    description: Component schemas should have a description
-    severity: hint
-    given: "$.components.schemas.*"
-    then:
-      field: description
-      function: truthy
-
-overrides:
-  # /ws uses HTTP 101 (Switching Protocols) — a legitimate response for a
-  # WebSocket upgrade, but not a 2xx, so operation-success-response fires
-  # as a false positive. OpenAPI 3.x has no native WebSocket support.
-  - files:
-      - "openapi.yaml#/paths/~1ws"
-    rules:
-      operation-success-response: off

AGENTS.md

@@ -1,296 +0,0 @@
-## Engineering Style
-
-- Keep changes small and direct. Most fixes should touch the narrowest code path
-  that explains the bug, performance issue, dtype issue, model-format issue, or
-  user-facing behavior.
-- Change the least amount of files possible. A change that touches many files is
-  more likely to be a bad change than a good one unless the broader scope is
-  directly required.
-- Prefer practical fixes over broad architecture work. Add abstractions only
-  when they remove real repeated logic or match an existing ComfyUI pattern.
-- Prefer fewer dependencies. Do not add new dependencies to ComfyUI unless they
-  are absolutely necessary.
-- Delete obsolete code aggressively when newer infrastructure makes it useless.
-  Remove dead fallbacks, migration paths, unused options, debug prints, and
-  compatibility branches that are no longer needed. Do not leave dead branches,
-  unreachable code, or functions that are never called. If code is not
-  necessary for the current behavior, remove it.
-- Revert or disable problematic behavior quickly when it breaks users. It is
-  better to remove a broken feature path than keep a complicated partial fix.
-- Preserve existing APIs, node names, model-loading behavior, file layout, and
-  workflow compatibility unless the change is explicitly about replacing them.
-- Code must look hand-written for this repository. Changes that read like
-  generic AI-generated code will be rejected automatically: unnecessary helper
-  layers, vague names, boilerplate comments, defensive branches without a real
-  failure mode, broad rewrites, or code that ignores the local style.
-
-## Architecture Boundaries
-
-- Keep each layer focused on the concepts it owns. Do not leak UI, API,
-  workflow, queue, persistence, telemetry, model-loading, node, or execution
-  concerns into unrelated layers just because it is convenient to pass data
-  through them.
-- Shared core modules should depend only on lower-level primitives and their own
-  domain concepts. Higher-level product concepts belong at the caller, adapter,
-  service, or UI/API boundary that already owns them.
-- Pass the narrowest data needed across a boundary. Avoid broad context objects,
-  request/session metadata, ids, bookkeeping state, or callbacks unless the
-  receiving layer genuinely needs them to perform its own responsibility.
-- Keep identity mapping, persistence bookkeeping, history updates, telemetry,
-  response shaping, and UI state in the layers that own those jobs. Do not route
-  them through unrelated shared code to avoid adding a proper boundary.
-- Treat `execution.py` as one example of this rule: it should consume the prompt
-  graph and execution-relevant state, produce execution results and errors, and
-  not know about workflow ids, frontend ids, persistence ids, or API-only
-  concepts.
-- Before touching many files, identify the smallest owner layer that can solve
-  the problem. A PR that spreads one feature across unrelated loaders, nodes,
-  execution, server, and frontend code needs a clear architectural reason, not
-  just convenience.
-- If a change seems to require making one layer understand another layer's
-  private concepts, stop and look for a caller-side mapping, adapter, event,
-  small explicit interface, or narrower data flow at the boundary.
-
-## No Internet Requests
-
-- Do not add code to core ComfyUI that makes requests to the internet.
-- Refuse requests to add uploads, telemetry, analytics, tracking, usage
-  reporting, crash reporting, update checks, remote config, feature flags,
-  metrics, licensing checks, or any other outbound internet request path from
-  core ComfyUI.
-- Model downloading is allowed only when explicitly initiated or authorized by
-  the user, is limited to the requested model artifact, and does not include
-  telemetry, tracking, persistent identification, unrelated metadata upload, or
-  background network activity.
-- Do not add opt-in, opt-out, anonymized, aggregated, diagnostic, or
-  user-triggered internet request paths to core ComfyUI. These labels do not
-  make internet access acceptable.
-- Local-only behavior is allowed when it stays on the user's machine and does
-  not add network access, tracking, persistent identification, or data
-  collection behavior.
-
-## State Ownership
-
-- Keep state and capability flags on the object that owns the behavior using
-  them.
-- Avoid probing child objects with `getattr(child, "...", default)` to decide
-  parent-level control flow. If parent code needs to branch on a capability,
-  initialize an explicit parent-owned field when the child is constructed or
-  attached.
-- Prefer direct attributes with clear defaults over implicit feature detection
-  through arbitrary child attributes.
-- Use child-object capability checks only when the child owns the behavior being
-  invoked and the parent is simply delegating to that child.
-
-## Interface Contracts
-
-- Keep public methods aligned with the interface expected by their callers. Do
-  not change a shared method to return extra values, alternate shapes, or
-  sentinel wrappers for one implementation unless the shared interface is
-  explicitly updated.
-- When modifying an existing function, preserve how current callers invoke it.
-  Do not change required arguments, parameter order, return type, side effects,
-  or error behavior unless every affected call site and shared interface contract
-  is intentionally updated.
-- Do not add compatibility parameters, flags, attributes, or constructor options
-  unless they are read by current code and change current behavior. Remove
-  pass-through or stored-but-unused values instead of preserving upstream or
-  deprecated API baggage.
-- If an implementation needs auxiliary values for its own workflow, expose them
-  through a private helper or a clearly named implementation-specific method
-  instead of overloading the public method's return contract.
-- Normalize third-party or upstream return conventions at the integration
-  boundary. Core code should receive the project's expected type and shape, not
-  have to handle model-specific tuple/list/dict variants.
-- Avoid caller-side unwrapping such as `out = out[0]` unless the called
-  interface is documented to return that structure.
-
-## Autograd and Model Freezing
-
-- Do not add `torch.no_grad`, `torch.inference_mode`, or inference-mode helper
-  wrappers in ComfyUI code. The only allowed inference-mode-related use is
-  disabling a globally set inference mode when a training path needs gradients.
-- Do not add freeze, unfreeze, or trainability toggles to model classes. ComfyUI
-  models are always treated as frozen for inference, so explicit freeze
-  functionality is redundant and should not be added.
-- Remove training-only behavior such as dropout from inference model code, but
-  preserve checkpoint and state-dict compatibility when doing so. If deleting a
-  module would change state-dict keys, module ordering, or checkpoint loading
-  behavior, replace it with a no-op such as `nn.Identity` instead of removing the
-  slot outright.
-
-## Python Style
-
-- Keep imports at module scope. Avoid inline imports unless they are already part
-  of an established optional-backend probe or are needed to avoid an import
-  cycle.
-- Do not add unnecessary `try`/`except` blocks. Use them for optional dependency,
-  platform, or backend capability detection only when the program has a useful
-  fallback. Prefer specific exception types when changing new code.
-- If a library version is pinned in `requirements.txt`, do not add code to
-  ComfyUI to handle older versions of that library.
-- Remove any workarounds for PyTorch versions that ComfyUI no longer officially
-  supports. Deprecated workarounds include catching an exception and rerunning
-  the same op with the input cast to float. If a workaround does not have a
-  comment naming the exact PyTorch version or versions that still need it,
-  remove it.
-- Let unsupported model formats, invalid quantization metadata, and bad states
-  fail with clear errors instead of silently producing lower quality output.
-- Match the existing local style in the file you edit. This codebase tolerates
-  long lines, simple helper functions, module-level state, and direct tensor
-  operations when they make the code easier to follow.
-- Keep comments sparse and useful. Strip useless comments that restate the code
-  or describe obvious behavior. Short TODOs are fine when they name the concrete
-  missing follow-up.
-
-## Model, Device, and Memory Behavior
-
-- Treat dtype, device placement, VRAM usage, and offloading behavior as core
-  correctness concerns. Check CPU, CUDA, ROCm, MPS, DirectML, XPU, NPU, and low
-  VRAM implications when touching shared execution or loading code.
-- Prefer native ComfyUI formats and existing quantization/offload helpers over
-  adding parallel code paths. Use `comfy.quant_ops`, `comfy.model_management`,
-  `comfy.memory_management`, `comfy.pinned_memory`, `comfy_aimdo`, and
-  `comfy-kitchen` helpers where they already solve the problem.
-- Use optimized comfy-kitchen ops in places where they improve performance
-  without changing the expected dtype, device, memory, or interface behavior.
-- All models should use the optimized attention function selected by ComfyUI.
-  Treat optimized backend functions, dispatch helpers, and capability-selected
-  callables as opaque. Higher-level code must not inspect function identity,
-  names, modules, or implementation details to decide behavior.
-- Apply the same opacity rule to similar patterns beyond attention: callers
-  should depend on the documented interface and result contract, not on which
-  backend implementation was selected underneath.
-- Do not use custom inference ops that only duplicate an existing op while
-  upcasting to float32, such as custom RMSNorm variants. Use the generic ComfyUI
-  ops and/or native torch ops instead.
-- If a model class `__init__` has an `operations` parameter, assume
-  `operations` is never `None`. Do not add fallback branches or default torch
-  ops for a missing `operations` object.
-- Do not add unnecessary parameters to model, model block, or model ops related
-  classes. Constructor and forward signatures should carry only values that are
-  actually needed by that object for inference.
-- Reuse existing model classes, blocks, ops, and helper modules when appropriate.
-  Before implementing a new version of a model component, search the existing
-  model code for a class or helper that already provides the behavior.
-- Model detection code that inspects linear weight shapes should only use the
-  first dimension. The second dimension may be half the original size for
-  NVFP4 or other 4-bit quantized models.
-- Avoid adding `einops` usage in core inference code. Use native torch tensor
-  ops such as `reshape`, `view`, `permute`, `transpose`, `flatten`, `unflatten`,
-  `unsqueeze`, and `squeeze` instead.
-- Do not use tensors as general-purpose Python data structures. Keep metadata,
-  bookkeeping, counters, flags, shape math, padding math, index planning, memory
-  estimates, and control-flow decisions in plain Python values unless the data
-  must participate directly in tensor computation. Do not create tensors for
-  structural metadata that is only used for Python-side control flow. Sequence
-  lengths, cumulative offsets, split indices, window counts, slice boundaries,
-  and repeat counts should be kept as Python ints/lists from the point they are
-  computed. Do not build them as CPU/GPU tensors and then cast, move, validate,
-  or convert them back to Python for `split`, `tensor_split`, indexing plans,
-  loops, or cache keys. Avoid creating temporary tensors just to use tensor
-  methods for scalar or structural calculations.
-- Avoid unnecessary casts and transfers. Preserve the intended compute dtype,
-  storage dtype, bias dtype, and original tensor shape metadata.
-- Keep model-native latent layout handling inside the model or latent-format
-  owner, not in helper nodes. Do not collapse, expand, pack, or unpack latent
-  dimensions in nodes or other caller-side adapters just to satisfy a model
-  forward; the model path should consume and return the native latent shape for
-  that model family.
-- Assume inputs to the main model forward are already in the compute dtype by
-  default, except integer inputs such as some model timestep tensors. Do not add
-  defensive or convenience casts in model code; it is better for invalid dtype
-  plumbing to error clearly than to hide it with unnecessary casts.
-- Raw model parameters that are not owned by an op and may be initialized in a
-  dtype different from the compute dtype should be cast at use in forward or
-  inference code with `comfy.ops.cast_to_input` or
-  `comfy.model_management.cast_to` to avoid dtype mismatches.
-- Model code should not care what dtype it is initialized in, and model
-  `__init__` methods should not contain workarounds for specific dtypes. Dtype
-  workaround code, such as making a model work with fp16 compute, belongs in the
-  execution or model-management layer that owns compute policy.
-- Model code should not perform unnecessary device-to-CPU or CPU-to-device
-  transfers. New allocations must be created on the correct device and dtype;
-  never allocate on CPU and then move to GPU, or allocate in one dtype and then
-  convert to another.
-- Model code itself should not perform memory management. Loading, unloading,
-  offloading, device movement, VRAM policy, cache lifetime, and cleanup belong
-  in the relevant model-management and execution layers, not inside model
-  implementations.
-- Do not add global, module-level, class-level, singleton, or model-owned stores
-  for tensors or other large memory that persist across executions. Temporary
-  caches must be scoped to a single execution or forward/encode/decode call:
-  allocate them in the owning top-level call, pass them explicitly through the
-  call stack, and let them be discarded when that call returns.
-- Follow the Wan VAE temporal cache pattern for temporary caches: create a local
-  cache such as `feat_map` for the encode/decode operation, pass it into the
-  blocks that need it, and do not retain it on the model or in global state.
-- In model init code, prefer `torch.empty` for parameter/buffer placeholders
-  that are populated from the model state dict instead of zero-initializing with
-  `torch.zeros` or similar. If an allocation is not loaded from the state dict
-  and is useless for inference, do not include it.
-- `nn.Parameter` tensors that are stored in and populated from the model state
-  dict should be initialized with `torch.empty`, not with zero, random, or
-  otherwise meaningful initialization.
-- Model initialization should describe module structure, not fabricate
-  checkpoint-owned tensor contents. Parameters and buffers that are loaded from
-  the state dict must not be manually initialized, reassigned, or filled with
-  fallback values unless that value is actually used when no checkpoint key
-  exists.
-- When slicing large tensors, copy the slice if the sliced tensor's lifetime
-  exceeds the current function scope. Do not keep a long-lived view into a large
-  backing tensor when a smaller copy would release memory sooner.
-- Use fused or compound torch operations such as `addcmul` when they naturally
-  match the math. Reducing Python and torch dispatch overhead is a valid
-  optimization when it does not obscure the code or change dtype/device
-  behavior.
-- Avoid caches that persist across different executions as much as possible.
-  Persistent caches are acceptable only when they use a very minimal amount of
-  memory and have a clear ownership and invalidation story.
-- When optimizing, favor small measurable changes: fewer allocations, fewer
-  device transfers, less peak memory, better batching, or use of a faster
-  existing backend op.
-
-## Nodes and User-Facing Behavior
-
-- Follow existing node conventions: `INPUT_TYPES`, `RETURN_TYPES`, `FUNCTION`,
-  `CATEGORY`, and registration through the local mapping used by that file.
-- Keep node changes backward compatible by default. Add inputs with sensible
-  defaults and avoid changing output types unless the request requires it.
-- Model implementations should add the minimal number of ComfyUI nodes required
-  to run the model. Reuse existing nodes as much as possible; adapting the model
-  to work with existing nodes is strongly preferred over creating new nodes.
-- Nodes should output only values they own. Do not add pass-through outputs for
-  workflow convenience unless the node is explicitly an output node. Existing
-  models, latents, conditioning, or other inputs should flow directly to the
-  next consumer instead of being re-emitted unchanged.
-- Nodes should expose only inputs they actually read to produce current
-  behavior. Do not add placeholder, pass-through, compatibility, or
-  workflow-shaping inputs that are ignored or could flow directly to another
-  node.
-- Node-level code must not patch model code directly. Any node behavior that
-  modifies, wraps, hooks, or changes model behavior must go through the model
-  patcher class instead of reaching into model internals.
-- The official mascot of ComfyUI is a very cute anime girl with massive fennec
-  ears, a big fluffy tail, long blonde wavy hair, and blue eyes. Feel free to
-  use her in ComfyUI materials, UI text, examples, tests, generated assets, or
-  comments, but do not disrespect her.
-- Warning and info messages should be short and actionable. Remove noisy or
-  misleading messages rather than adding more logging.
-- Documentation and README edits should be concise, factual, and tied to the
-  changed behavior.
-
-## Commit and Review Habits
-
-- If asked to write commit messages, use short direct subjects like the existing
-  history: `Fix ...`, `Add ...`, `Support ...`, `Remove ...`, `Update ...`,
-  `Make ...`, `Use ...`, `Disable ...`, `Bump ...`, or `Revert ...`.
-- Keep PR descriptions short and reviewable. State the problem, the behavioral
-  change, and the tests run; avoid long narrative explanations, implementation
-  diaries, or exhaustive file-by-file summaries unless the reviewer explicitly
-  needs that context.
-- Prefer one coherent behavioral change per commit. Dependency pins, tests, and
-  the code that needs them may be in the same commit when they are inseparable.
-- In reviews, prioritize real user impact: crashes, wrong dtype/device behavior,
-  memory regressions, broken model loading, workflow incompatibility, and noisy
-  or misleading user-facing output.

CODEOWNERS

@@ -1,5 +1,2 @@
-* @comfyanonymous @kosinkadink @guill @alexisrolland @rattus128 @kijai
-
-/CODEOWNERS @comfyanonymous
-/.ci/ @comfyanonymous
-/.github/ @comfyanonymous
+# Admins
+* @comfyanonymous @kosinkadink @guill

README.md

@@ -1,7 +1,7 @@
 <div align="center">
 
 # ComfyUI
-**The most powerful and modular AI engine for content creation.**
+**The most powerful and modular visual AI engine and application.**
 
 
 [![Website][website-shield]][website-url]
@@ -20,7 +20,7 @@
 [website-url]: https://www.comfy.org/
 <!-- Workaround to display total user from https://github.com/badges/shields/issues/4500#issuecomment-2060079995 -->
 [discord-shield]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdiscord.com%2Fapi%2Finvites%2Fcomfyorg%3Fwith_counts%3Dtrue&query=%24.approximate_member_count&logo=discord&logoColor=white&label=Discord&color=green&suffix=%20total
-[discord-url]: https://discord.com/invite/comfyorg
+[discord-url]: https://www.comfy.org/discord
 [twitter-shield]: https://img.shields.io/twitter/follow/ComfyUI
 [twitter-url]: https://x.com/ComfyUI
 
@@ -31,16 +31,10 @@
 [github-downloads-latest-shield]: https://img.shields.io/github/downloads/comfyanonymous/ComfyUI/latest/total?style=flat&label=downloads%40latest
 [github-downloads-link]: https://github.com/comfyanonymous/ComfyUI/releases
 
-<img width="1590" height="795" alt="ComfyUI Screenshot" src="https://github.com/user-attachments/assets/36e065e0-bfae-4456-8c7f-8369d5ea48a2" />
-<br>
+![ComfyUI Screenshot](https://github.com/user-attachments/assets/7ccaf2c1-9b72-41ae-9a89-5688c94b7abe)
 </div>
 
-ComfyUI is the AI creation engine for visual professionals who demand control over every model, every parameter, and every output. Its powerful and modular node graph interface empowers creatives to generate images, videos, 3D models, audio, and more...
-- ComfyUI natively supports the latest open-source state of the art models.
-- API nodes provide access to the best closed source models such as Nano Banana, Seedance, Hunyuan3D, etc.
-- It is available on Windows, Linux, and macOS, locally with our [desktop application](https://www.comfy.org/download), our [portable install](#installing) or on our [cloud](https://www.comfy.org/cloud).
-- The most sophisticated workflows can be exposed through a simple UI thanks to App Mode.
-- It integrates seamlessly into production pipelines with our API endpoints.
+ComfyUI lets you design and execute advanced stable diffusion pipelines using a graph/nodes/flowchart based interface. Available on Windows, Linux, and macOS.
 
 ## Get Started
 
@@ -83,7 +77,6 @@ See what ComfyUI can do with the [newer template workflows](https://comfy.org/wo
    - [Hunyuan Image 2.1](https://comfyanonymous.github.io/ComfyUI_examples/hunyuan_image/)
    - [Flux 2](https://comfyanonymous.github.io/ComfyUI_examples/flux2/)
    - [Z Image](https://comfyanonymous.github.io/ComfyUI_examples/z_image/)
-   - Ernie Image
 - Image Editing Models
    - [Omnigen 2](https://comfyanonymous.github.io/ComfyUI_examples/omnigen/)
    - [Flux Kontext](https://comfyanonymous.github.io/ComfyUI_examples/flux/#flux-kontext-image-editing-model)
@@ -133,14 +126,14 @@ Workflow examples can be found on the [Examples page](https://comfyanonymous.git
 ComfyUI follows a weekly release cycle targeting Monday but this regularly changes because of model releases or large changes to the codebase. There are three interconnected repositories:
 
 1. **[ComfyUI Core](https://github.com/comfyanonymous/ComfyUI)**
-   - Releases a new major stable version (e.g., v0.7.0) roughly every 2 weeks.
+   - Releases a new stable version (e.g., v0.7.0) roughly every week.
    - Starting from v0.4.0 patch versions will be used for fixes backported onto the current stable release.
    - Minor versions will be used for releases off the master branch.
    - Patch versions may still be used for releases on the master branch in cases where a backport would not make sense.
    - Commits outside of the stable release tags may be very unstable and break many custom nodes.
    - Serves as the foundation for the desktop release
 
-2. **[Comfy Desktop](https://github.com/Comfy-Org/Comfy-Desktop)**
+2. **[ComfyUI Desktop](https://github.com/Comfy-Org/desktop)**
    - Builds a new release using the latest stable core version
 
 3. **[ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend)**
@@ -200,15 +193,13 @@ If you have trouble extracting it, right click the file -> properties -> unblock
 
 The portable above currently comes with python 3.13 and pytorch cuda 13.0. Update your Nvidia drivers if it doesn't start.
 
-#### All Official Portable Downloads:
+#### Alternative Downloads:
 
 [Portable for AMD GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_amd.7z)
 
-[Portable for Intel GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_intel.7z)
+[Experimental portable for Intel GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_intel.7z)
 
-[Portable for Nvidia GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia.7z) (supports 20 series and above).
-
-[Portable for Nvidia GPUs with pytorch cuda 12.6 and python 3.12](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia_cu126.7z) (Supports Nvidia 10 series and older GPUs).
+[Portable with pytorch cuda 12.6 and python 3.12](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia_cu126.7z) (Supports Nvidia 10 series and older GPUs).
 
 #### How do I share models between another UI and ComfyUI?
 
@@ -229,7 +220,7 @@ Python 3.14 works but some custom nodes may have issues. The free threaded varia
 
 Python 3.13 is very well supported. If you have trouble with some custom node dependencies on 3.13 you can try 3.12
 
-torch 2.5 is minimally supported but using a newer version is extremely recommended. Some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old. If your pytorch is more than 6 months old, please update it.
+torch 2.4 and above is supported but some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old.
 
 ### Instructions:
 
@@ -309,7 +300,7 @@ After this you should have everything installed and can proceed to running Comfy
 
 #### Apple Mac silicon
 
-You can install ComfyUI in Apple Mac silicon (M1, M2, M3 or M4) with any recent macOS version.
+You can install ComfyUI in Apple Mac silicon (M1 or M2) with any recent macOS version.
 
 1. Install pytorch nightly. For instructions, read the [Accelerated PyTorch training on Mac](https://developer.apple.com/metal/pytorch/) Apple Developer guide (make sure to install the latest pytorch nightly).
 1. Follow the [ComfyUI manual installation](#manual-install-windows-linux) instructions for Windows and Linux.
@@ -364,7 +355,7 @@ For models compatible with Iluvatar Extension for PyTorch. Here's a step-by-step
 | Flag | Description |
 |------|-------------|
 | `--enable-manager` | Enable ComfyUI-Manager |
-| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (implies `--enable-manager`) |
+| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (requires `--enable-manager`) |
 | `--disable-manager-ui` | Disable the manager UI and endpoints while keeping background features like security checks and scheduled installation completion (requires `--enable-manager`) |
 
 
@@ -382,7 +373,11 @@ For AMD 7600 and maybe other RDNA3 cards: ```HSA_OVERRIDE_GFX_VERSION=11.0.0 pyt
 
 ### AMD ROCm Tips
 
-You can try setting this env variable `PYTORCH_TUNABLEOP_ENABLED=1` which might speed things up at the cost of a very slow initial run.
+You can enable experimental memory efficient attention on recent pytorch in ComfyUI on some AMD GPUs using this command, it should already be enabled by default on RDNA3. If this improves speed for you on latest pytorch on your GPU please report it so that I can enable it by default.
+
+```TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1 python main.py --use-pytorch-cross-attention```
+
+You can also try setting this env variable `PYTORCH_TUNABLEOP_ENABLED=1` which might speed things up at the cost of a very slow initial run.
 
 # Notes
 
@@ -425,11 +420,9 @@ Use `--tls-keyfile key.pem --tls-certfile cert.pem` to enable TLS/SSL, the app w
 
 See also: [https://www.comfy.org/](https://www.comfy.org/)
 
-> _psst — we're hiring!_ Help build ComfyUI: [comfy.org/careers](https://www.comfy.org/careers)
-
 ## Frontend Development
 
-As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). The compiled JS files (from TS/Vue) are published to [pypi](https://pypi.org/project/comfyui-frontend-package) and installed as a dependency in ComfyUI.
+As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). This repository now hosts the compiled JS (from TS/Vue) under the `web/` directory.
 
 ### Reporting Issues and Requesting Features
 
@@ -458,6 +451,16 @@ To use the most up-to-date frontend version:
 
 This approach allows you to easily switch between the stable fortnightly release and the cutting-edge daily updates, or even specific versions for testing purposes.
 
+### Accessing the Legacy Frontend
+
+If you need to use the legacy frontend for any reason, you can access it using the following command line argument:
+
+```
+--front-end-version Comfy-Org/ComfyUI_legacy_frontend@latest
+```
+
+This will use a snapshot of the legacy frontend preserved in the [ComfyUI Legacy Frontend repository](https://github.com/Comfy-Org/ComfyUI_legacy_frontend).
+
 # QA
 
 ### Which GPU should I buy for this?

SECURITY.md

@@ -1,44 +0,0 @@
-# Security Policy
-
-## Scope
-
-ComfyUI is designed to run locally. By default, the server binds to `127.0.0.1`, meaning only the user's own machine can reach it. Our threat model assumes:
-
-- The user installed ComfyUI through a supported channel: the desktop application, the portable build, or a manual install following the README.
-- The user has not installed untrusted custom nodes. Custom nodes are arbitrary Python code and are trusted as much as any other software the user chooses to install.
-- Anyone with access to the ComfyUI URL is trusted (a direct consequence of the localhost-only default).
-- PyTorch and other dependencies are at the versions we ship or recommend in the README.
-
-A report is in scope only if it affects a user operating within this threat model.
-
-## What We Consider a Vulnerability
-
-We want to hear about issues where a **reasonable user** — someone who does not install random untrusted nodes and who reads UI prompts and warnings before clicking through them — can be harmed by ComfyUI itself.
-
-The clearest example: a workflow file that such a user might plausibly load and run, using only built-in nodes, that results in **untrusted code execution, arbitrary file read/write outside expected directories, or credential/data exfiltration**.
-
-When submitting a report, please include a clear description of *why this is a problem for a typical local ComfyUI user*. Reports without this context are difficult to act on.
-
-## What We Do Not Consider a Security Vulnerability
-
-Please report the following through our regular [GitHub issues](https://github.com/comfyanonymous/ComfyUI/issues) instead. Filing them as security reports will likely cause them to be deprioritized or closed.
-
-- **Issues requiring `--listen` or any non-default network exposure.** ComfyUI binds to localhost by default. If a remote attacker needs to reach the server for the attack to work, the user has chosen to expose it and is responsible for securing that deployment (firewall, reverse proxy, authentication, etc.). These are bugs, not vulnerabilities.
-- **`torch.load` and related deserialization issues in old PyTorch versions.** These are upstream PyTorch issues. Our distributions ship with — and our documentation recommends — recent PyTorch versions where these are addressed.
-- **Vulnerabilities that depend on outdated library versions** that we neither ship nor recommend (e.g., requiring PyTorch 2.6 or older).
-- **Issues that require a specific custom node to be installed.** Custom nodes are third-party code. Report these to the maintainer of that node.
-- **Crashes, hangs, or resource exhaustion from a loaded workflow.** Annoying, but not a security issue in our model. File a regular bug.
-- **Social-engineering scenarios** where the user is expected to ignore an explicit UI warning or prompt.
-
-## Reporting
-
-If you believe you have found an issue that falls within the scope above, please report it privately via GitHub's [Report a vulnerability](https://github.com/comfyanonymous/ComfyUI/security/advisories/new) feature rather than opening a public issue.
-
-Please include:
-
-1. A description of the vulnerability and the affected component.
-2. Reproduction steps, ideally with a minimal workflow file or proof-of-concept.
-3. The ComfyUI version, install method (desktop / portable / manual), and OS.
-4. An explanation of how this affects a typical local user as described in the threat model.
-
-We will acknowledge valid reports and coordinate a fix and disclosure timeline with you.

alembic_db/versions/0004_drop_tag_type.py

@@ -1,39 +0,0 @@
-"""
-Drop the vestigial tags.tag_type column.
-
-tag_type was always "user" in practice — no code path ever set it to anything
-else (no system/seeded classification was ever wired up) and nothing queried it.
-The column, its index (ix_tags_tag_type), and the corresponding API field were
-dead weight, so they are removed.
-
-Revision ID: 0004_drop_tag_type
-Revises: 0003_add_metadata_job_id
-Create Date: 2026-06-03
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0004_drop_tag_type"
-down_revision = "0003_add_metadata_job_id"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("tags") as batch_op:
-        batch_op.drop_index("ix_tags_tag_type")
-        batch_op.drop_column("tag_type")
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("tags") as batch_op:
-        batch_op.add_column(
-            sa.Column(
-                "tag_type",
-                sa.String(length=32),
-                nullable=False,
-                server_default="user",
-            )
-        )
-        batch_op.create_index("ix_tags_tag_type", ["tag_type"])

alembic_db/versions/0005_allow_case_sensitive_tags.py

@@ -1,107 +0,0 @@
-"""
-Allow case-sensitive tag names.
-
-Revision ID: 0005_allow_case_sensitive_tags
-Revises: 0004_drop_tag_type
-Create Date: 2026-06-16
-"""
-
-import sqlalchemy as sa
-from alembic import op
-
-revision = "0005_allow_case_sensitive_tags"
-down_revision = "0004_drop_tag_type"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    bind = op.get_bind()
-    if bind.dialect.name == "sqlite":
-        # SQLite cannot ALTER/DROP CHECK constraints. Recreate the small tag
-        # vocabulary table without the lowercase constraint while preserving
-        # existing tag names.
-        op.execute("PRAGMA foreign_keys=OFF")
-        try:
-            op.execute(
-                "CREATE TABLE tags_new ("
-                "name VARCHAR(512) NOT NULL, "
-                "CONSTRAINT pk_tags PRIMARY KEY (name)"
-                ")"
-            )
-            op.execute("INSERT INTO tags_new(name) SELECT name FROM tags")
-            op.execute("DROP TABLE tags")
-            op.execute("ALTER TABLE tags_new RENAME TO tags")
-        finally:
-            op.execute("PRAGMA foreign_keys=ON")
-        return
-
-    op.drop_constraint("ck_tags_ck_tags_lowercase", "tags", type_="check")
-
-
-def downgrade() -> None:
-    # Existing mixed-case tags cannot satisfy the old constraint. Lowercase them
-    # before restoring it, merging duplicate vocabulary/link rows that collide.
-    bind = op.get_bind()
-
-    tag_names = [row[0] for row in bind.execute(sa.text("SELECT name FROM tags"))]
-    existing_names = set(tag_names)
-    lowercase_names = sorted({name.lower() for name in tag_names})
-    missing_lowercase_rows = [
-        {"name": name} for name in lowercase_names if name not in existing_names
-    ]
-    if missing_lowercase_rows:
-        bind.execute(sa.text("INSERT INTO tags(name) VALUES (:name)"), missing_lowercase_rows)
-
-    link_rows = bind.execute(
-        sa.text(
-            "SELECT asset_reference_id, tag_name, origin, added_at "
-            "FROM asset_reference_tags "
-            "ORDER BY asset_reference_id, tag_name"
-        )
-    ).mappings()
-    deduped_links = {}
-    for row in link_rows:
-        key = (row["asset_reference_id"], row["tag_name"].lower())
-        deduped_links.setdefault(
-            key,
-            {
-                "asset_reference_id": row["asset_reference_id"],
-                "tag_name": row["tag_name"].lower(),
-                "origin": row["origin"],
-                "added_at": row["added_at"],
-            },
-        )
-
-    op.execute("DELETE FROM asset_reference_tags")
-    if deduped_links:
-        bind.execute(
-            sa.text(
-                "INSERT INTO asset_reference_tags "
-                "(asset_reference_id, tag_name, origin, added_at) "
-                "VALUES (:asset_reference_id, :tag_name, :origin, :added_at)"
-            ),
-            list(deduped_links.values()),
-        )
-    op.execute("DELETE FROM tags WHERE name != lower(name)")
-
-    if bind.dialect.name == "sqlite":
-        op.execute("PRAGMA foreign_keys=OFF")
-        try:
-            op.execute(
-                "CREATE TABLE tags_new ("
-                "name VARCHAR(512) NOT NULL, "
-                "CONSTRAINT pk_tags PRIMARY KEY (name), "
-                "CONSTRAINT ck_tags_lowercase CHECK (name = lower(name))"
-                ")"
-            )
-            op.execute("INSERT INTO tags_new(name) SELECT name FROM tags")
-            op.execute("DROP TABLE tags")
-            op.execute("ALTER TABLE tags_new RENAME TO tags")
-        finally:
-            op.execute("PRAGMA foreign_keys=ON")
-        return
-
-    op.create_check_constraint(
-        "ck_tags_ck_tags_lowercase", "tags", "name = lower(name)"
-    )

alembic_db/versions/0005_download_manager.py

@@ -1,84 +0,0 @@
-"""
-Download manager schema.
-
-Adds the two tables that back the server-side model download manager:
-transient job/queue state (``downloads`` + per-segment ``download_segments``).
-
-Revision ID: 0005_download_manager
-Revises: 0004_drop_tag_type
-Create Date: 2026-06-27
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0005_download_manager"
-down_revision = "0004_drop_tag_type"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "downloads",
-        sa.Column("id", sa.String(length=36), primary_key=True),
-        sa.Column("url", sa.Text(), nullable=False),
-        sa.Column("final_url", sa.Text(), nullable=True),
-        sa.Column("model_id", sa.String(length=1024), nullable=False),
-        sa.Column("dest_path", sa.Text(), nullable=False),
-        sa.Column("temp_path", sa.Text(), nullable=False),
-        sa.Column("status", sa.String(length=16), nullable=False),
-        sa.Column("priority", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("total_bytes", sa.BigInteger(), nullable=True),
-        sa.Column("bytes_done", sa.BigInteger(), nullable=False, server_default="0"),
-        sa.Column("etag", sa.String(length=512), nullable=True),
-        sa.Column("last_modified", sa.String(length=128), nullable=True),
-        sa.Column(
-            "accept_ranges", sa.Boolean(), nullable=False, server_default=sa.text("false")
-        ),
-        sa.Column("expected_sha256", sa.String(length=64), nullable=True),
-        sa.Column(
-            "allow_any_extension",
-            sa.Boolean(),
-            nullable=False,
-            server_default=sa.text("false"),
-        ),
-        sa.Column("attempts", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("error", sa.Text(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
-        sa.CheckConstraint("bytes_done >= 0", name="ck_downloads_bytes_done_nonneg"),
-        sa.CheckConstraint(
-            "total_bytes IS NULL OR total_bytes >= 0",
-            name="ck_downloads_total_bytes_nonneg",
-        ),
-    )
-    op.create_index("ix_downloads_status", "downloads", ["status"])
-    op.create_index("ix_downloads_priority", "downloads", ["priority"])
-    op.create_index("ix_downloads_model_id", "downloads", ["model_id"])
-
-    op.create_table(
-        "download_segments",
-        sa.Column(
-            "download_id",
-            sa.String(length=36),
-            sa.ForeignKey("downloads.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("idx", sa.Integer(), nullable=False),
-        sa.Column("start_offset", sa.BigInteger(), nullable=False),
-        sa.Column("end_offset", sa.BigInteger(), nullable=False),
-        sa.Column("bytes_done", sa.BigInteger(), nullable=False, server_default="0"),
-        sa.PrimaryKeyConstraint("download_id", "idx", name="pk_download_segments"),
-        sa.CheckConstraint("bytes_done >= 0", name="ck_segments_bytes_done_nonneg"),
-        sa.CheckConstraint("end_offset >= start_offset", name="ck_segments_range"),
-    )
-
-
-def downgrade() -> None:
-    op.drop_table("download_segments")
-
-    op.drop_index("ix_downloads_model_id", table_name="downloads")
-    op.drop_index("ix_downloads_priority", table_name="downloads")
-    op.drop_index("ix_downloads_status", table_name="downloads")
-    op.drop_table("downloads")

alembic_db/versions/0006_add_loader_path.py

@@ -1,30 +0,0 @@
-"""
-Add loader_path column to asset_references.
-
-Stores the in-root loader path (path relative to the storage root with the
-top-level model category dropped) derived from file_path at scan/ingest time,
-so the assets API can return it without re-resolving against every registered
-model-folder base on every request.
-
-Revision ID: 0006_add_loader_path
-Revises: 0005_allow_case_sensitive_tags
-Create Date: 2026-07-02
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0006_add_loader_path"
-down_revision = "0005_allow_case_sensitive_tags"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.add_column(sa.Column("loader_path", sa.Text(), nullable=True))
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.drop_column("loader_path")

app/assets/api/routes.py

@@ -39,8 +39,6 @@ from app.assets.services import (
     update_asset_metadata,
     upload_from_temp_path,
 )
-from app.assets.services.cursor import InvalidCursorError
-from app.assets.services.path_utils import compute_display_name
 from app.assets.services.tagging import list_tag_histogram
 
 ROUTES = web.RouteTableDef()
@@ -162,20 +160,10 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResu
             preview_url = None
     else:
         preview_url = _build_preview_url_from_view(result.tags, result.ref.user_metadata)
-    if result.ref.file_path:
-        display_name = compute_display_name(result.ref.file_path)
-        # In-root loader path (model category dropped): what model loaders consume.
-        loader_path = result.ref.loader_path
-    else:
-        display_name, loader_path = None, None
-    asset_content_hash = result.asset.hash if result.asset else None
     return schemas_out.Asset(
         id=result.ref.id,
         name=result.ref.name,
-        hash=asset_content_hash,
-        loader_path=loader_path,
-        display_name=display_name,
-        asset_hash=asset_content_hash,
+        asset_hash=result.asset.hash if result.asset else None,
         size=int(result.asset.size_bytes) if result.asset else None,
         mime_type=result.asset.mime_type if result.asset else None,
         tags=result.tags,
@@ -184,7 +172,7 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResu
         user_metadata=result.ref.user_metadata or {},
         metadata=result.ref.system_metadata,
         job_id=result.ref.job_id,
-        prompt_id=result.ref.job_id,  # deprecated alias of job_id, kept for compatibility
+        prompt_id=result.ref.job_id,  # deprecated: mirrors job_id for cloud compat
         created_at=result.ref.created_at,
         updated_at=result.ref.updated_at,
         last_access_time=result.ref.last_access_time,
@@ -221,37 +209,24 @@ async def list_assets_route(request: web.Request) -> web.Response:
     order_candidate = (q.order or "desc").lower()
     order = order_candidate if order_candidate in {"asc", "desc"} else "desc"
 
-    try:
-        result = list_assets_page(
-            owner_id=USER_MANAGER.get_request_user_id(request),
-            include_tags=q.include_tags,
-            exclude_tags=q.exclude_tags,
-            name_contains=q.name_contains,
-            metadata_filter=q.metadata_filter,
-            limit=q.limit,
-            offset=q.offset,
-            sort=sort,
-            order=order,
-            after=q.after,
-        )
-    except InvalidCursorError as e:
-        return _build_error_response(400, "INVALID_CURSOR", str(e))
+    result = list_assets_page(
+        owner_id=USER_MANAGER.get_request_user_id(request),
+        include_tags=q.include_tags,
+        exclude_tags=q.exclude_tags,
+        name_contains=q.name_contains,
+        metadata_filter=q.metadata_filter,
+        limit=q.limit,
+        offset=q.offset,
+        sort=sort,
+        order=order,
+    )
 
     summaries = [_build_asset_response(item) for item in result.items]
 
-    # has_more semantics differ by mode:
-    #   - cursor mode: a non-empty next_cursor means there are more results.
-    #   - offset mode: derived from total - (offset + page size).
-    if q.after is not None:
-        has_more = result.next_cursor is not None
-    else:
-        has_more = (q.offset + len(summaries)) < result.total
-
     payload = schemas_out.AssetsList(
         assets=summaries,
         total=result.total,
-        has_more=has_more,
-        next_cursor=result.next_cursor,
+        has_more=(q.offset + len(summaries)) < result.total,
     )
     return web.json_response(payload.model_dump(mode="json", exclude_none=True))
 
@@ -315,15 +290,12 @@ async def download_asset_content(request: web.Request) -> web.Response:
             404, "FILE_NOT_FOUND", "Underlying file not found on disk."
         )
 
-    # User-controlled asset content must never render inline in the app origin
-    # (stored XSS via SVG/HTML/XML). Force dangerous types to download and
-    # override any requested inline disposition. Centralised through
-    # folder_paths.is_dangerous_content_type so this can't drift from /view and
-    # /userdata (the previous inline set here omitted image/svg+xml and missed
-    # the charset/casing/+xml-dialect bypasses).
-    if folder_paths.is_dangerous_content_type(content_type):
+    _DANGEROUS_MIME_TYPES = {
+        "text/html", "text/html-sandboxed", "application/xhtml+xml",
+        "text/javascript", "text/css",
+    }
+    if content_type in _DANGEROUS_MIME_TYPES:
         content_type = "application/octet-stream"
-        disposition = "attachment"
 
     safe_name = (filename or "").replace("\r", "").replace("\n", "")
     encoded = urllib.parse.quote(safe_name)
@@ -428,6 +400,17 @@ async def upload_asset(request: web.Request) -> web.Response:
             400, "INVALID_BODY", f"Validation failed: {ve.json()}"
         )
 
+    if spec.tags and spec.tags[0] == "models":
+        if (
+            len(spec.tags) < 2
+            or spec.tags[1] not in folder_paths.folder_names_and_paths
+        ):
+            delete_temp_file_if_exists(parsed.tmp_path)
+            category = spec.tags[1] if len(spec.tags) >= 2 else ""
+            return _build_error_response(
+                400, "INVALID_BODY", f"unknown models category '{category}'"
+            )
+
     try:
         # Fast path: hash exists, create AssetReference without writing anything
         if spec.hash and parsed.provided_hash_exists is True:
@@ -471,7 +454,7 @@ async def upload_asset(request: web.Request) -> web.Response:
         return _build_error_response(400, e.code, str(e))
     except ValueError as e:
         delete_temp_file_if_exists(parsed.tmp_path)
-        return _build_error_response(400, "INVALID_BODY", str(e))
+        return _build_error_response(400, "BAD_REQUEST", str(e))
     except HashMismatchError as e:
         delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(400, "HASH_MISMATCH", str(e))
@@ -534,14 +517,18 @@ async def update_asset_route(request: web.Request) -> web.Response:
 @_require_assets_feature_enabled
 async def delete_asset_route(request: web.Request) -> web.Response:
     reference_id = str(uuid.UUID(request.match_info["id"]))
+    delete_content_param = request.query.get("delete_content")
+    delete_content = (
+        False
+        if delete_content_param is None
+        else delete_content_param.lower() not in {"0", "false", "no"}
+    )
 
     try:
-        # Deleting an asset is a soft delete of the reference; the underlying
-        # content is preserved (it may be shared with other references).
         deleted = delete_asset_reference(
             reference_id=reference_id,
             owner_id=USER_MANAGER.get_request_user_id(request),
-            delete_content_if_orphan=False,
+            delete_content_if_orphan=delete_content,
         )
     except Exception:
         logging.exception(
@@ -586,8 +573,8 @@ async def get_tags(request: web.Request) -> web.Response:
     )
 
     tags = [
-        schemas_out.TagUsage(name=name, count=count)
-        for (name, count) in rows
+        schemas_out.TagUsage(name=name, count=count, type=tag_type)
+        for (name, tag_type, count) in rows
     ]
     payload = schemas_out.TagsList(
         tags=tags, total=total, has_more=(query.offset + len(tags)) < total

app/assets/api/schemas_in.py

@@ -59,11 +59,6 @@ class ListAssetsQuery(BaseModel):
 
     limit: conint(ge=1, le=500) = 20
     offset: conint(ge=0) = 0
-    # Opaque keyset cursor. When supplied, `offset` is ignored. Cursor pagination
-    # is supported for sort values `created_at`, `updated_at`, `name`, `size`.
-    # Supplying `after` together with `sort=last_access_time` returns
-    # 400 INVALID_CURSOR; that sort only supports offset/limit.
-    after: str | None = None
 
     sort: Literal["name", "created_at", "updated_at", "size", "last_access_time"] = (
         "created_at"
@@ -140,7 +135,7 @@ class CreateFromHashBody(BaseModel):
         if v is None:
             return []
         if isinstance(v, list):
-            out = [str(t).strip() for t in v if str(t).strip()]
+            out = [str(t).strip().lower() for t in v if str(t).strip()]
             seen = set()
             dedup = []
             for t in out:
@@ -149,7 +144,7 @@ class CreateFromHashBody(BaseModel):
                     dedup.append(t)
             return dedup
         if isinstance(v, str):
-            return list(dict.fromkeys(t.strip() for t in v.split(",") if t.strip()))
+            return [t.strip().lower() for t in v.split(",") if t.strip()]
         return []
 
 
@@ -206,7 +201,7 @@ class TagsListQuery(BaseModel):
         if v is None:
             return v
         v = v.strip()
-        return v or None
+        return v.lower() or None
 
 
 class TagsAdd(BaseModel):
@@ -220,7 +215,7 @@ class TagsAdd(BaseModel):
         for t in v:
             if not isinstance(t, str):
                 raise TypeError("tags must be strings")
-            tnorm = t.strip()
+            tnorm = t.strip().lower()
             if tnorm:
                 out.append(tnorm)
         seen = set()
@@ -239,8 +234,8 @@ class TagsRemove(TagsAdd):
 class UploadAssetSpec(BaseModel):
     """Upload Asset operation.
 
-    - tags: labels plus one destination role ('models'|'input'|'output') for new bytes;
-            if role == 'models', exactly one model_type:<folder_name> tag is required
+    - tags: optional list; if provided, first is root ('models'|'input'|'output');
+            if root == 'models', second must be a valid category
     - name: display name
     - user_metadata: arbitrary JSON object (optional)
     - hash: optional canonical 'blake3:<hex>' for validation / fast-path
@@ -309,7 +304,7 @@ class UploadAssetSpec(BaseModel):
         norm = []
         seen = set()
         for t in items:
-            tnorm = str(t).strip()
+            tnorm = str(t).strip().lower()
             if tnorm and tnorm not in seen:
                 seen.add(tnorm)
                 norm.append(tnorm)
@@ -335,4 +330,14 @@ class UploadAssetSpec(BaseModel):
 
     @model_validator(mode="after")
     def _validate_order(self):
+        if not self.tags:
+            raise ValueError("at least one tag is required for uploads")
+        root = self.tags[0]
+        if root not in {"models", "input", "output"}:
+            raise ValueError("first tag must be one of: models, input, output")
+        if root == "models":
+            if len(self.tags) < 2:
+                raise ValueError(
+                    "models uploads require a category tag as the second tag"
+                )
         return self

app/assets/api/schemas_out.py

@@ -9,20 +9,7 @@ class Asset(BaseModel):
     ``id`` here is the AssetReference id, not the content-addressed Asset id."""
 
     id: str
-    name: str = Field(
-        ...,
-        deprecated=True,
-        description="Reference label, often caller-provided or derived from the filename. Deprecated for storage path/display semantics; use `loader_path` and `display_name` when present.",
-    )
-    hash: str | None = None
-    loader_path: str | None = Field(
-        default=None,
-        description="The value a loader consumes to load this asset. `None` when no loader can resolve the file.",
-    )
-    display_name: str | None = Field(
-        default=None,
-        description="Human-facing label for the asset. Not unique.",
-    )
+    name: str
     asset_hash: str | None = None
     size: int | None = None
     mime_type: str | None = None
@@ -53,13 +40,12 @@ class AssetsList(BaseModel):
     assets: list[Asset]
     total: int
     has_more: bool
-    # Opaque cursor for the next page. Omitted when there are no more results.
-    next_cursor: str | None = None
 
 
 class TagUsage(BaseModel):
     name: str
     count: int
+    type: str
 
 
 class TagsList(BaseModel):

app/assets/api/upload.py

@@ -140,6 +140,7 @@ async def parse_multipart_upload(
             provided_mime_type = ((await field.text()) or "").strip() or None
         elif fname == "preview_id":
             provided_preview_id = ((await field.text()) or "").strip() or None
+
     if not file_present and not (provided_hash and provided_hash_exists):
         raise UploadError(
             400, "MISSING_FILE", "Form must include a 'file' part or a known 'hash'."

app/assets/database/models.py

@@ -76,8 +76,6 @@ class AssetReference(Base):
 
     # Cache state fields (from former AssetCacheState)
     file_path: Mapped[str | None] = mapped_column(Text, nullable=True)
-    # In-root loader path derived from file_path at scan/ingest time.
-    loader_path: Mapped[str | None] = mapped_column(Text, nullable=True)
     mtime_ns: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
     needs_verify: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     is_missing: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
@@ -229,6 +227,7 @@ class Tag(Base):
     __tablename__ = "tags"
 
     name: Mapped[str] = mapped_column(String(512), primary_key=True)
+    tag_type: Mapped[str] = mapped_column(String(32), nullable=False, default="user")
 
     asset_reference_links: Mapped[list[AssetReferenceTag]] = relationship(
         back_populates="tag",
@@ -241,5 +240,7 @@ class Tag(Base):
         overlaps="asset_reference_links,tag_links,tags,asset_reference",
     )
 
+    __table_args__ = (Index("ix_tags_tag_type", "tag_type"),)
+
     def __repr__(self) -> str:
         return f"<Tag {self.name}>"

app/assets/database/queries/asset_reference.py

@@ -266,18 +266,9 @@ def list_references_page(
     metadata_filter: dict | None = None,
     sort: str | None = None,
     order: str | None = None,
-    after_cursor_value: object | None = None,
-    after_cursor_id: str | None = None,
 ) -> tuple[list[AssetReference], dict[str, list[str]], int]:
     """List references with pagination, filtering, and sorting.
 
-    When ``after_cursor_value``/``after_cursor_id`` are supplied the query uses
-    keyset pagination — ``offset`` is ignored and a WHERE clause selects rows
-    strictly after the given ``(sort_col, id)`` position in the active sort
-    direction. The cursor value must already be typed for the column
-    (datetime for time sorts, int for size, str for name); the caller decodes
-    the opaque cursor string and resolves to the typed value.
-
     Returns (references, tag_map, total_count).
     """
     base = (
@@ -306,31 +297,9 @@ def list_references_page(
         "size": Asset.size_bytes,
     }
     sort_col = sort_map.get(sort, AssetReference.created_at)
-    descending = order == "desc"
+    sort_exp = sort_col.desc() if order == "desc" else sort_col.asc()
 
-    # Keyset WHERE: (sort_col, id) strictly less-than / greater-than the cursor.
-    # Equivalent to: sort_col <op> v  OR  (sort_col = v AND id <op> cursor_id).
-    if after_cursor_value is not None and after_cursor_id is not None:
-        if descending:
-            keyset = sa.or_(
-                sort_col < after_cursor_value,
-                sa.and_(sort_col == after_cursor_value, AssetReference.id < after_cursor_id),
-            )
-        else:
-            keyset = sa.or_(
-                sort_col > after_cursor_value,
-                sa.and_(sort_col == after_cursor_value, AssetReference.id > after_cursor_id),
-            )
-        base = base.where(keyset)
-
-    # Secondary ORDER BY id (matching the primary direction) gives the keyset
-    # comparison a deterministic tiebreaker on duplicate sort_col values.
-    id_exp = AssetReference.id.desc() if descending else AssetReference.id.asc()
-    sort_exp = sort_col.desc() if descending else sort_col.asc()
-
-    base = base.order_by(sort_exp, id_exp).limit(limit)
-    if after_cursor_id is None:
-        base = base.offset(offset)
+    base = base.order_by(sort_exp).limit(limit).offset(offset)
 
     count_stmt = (
         select(sa.func.count())
@@ -650,7 +619,6 @@ def upsert_reference(
     name: str,
     mtime_ns: int,
     owner_id: str = "",
-    loader_path: str | None = None,
 ) -> tuple[bool, bool]:
     """Upsert a reference by file_path. Returns (created, updated).
 
@@ -660,7 +628,6 @@ def upsert_reference(
     vals = {
         "asset_id": asset_id,
         "file_path": file_path,
-        "loader_path": loader_path,
         "name": name,
         "owner_id": owner_id,
         "mtime_ns": int(mtime_ns),
@@ -688,14 +655,13 @@ def upsert_reference(
                 AssetReference.asset_id != asset_id,
                 AssetReference.mtime_ns.is_(None),
                 AssetReference.mtime_ns != int(mtime_ns),
-                AssetReference.loader_path.is_distinct_from(loader_path),
                 AssetReference.is_missing == True,  # noqa: E712
                 AssetReference.deleted_at.isnot(None),
             )
         )
         .values(
-            asset_id=asset_id, mtime_ns=int(mtime_ns), loader_path=loader_path,
-            is_missing=False, deleted_at=None, updated_at=now,
+            asset_id=asset_id, mtime_ns=int(mtime_ns), is_missing=False,
+            deleted_at=None, updated_at=now,
         )
     )
     res2 = session.execute(upd)

app/assets/database/queries/tags.py

@@ -55,11 +55,13 @@ def validate_tags_exist(session: Session, tags: list[str]) -> None:
         raise ValueError(f"Unknown tags: {missing}")
 
 
-def ensure_tags_exist(session: Session, names: Iterable[str]) -> None:
+def ensure_tags_exist(
+    session: Session, names: Iterable[str], tag_type: str = "user"
+) -> None:
     wanted = normalize_tags(list(names))
     if not wanted:
         return
-    rows = [{"name": n} for n in list(dict.fromkeys(wanted))]
+    rows = [{"name": n, "tag_type": tag_type} for n in list(dict.fromkeys(wanted))]
     ins = (
         sqlite.insert(Tag)
         .values(rows)
@@ -95,7 +97,7 @@ def set_reference_tags(
     to_remove = [t for t in current if t not in desired]
 
     if to_add:
-        ensure_tags_exist(session, to_add)
+        ensure_tags_exist(session, to_add, tag_type="user")
         session.add_all(
             [
                 AssetReferenceTag(
@@ -140,7 +142,7 @@ def add_tags_to_reference(
         return AddTagsResult(added=[], already_present=[], total_tags=total)
 
     if create_if_missing:
-        ensure_tags_exist(session, norm)
+        ensure_tags_exist(session, norm, tag_type="user")
 
     current = set(get_reference_tags(session, reference_id))
 
@@ -265,8 +267,6 @@ def list_tags_with_usage(
     order: str = "count_desc",
     owner_id: str = "",
 ) -> tuple[list[tuple[str, str, int]], int]:
-    prefix_filter = prefix.strip() if prefix else ""
-
     counts_sq = (
         select(
             AssetReferenceTag.tag_name.label("tag_name"),
@@ -289,14 +289,16 @@ def list_tags_with_usage(
     q = (
         select(
             Tag.name,
+            Tag.tag_type,
             func.coalesce(counts_sq.c.cnt, 0).label("count"),
         )
         .select_from(Tag)
         .join(counts_sq, counts_sq.c.tag_name == Tag.name, isouter=True)
     )
 
-    if prefix_filter:
-        q = q.where(func.substr(Tag.name, 1, len(prefix_filter)) == prefix_filter)
+    if prefix:
+        escaped, esc = escape_sql_like_string(prefix.strip().lower())
+        q = q.where(Tag.name.like(escaped + "%", escape=esc))
 
     if not include_zero:
         q = q.where(func.coalesce(counts_sq.c.cnt, 0) > 0)
@@ -307,8 +309,9 @@ def list_tags_with_usage(
         q = q.order_by(func.coalesce(counts_sq.c.cnt, 0).desc(), Tag.name.asc())
 
     total_q = select(func.count()).select_from(Tag)
-    if prefix_filter:
-        total_q = total_q.where(func.substr(Tag.name, 1, len(prefix_filter)) == prefix_filter)
+    if prefix:
+        escaped, esc = escape_sql_like_string(prefix.strip().lower())
+        total_q = total_q.where(Tag.name.like(escaped + "%", escape=esc))
     if not include_zero:
         visible_tags_sq = (
             select(AssetReferenceTag.tag_name)
@@ -328,7 +331,7 @@ def list_tags_with_usage(
     rows = (session.execute(q.limit(limit).offset(offset))).all()
     total = (session.execute(total_q)).scalar_one()
 
-    rows_norm = [(name, int(count or 0)) for (name, count) in rows]
+    rows_norm = [(name, ttype, int(count or 0)) for (name, ttype, count) in rows]
     return rows_norm, int(total or 0)
 
 

app/assets/helpers.py

@@ -41,10 +41,10 @@ def get_utc_now() -> datetime:
 def normalize_tags(tags: list[str] | None) -> list[str]:
     """
     Normalize a list of tags by:
-      - Stripping whitespace.
-      - Removing exact duplicates while preserving order and case.
+      - Stripping whitespace and converting to lowercase.
+      - Removing duplicates.
     """
-    return list(dict.fromkeys(t.strip() for t in (tags or []) if (t or "").strip()))
+    return list(dict.fromkeys(t.strip().lower() for t in (tags or []) if (t or "").strip()))
 
 
 def validate_blake3_hash(s: str) -> str:

app/assets/scanner.py

@@ -33,10 +33,9 @@ from app.assets.services.file_utils import (
     verify_file_unchanged,
 )
 from app.assets.services.hashing import HashCheckpoint, compute_blake3_hash
-from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.metadata_extract import extract_file_metadata
 from app.assets.services.path_utils import (
-    compute_loader_path,
+    compute_relative_filename,
     get_comfy_models_folders,
     get_name_and_tags_from_asset_path,
 )
@@ -63,7 +62,7 @@ RootType = Literal["models", "input", "output"]
 def get_prefixes_for_root(root: RootType) -> list[str]:
     if root == "models":
         bases: list[str] = []
-        for _bucket, paths, _exts in get_comfy_models_folders():
+        for _bucket, paths in get_comfy_models_folders():
             bases.extend(paths)
         return [os.path.abspath(p) for p in bases]
     if root == "input":
@@ -81,7 +80,7 @@ def get_all_known_prefixes() -> list[str]:
 
 def collect_models_files() -> list[str]:
     out: list[str] = []
-    for folder_name, bases, _exts in get_comfy_models_folders():
+    for folder_name, bases in get_comfy_models_folders():
         rel_files = folder_paths.get_filename_list(folder_name) or []
         for rel_path in rel_files:
             if not all(is_visible(part) for part in Path(rel_path).parts):
@@ -308,7 +307,7 @@ def build_asset_specs(
         if not stat_p.st_size:
             continue
         name, tags = get_name_and_tags_from_asset_path(abs_p)
-        rel_fname = compute_loader_path(abs_p)
+        rel_fname = compute_relative_filename(abs_p)
 
         # Extract metadata (tier 1: filesystem, tier 2: safetensors header)
         metadata = None
@@ -355,7 +354,7 @@ def insert_asset_specs(specs: list[SeedAssetSpec], tag_pool: set[str]) -> int:
         return 0
     with create_session() as sess:
         if tag_pool:
-            ensure_tags_exist(sess, tag_pool)
+            ensure_tags_exist(sess, tag_pool, tag_type="user")
         result = batch_insert_seed_assets(sess, specs=specs, owner_id="")
         sess.commit()
         return result.inserted_refs
@@ -430,7 +429,7 @@ def enrich_asset(
         return new_level
 
     initial_mtime_ns = get_mtime_ns(stat_p)
-    rel_fname = compute_loader_path(file_path)
+    rel_fname = compute_relative_filename(file_path)
     mime_type: str | None = None
     metadata = None
 
@@ -507,10 +506,6 @@ def enrich_asset(
 
     if extract_metadata and metadata:
         system_metadata = metadata.to_user_metadata()
-        if mime_type and mime_type.startswith("image/"):
-            dims = extract_image_dimensions(file_path, mime_type=mime_type)
-            if dims:
-                system_metadata.update(dims)
         set_reference_system_metadata(session, reference_id, system_metadata)
 
     if full_hash:

app/assets/services/asset_management.py

@@ -1,19 +1,8 @@
 import contextlib
 import mimetypes
 import os
-from datetime import timezone
 from typing import Sequence
 
-from app.assets.services.cursor import (
-    CursorPayload,
-    InvalidCursorError,
-    decode_cursor,
-    decode_cursor_int,
-    decode_cursor_time,
-    encode_cursor,
-    encode_cursor_from_time,
-)
-
 
 from app.assets.database.models import Asset
 from app.assets.database.queries import (
@@ -38,7 +27,7 @@ from app.assets.database.queries import (
     update_reference_updated_at,
 )
 from app.assets.helpers import select_best_live_path
-from app.assets.services.path_utils import compute_loader_path
+from app.assets.services.path_utils import compute_relative_filename
 from app.assets.services.schemas import (
     AssetData,
     AssetDetailResult,
@@ -91,7 +80,7 @@ def update_asset_metadata(
             update_reference_name(session, reference_id=reference_id, name=name)
             touched = True
 
-        computed_filename = compute_loader_path(ref.file_path) if ref.file_path else None
+        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
 
         new_meta: dict | None = None
         if user_metadata is not None:
@@ -160,16 +149,6 @@ def delete_asset_reference(
     owner_id: str,
     delete_content_if_orphan: bool = True,
 ) -> bool:
-    """Delete an asset reference.
-
-    With ``delete_content_if_orphan=False`` (a soft delete), the reference is
-    hidden and the underlying content is preserved. With ``True``, the content
-    is also removed once it becomes orphaned.
-
-    Note: the public DELETE /api/assets/{id} endpoint always soft-deletes
-    (passes ``False``); the orphan-reclamation path is intentionally
-    internal-only, retained for a future GC/admin caller.
-    """
     with create_session() as session:
         if not delete_content_if_orphan:
             # Soft delete: mark the reference as deleted but keep everything
@@ -263,11 +242,6 @@ def get_asset_by_hash(asset_hash: str) -> AssetData | None:
         return extract_asset_data(asset)
 
 
-# Sort fields that support cursor pagination. `last_access_time` is not
-# in this list — it falls back to offset/limit.
-_CURSOR_SORT_FIELDS = ("created_at", "updated_at", "name", "size")
-
-
 def list_assets_page(
     owner_id: str = "",
     include_tags: Sequence[str] | None = None,
@@ -278,39 +252,7 @@ def list_assets_page(
     offset: int = 0,
     sort: str = "created_at",
     order: str = "desc",
-    after: str | None = None,
 ) -> ListAssetsResult:
-    """List assets with optional cursor pagination.
-
-    When ``after`` is supplied it overrides ``offset``. The cursor's sort field
-    must match ``sort`` and be in the cursor-supported allowlist; mismatches
-    raise InvalidCursorError so the handler can map to 400 INVALID_CURSOR.
-    """
-    cursor_value: object | None = None
-    cursor_id: str | None = None
-    # Mint next_cursor on every page where the sort is cursor-supported, not
-    # only when the request itself arrived with a cursor. Otherwise a first
-    # request (no `after`) returns next_cursor=None and the client can never
-    # enter cursor mode.
-    mint_cursor = sort in _CURSOR_SORT_FIELDS
-
-    if after is not None:
-        if sort not in _CURSOR_SORT_FIELDS:
-            raise InvalidCursorError(
-                f"cursor pagination is not supported for sort={sort!r}"
-            )
-        payload = decode_cursor(after, _CURSOR_SORT_FIELDS, expected_order=order)
-        if payload.sort_field != sort:
-            raise InvalidCursorError(
-                f"cursor sort field {payload.sort_field!r} does not match request sort {sort!r}"
-            )
-        cursor_value, cursor_id = _resolve_cursor_value(payload), payload.id
-
-    # Over-fetch by one row so we can distinguish "exactly `limit` rows total
-    # remaining" from "more rows past this page" without a second query. Drop
-    # the sentinel before returning.
-    fetch_limit = limit + 1 if mint_cursor else limit
-
     with create_session() as session:
         refs, tag_map, total = list_references_page(
             session,
@@ -319,22 +261,12 @@ def list_assets_page(
             exclude_tags=exclude_tags,
             name_contains=name_contains,
             metadata_filter=metadata_filter,
-            limit=fetch_limit,
+            limit=limit,
             offset=offset,
             sort=sort,
             order=order,
-            after_cursor_value=cursor_value,
-            after_cursor_id=cursor_id,
         )
 
-        next_cursor: str | None = None
-        if mint_cursor and len(refs) > limit:
-            # There's at least one more row past this page — mint a cursor from
-            # the last row of the page (i.e. index `limit - 1`, since we
-            # over-fetched), and drop the sentinel.
-            next_cursor = _encode_next_cursor(refs[limit - 1], sort, order)
-            refs = refs[:limit]
-
         items: list[AssetSummaryData] = []
         for ref in refs:
             items.append(
@@ -345,39 +277,7 @@ def list_assets_page(
                 )
             )
 
-        return ListAssetsResult(items=items, total=total, next_cursor=next_cursor)
-
-
-def _resolve_cursor_value(payload: CursorPayload) -> object:
-    """Map a decoded cursor payload to a column-typed Python value."""
-    if payload.sort_field in ("created_at", "updated_at"):
-        # DB stores naive UTC; strip tzinfo so the comparison binds against a
-        # `TIMESTAMP WITHOUT TIME ZONE` column without an offset shift.
-        return decode_cursor_time(payload).replace(tzinfo=None)
-    if payload.sort_field == "size":
-        return decode_cursor_int(payload)
-    return payload.value  # name, str-typed
-
-
-def _encode_next_cursor(ref, sort: str, order: str) -> str | None:
-    """Mint a cursor pointing at *ref* for the given sort dimension.
-
-    Returns None when the boundary row carries a NULL sort value (e.g. an asset
-    record whose size_bytes hasn't been backfilled). Continuing pagination
-    across a NULL boundary is undefined under keyset ordering — better to
-    truncate cleanly here than to mint a cursor that mis-positions.
-    """
-    if sort == "name":
-        return encode_cursor("name", ref.name, ref.id, order=order)
-    if sort == "size":
-        if ref.asset is None or ref.asset.size_bytes is None:
-            return None
-        return encode_cursor("size", str(ref.asset.size_bytes), ref.id, order=order)
-    # created_at / updated_at — DB datetimes are naive UTC; attach tz before encoding.
-    value = ref.created_at if sort == "created_at" else ref.updated_at
-    if value is None:
-        return None
-    return encode_cursor_from_time(sort, value.replace(tzinfo=timezone.utc), ref.id, order=order)
+        return ListAssetsResult(items=items, total=total)
 
 
 def resolve_hash_to_path(

app/assets/services/bulk_ingest.py

@@ -56,7 +56,6 @@ class ReferenceRow(TypedDict):
     id: str
     asset_id: str
     file_path: str
-    loader_path: str | None
     mtime_ns: int
     owner_id: str
     name: str
@@ -135,14 +134,6 @@ def batch_insert_seed_assets(
 
     for spec in specs:
         absolute_path = os.path.abspath(spec["abs_path"])
-        existing_asset_id = path_to_asset_id.get(absolute_path)
-        if existing_asset_id is not None:
-            existing_tags = asset_id_to_ref_data[existing_asset_id]["tags"]
-            asset_id_to_ref_data[existing_asset_id]["tags"] = list(
-                dict.fromkeys([*existing_tags, *spec["tags"]])
-            )
-            continue
-
         asset_id = str(uuid.uuid4())
         reference_id = str(uuid.uuid4())
         absolute_path_list.append(absolute_path)
@@ -173,8 +164,6 @@ def batch_insert_seed_assets(
                 "id": reference_id,
                 "asset_id": asset_id,
                 "file_path": absolute_path,
-                # spec["fname"] is compute_loader_path(abs_path) from build_asset_specs.
-                "loader_path": spec["fname"],
                 "mtime_ns": spec["mtime_ns"],
                 "owner_id": owner_id,
                 "name": spec["info_name"],

app/assets/services/cursor.py

@@ -1,213 +0,0 @@
-"""Opaque keyset-pagination cursor for /api/assets.
-
-Payload JSON uses short keys to keep the encoded length small:
-
-    {"s": <sort_field>, "v": <value>, "id": <id>, "o": <order>}
-
-The `o` key binds the cursor to the sort direction it was minted under,
-so replaying a `desc` cursor against an `asc` request fails with
-``INVALID_CURSOR`` rather than silently walking the wrong direction.
-`o` is mandatory on every payload — a cursor without it is rejected as
-malformed.
-
-Encoding is base64url with no padding. Cursors are opaque tokens: the
-payload format is internal to this server, and clients must treat a
-cursor as a black box handed back via `next_cursor`. No byte-level
-compatibility with any other implementation is required.
-
-Time values are serialized as Unix microseconds (UTC) — microsecond
-precision is sufficient to round-trip the timestamps stored by the
-database without rounding rows in the same millisecond bucket.
-"""
-from __future__ import annotations
-
-import base64
-import json
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from typing import Iterable, Optional
-
-
-class InvalidCursorError(ValueError):
-    """Raised on a malformed, oversized, or unsupported-sort-field cursor.
-
-    Map to a 400 response with code ``INVALID_CURSOR`` at the handler.
-    """
-
-
-# Wire-format length caps. Cursors are user-controlled, so caps protect the
-# decode path from oversized allocations and downstream SQL predicates from
-# unbounded strings.
-#
-# MAX_CURSOR_VALUE_LENGTH is 512 to fit the `AssetReference.name` column max
-# (`String(512)`) — otherwise a long-named asset would mint a cursor the same
-# server then refuses on the next request.
-#
-# MAX_ENCODED_CURSOR_LENGTH is the decode-path guard, sized comfortably above
-# the largest cursor the per-field caps can produce. Worst case is value + id
-# at their caps with every character JSON-escaping to the six-byte `\uXXXX`
-# form (control characters), which is ~5.2 KB once base64url-encoded. At 8192
-# the encoder can never mint a cursor that exceeds it, so a freshly minted
-# cursor always decodes on the next request and there is no user-visible
-# "cursor too long" failure.
-MAX_ENCODED_CURSOR_LENGTH = 8192
-MAX_CURSOR_VALUE_LENGTH = 512
-MAX_CURSOR_ID_LENGTH = 128
-
-
-@dataclass(frozen=True)
-class CursorPayload:
-    sort_field: str
-    value: str
-    id: str
-    order: str
-
-
-_VALID_ORDERS = ("asc", "desc")
-
-
-def encode_cursor(sort_field: str, value: str, id: str, order: str = "desc") -> str:
-    """Encode a cursor payload as a base64url (no-padding) string.
-
-    `order` binds the cursor to the sort direction it was minted under so a
-    later request with a flipped `order` query parameter is rejected with
-    ``INVALID_CURSOR`` rather than silently walking the wrong direction.
-    """
-    if order not in _VALID_ORDERS:
-        raise InvalidCursorError(f"order must be one of {_VALID_ORDERS}, got {order!r}")
-    # Symmetric input validation: the encoder must reject anything the
-    # decoder rejects, or the same server will mint cursors it then 400s on
-    # the next request.
-    if not id:
-        raise InvalidCursorError("id must be non-empty")
-    if len(id) > MAX_CURSOR_ID_LENGTH:
-        raise InvalidCursorError("id exceeds maximum length")
-    if len(value) > MAX_CURSOR_VALUE_LENGTH:
-        raise InvalidCursorError("value exceeds maximum length")
-    payload = {"s": sort_field, "v": value, "id": id, "o": order}
-    raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
-    # No mint-time length guard is needed: the per-field caps above bound the
-    # encoded length well below MAX_ENCODED_CURSOR_LENGTH (see its definition),
-    # so the encoder can never produce a cursor the decode path would reject.
-    return base64.urlsafe_b64encode(raw.encode("utf-8")).rstrip(b"=").decode("ascii")
-
-
-def encode_cursor_from_time(sort_field: str, t: datetime, id: str, order: str = "desc") -> str:
-    """Encode a time-typed cursor at Unix microsecond precision.
-
-    Accepts an aware datetime (any timezone) and normalizes to UTC. Naive
-    datetimes are rejected so callers can't accidentally encode the local
-    wall-clock value of a UTC-stored timestamp.
-    """
-    if t.tzinfo is None:
-        raise ValueError("encode_cursor_from_time requires an aware datetime")
-    micros = _datetime_to_unix_micros(t.astimezone(timezone.utc))
-    return encode_cursor(sort_field, str(micros), id, order=order)
-
-
-def decode_cursor(
-    cursor: str,
-    allowed_sort_fields: Iterable[str],
-    expected_order: str | None = None,
-) -> CursorPayload:
-    """Parse an opaque cursor.
-
-    ``allowed_sort_fields`` is the endpoint's accepted sort-field list — a
-    cursor carrying a field outside this set is rejected so a cursor minted
-    for one column can't be replayed against another (e.g. a ``created_at``
-    timestamp string compared against a ``name`` column).
-
-    ``expected_order`` (``"asc"``/``"desc"``), when supplied, must match the
-    payload's ``o`` field. ``o`` is required on every payload; a cursor
-    missing it is rejected as malformed.
-
-    Passing no allowed fields rejects every cursor.
-    """
-    if len(cursor) > MAX_ENCODED_CURSOR_LENGTH:
-        raise InvalidCursorError("cursor exceeds maximum length")
-
-    try:
-        # urlsafe_b64decode requires correct padding; we strip on encode, so
-        # restore the trailing '=' pad here.
-        padding = "=" * (-len(cursor) % 4)
-        raw = base64.urlsafe_b64decode(cursor + padding)
-    except (ValueError, base64.binascii.Error) as e:
-        raise InvalidCursorError(f"encoding: {e}") from e
-
-    try:
-        decoded = json.loads(raw)
-    except (json.JSONDecodeError, UnicodeDecodeError) as e:
-        raise InvalidCursorError(f"payload: {e}") from e
-
-    if not isinstance(decoded, dict):
-        raise InvalidCursorError("payload: expected object")
-
-    sort_field = decoded.get("s")
-    value = decoded.get("v")
-    id = decoded.get("id")
-    order = decoded.get("o")
-
-    if not isinstance(sort_field, str) or not isinstance(value, str) or not isinstance(id, str):
-        raise InvalidCursorError("payload: missing or non-string s/v/id")
-
-    if id == "":
-        raise InvalidCursorError("missing id")
-    if len(id) > MAX_CURSOR_ID_LENGTH:
-        raise InvalidCursorError("id exceeds maximum length")
-    if len(value) > MAX_CURSOR_VALUE_LENGTH:
-        raise InvalidCursorError("value exceeds maximum length")
-
-    if sort_field not in allowed_sort_fields:
-        raise InvalidCursorError(f"unsupported sort field {sort_field!r}")
-
-    if not isinstance(order, str):
-        raise InvalidCursorError("missing or non-string o")
-    if order not in _VALID_ORDERS:
-        raise InvalidCursorError(f"unsupported order {order!r}")
-    if expected_order is not None and order != expected_order:
-        raise InvalidCursorError(
-            f"cursor order {order!r} does not match request order {expected_order!r}"
-        )
-
-    return CursorPayload(sort_field=sort_field, value=value, id=id, order=order)
-
-
-def decode_cursor_time(payload: Optional[CursorPayload]) -> datetime:
-    """Parse a time-typed cursor value as Unix microseconds, returning UTC."""
-    if payload is None:
-        raise InvalidCursorError("nil cursor payload")
-    try:
-        micros = int(payload.value)
-    except ValueError as e:
-        raise InvalidCursorError(f"value is not a valid timestamp: {e}") from e
-    try:
-        return _unix_micros_to_datetime(micros)
-    except (OverflowError, OSError, ValueError) as e:
-        # Crafted out-of-range microseconds (e.g. > datetime.MAX_YEAR) blow up
-        # in fromtimestamp / datetime construction. Map to 400, not 500.
-        raise InvalidCursorError(f"value is out of representable range: {e}") from e
-
-
-def decode_cursor_int(payload: Optional[CursorPayload]) -> int:
-    """Parse a cursor value as a base-10 integer."""
-    if payload is None:
-        raise InvalidCursorError("nil cursor payload")
-    try:
-        return int(payload.value)
-    except ValueError as e:
-        raise InvalidCursorError(f"value is not a valid integer: {e}") from e
-
-
-_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
-
-
-def _datetime_to_unix_micros(t: datetime) -> int:
-    """Convert an aware UTC datetime to Unix microseconds (integer math)."""
-    delta = t - _EPOCH
-    return (delta.days * 86_400 + delta.seconds) * 1_000_000 + delta.microseconds
-
-
-def _unix_micros_to_datetime(micros: int) -> datetime:
-    """Convert Unix microseconds to a UTC datetime, preserving precision."""
-    seconds, micro_remainder = divmod(micros, 1_000_000)
-    return datetime.fromtimestamp(seconds, tz=timezone.utc).replace(microsecond=micro_remainder)

app/assets/services/image_dimensions.py

@@ -1,63 +0,0 @@
-"""Image dimension extraction for asset ingest.
-
-Reads only the image header via Pillow to capture width/height cheaply,
-without a full pixel decode. Returns a metadata dict suitable for merging
-into ``AssetReference.system_metadata``.
-"""
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def extract_image_dimensions(
-    file_path: str, mime_type: str | None = None
-) -> dict[str, Any] | None:
-    """Extract image dimensions for the file at ``file_path``.
-
-    Args:
-        file_path: Absolute path to a file on disk.
-        mime_type: Optional MIME type hint. When provided and not prefixed
-            with ``image/``, extraction is skipped without touching the file.
-
-    Returns:
-        ``{"kind": "image", "width": W, "height": H}`` when the file is a
-        recognizable image with positive dimensions, otherwise ``None``.
-
-    The dict shape is intended to be merged into ``system_metadata`` so the
-    asset response surfaces ``metadata.kind`` plus dimension fields for image
-    assets. Forward-compatible: future media kinds (e.g. ``"video"`` with
-    duration/fps) can extend this shape without schema changes.
-    """
-    if mime_type is not None and not mime_type.startswith("image/"):
-        return None
-
-    try:
-        from PIL import Image, UnidentifiedImageError
-    except ImportError:
-        logger.debug(
-            "Pillow not available; skipping image dimension extraction for %s",
-            file_path,
-        )
-        return None
-
-    try:
-        with Image.open(file_path) as img:
-            width, height = img.size
-    except (OSError, UnidentifiedImageError, ValueError) as exc:
-        logger.debug(
-            "Failed to read image dimensions from %s: %s", file_path, exc
-        )
-        return None
-
-    if (
-        not isinstance(width, int)
-        or not isinstance(height, int)
-        or width <= 0
-        or height <= 0
-    ):
-        return None
-
-    return {"kind": "image", "width": width, "height": height}

app/assets/services/ingest.py

@@ -17,11 +17,9 @@ from app.assets.database.queries import (
     get_reference_by_file_path,
     get_reference_tags,
     get_or_create_reference,
-    list_references_by_asset_id,
     reference_exists,
     remove_missing_tag_for_asset_id,
     set_reference_metadata,
-    set_reference_system_metadata,
     set_reference_tags,
     update_asset_hash_and_mime,
     upsert_asset,
@@ -31,11 +29,9 @@ from app.assets.database.queries import (
 from app.assets.helpers import get_utc_now, normalize_tags
 from app.assets.services.bulk_ingest import batch_insert_seed_assets
 from app.assets.services.file_utils import get_size_and_mtime_ns
-from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.path_utils import (
-    compute_loader_path,
+    compute_relative_filename,
     get_name_and_tags_from_asset_path,
-    get_path_derived_tags_from_path,
     resolve_destination_from_tags,
     validate_path_within_base,
 )
@@ -92,7 +88,6 @@ def _ingest_file_from_path(
             name=info_name or os.path.basename(locator),
             mtime_ns=mtime_ns,
             owner_id=owner_id,
-            loader_path=compute_loader_path(locator),
         )
 
         # Get the reference we just created/updated
@@ -103,32 +98,17 @@ def _ingest_file_from_path(
             if preview_id and ref.preview_id != preview_id:
                 ref.preview_id = preview_id
 
-            try:
-                backend_tags = get_path_derived_tags_from_path(locator)
-            except ValueError:
-                backend_tags = []
-            caller_tags = normalize_tags(tags)
-            backend_tags = normalize_tags(backend_tags)
-            all_tags = normalize_tags([*caller_tags, *backend_tags])
-            if all_tags:
+            norm = normalize_tags(list(tags))
+            if norm:
                 if require_existing_tags:
-                    validate_tags_exist(session, all_tags)
-                if backend_tags:
-                    add_tags_to_reference(
-                        session,
-                        reference_id=reference_id,
-                        tags=backend_tags,
-                        origin="automatic",
-                        create_if_missing=not require_existing_tags,
-                    )
-                if caller_tags:
-                    add_tags_to_reference(
-                        session,
-                        reference_id=reference_id,
-                        tags=caller_tags,
-                        origin=tag_origin,
-                        create_if_missing=not require_existing_tags,
-                    )
+                    validate_tags_exist(session, norm)
+                add_tags_to_reference(
+                    session,
+                    reference_id=reference_id,
+                    tags=norm,
+                    origin=tag_origin,
+                    create_if_missing=not require_existing_tags,
+                )
 
             _update_metadata_with_filename(
                 session,
@@ -138,14 +118,6 @@ def _ingest_file_from_path(
                 user_metadata=user_metadata,
             )
 
-            _maybe_store_image_dimensions(
-                session,
-                reference_id=reference_id,
-                file_path=locator,
-                mime_type=mime_type,
-                current_system_metadata=ref.system_metadata,
-            )
-
         try:
             remove_missing_tag_for_asset_id(session, asset_id=asset.id)
         except Exception:
@@ -245,7 +217,7 @@ def ingest_existing_file(
             "mtime_ns": mtime_ns,
             "info_name": name,
             "tags": tags,
-            "fname": compute_loader_path(abs_path),
+            "fname": os.path.basename(abs_path),
             "metadata": None,
             "hash": None,
             "mime_type": mime_type,
@@ -305,7 +277,7 @@ def _register_existing_asset(
             return result
 
         new_meta = dict(user_metadata)
-        computed_filename = compute_loader_path(ref.file_path) if ref.file_path else None
+        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
         if computed_filename:
             new_meta["filename"] = computed_filename
 
@@ -316,13 +288,6 @@ def _register_existing_asset(
                 user_metadata=new_meta,
             )
 
-        _backfill_image_dimensions_from_siblings(
-            session,
-            asset_id=asset.id,
-            new_reference_id=ref.id,
-            current_system_metadata=ref.system_metadata,
-        )
-
         if tags is not None:
             set_reference_tags(
                 session,
@@ -352,7 +317,7 @@ def _update_metadata_with_filename(
     current_metadata: dict | None,
     user_metadata: dict[str, Any],
 ) -> None:
-    computed_filename = compute_loader_path(file_path) if file_path else None
+    computed_filename = compute_relative_filename(file_path) if file_path else None
 
     current_meta = current_metadata or {}
     new_meta = dict(current_meta)
@@ -369,87 +334,6 @@ def _update_metadata_with_filename(
         )
 
 
-_IMAGE_DIMENSION_KEYS = ("kind", "width", "height")
-
-
-def _maybe_store_image_dimensions(
-    session: Session,
-    reference_id: str,
-    file_path: str,
-    mime_type: str | None,
-    current_system_metadata: dict | None,
-) -> None:
-    """Populate ``kind``/``width``/``height`` on system_metadata for image refs.
-
-    Non-image MIME types are a no-op. Pre-existing keys (e.g. enricher-written
-    safetensors metadata, download provenance) are preserved by merge.
-    """
-    if not mime_type or not mime_type.startswith("image/"):
-        return
-
-    dims = extract_image_dimensions(file_path, mime_type=mime_type)
-    if not dims:
-        return
-
-    current = current_system_metadata or {}
-    merged = dict(current)
-    merged.update(dims)
-    if merged != current:
-        set_reference_system_metadata(
-            session,
-            reference_id=reference_id,
-            system_metadata=merged,
-        )
-
-
-def _backfill_image_dimensions_from_siblings(
-    session: Session,
-    asset_id: str,
-    new_reference_id: str,
-    current_system_metadata: dict | None,
-) -> None:
-    """Copy image dimension keys from any sibling reference of the same asset.
-
-    The from-hash path doesn't read the file bytes, so dimensions can't be
-    extracted there directly. When another reference of the same asset already
-    carries image dimensions, copy them onto the new reference so consumers
-    see consistent metadata regardless of how the asset was registered.
-
-    Best-effort: missing siblings, non-image siblings, or absent dimension
-    keys leave the target reference unchanged.
-    """
-    current = current_system_metadata or {}
-    if current.get("kind") == "image" and "width" in current and "height" in current:
-        return
-
-    for sibling in list_references_by_asset_id(session, asset_id):
-        if sibling.id == new_reference_id:
-            continue
-        meta = sibling.system_metadata or {}
-        if meta.get("kind") != "image":
-            continue
-        width = meta.get("width")
-        height = meta.get("height")
-        if (
-            type(width) is not int
-            or type(height) is not int
-            or width <= 0
-            or height <= 0
-        ):
-            continue
-        merged = dict(current)
-        merged["kind"] = "image"
-        merged["width"] = width
-        merged["height"] = height
-        if merged != current:
-            set_reference_system_metadata(
-                session,
-                reference_id=new_reference_id,
-                system_metadata=merged,
-            )
-        return
-
-
 def _sanitize_filename(name: str | None, fallback: str) -> str:
     n = os.path.basename((name or "").strip() or fallback)
     return n if n else fallback
@@ -491,10 +375,6 @@ def upload_from_temp_path(
         existing = get_asset_by_hash(session, asset_hash=asset_hash)
 
     if existing is not None:
-        # Once content is already known, duplicate byte uploads are treated as
-        # reference-only creation. Request tags are labels only here: do not
-        # require upload destination tags, do not move bytes, and do not
-        # synthesize path-derived classification or uploaded provenance.
         with contextlib.suppress(Exception):
             if temp_path and os.path.exists(temp_path):
                 os.remove(temp_path)
@@ -556,7 +436,7 @@ def upload_from_temp_path(
         owner_id=owner_id,
         preview_id=preview_id,
         user_metadata=user_metadata or {},
-        tags=[*(tags or []), "uploaded"],
+        tags=tags,
         tag_origin="manual",
         require_existing_tags=False,
     )
@@ -590,19 +470,15 @@ def register_file_in_place(
 ) -> UploadResult:
     """Register an already-saved file in the asset database without moving it.
 
-    This helper is used by upload paths that have already written bytes before
-    registering the file, so it records the same ``uploaded`` tag as the
-    multipart byte-upload path.
-
-    Tags are derived from trusted filesystem classification and merged with any
-    caller-provided tags, matching the behavior of the scanner.
+    Tags are derived from the filesystem path (root category + subfolder names),
+    merged with any caller-provided tags, matching the behavior of the scanner.
     If the path is not under a known root, only the caller-provided tags are used.
     """
     try:
         _, path_tags = get_name_and_tags_from_asset_path(abs_path)
     except ValueError:
         path_tags = []
-    merged_tags = normalize_tags([*path_tags, *tags, "uploaded"])
+    merged_tags = normalize_tags([*path_tags, *tags])
 
     try:
         digest, _ = hashing.compute_blake3_hash(abs_path)

app/assets/services/metadata_extract.py

@@ -4,6 +4,7 @@ Tier 1: Filesystem metadata (zero parsing)
 Tier 2: Safetensors header metadata (fast JSON read only)
 """
 
+from __future__ import annotations
 
 import json
 import logging

app/assets/services/path_utils.py

@@ -3,66 +3,59 @@ from pathlib import Path
 from typing import Literal
 
 import folder_paths
+from app.assets.helpers import normalize_tags
 
 
-_NON_MODEL_FOLDER_NAMES = frozenset({"configs", "custom_nodes"})
-_KNOWN_SUBFOLDER_TAGS = frozenset({"3d", "pasted", "painter", "threed", "webcam"})
+_NON_MODEL_FOLDER_NAMES = frozenset({"custom_nodes"})
 
 
-def get_comfy_models_folders() -> list[tuple[str, list[str], set[str]]]:
-    """Build list of (folder_name, base_paths[], extensions) for all model locations.
+def get_comfy_models_folders() -> list[tuple[str, list[str]]]:
+    """Build list of (folder_name, base_paths[]) for all model locations.
 
     Includes every category registered in folder_names_and_paths,
     regardless of whether its paths are under the main models_dir,
-    but excludes non-model entries like configs and custom_nodes.
-
-    An empty extensions set means the category accepts any extension,
-    matching folder_paths.filter_files_extensions semantics.
+    but excludes non-model entries like custom_nodes.
     """
-    targets: list[tuple[str, list[str], set[str]]] = []
+    targets: list[tuple[str, list[str]]] = []
     for name, values in folder_paths.folder_names_and_paths.items():
         if name in _NON_MODEL_FOLDER_NAMES:
             continue
-        paths, exts = values[0], values[1]
+        paths, _exts = values[0], values[1]
         if paths:
-            targets.append((name, paths, set(exts)))
+            targets.append((name, paths))
     return targets
 
 
 def resolve_destination_from_tags(tags: list[str]) -> tuple[str, list[str]]:
-    """Validates and maps upload routing tags -> (base_dir, subdirs_for_fs).
-
-    The request tags are only used to choose the write destination. Extra tags
-    remain labels; they do not become path components or trusted classification.
-    """
-    destination_roles = [t for t in tags if t in {"input", "models", "output"}]
-    if len(destination_roles) != 1:
-        raise ValueError("uploads require exactly one destination role: input, models, or output")
-
-    root = destination_roles[0]
+    """Validates and maps tags -> (base_dir, subdirs_for_fs)"""
+    if not tags:
+        raise ValueError("tags must not be empty")
+    root = tags[0].lower()
     if root == "models":
-        model_type_tags = [t for t in tags if t.startswith("model_type:")]
-        if len(model_type_tags) != 1:
-            raise ValueError("models uploads require exactly one model_type:<folder_name> tag")
-        folder_name = model_type_tags[0].split(":", 1)[1]
-        if not folder_name:
-            raise ValueError("models uploads require exactly one model_type:<folder_name> tag")
-        model_folder_paths = {
-            name: paths for name, paths, _exts in get_comfy_models_folders()
-        }
+        if len(tags) < 2:
+            raise ValueError("at least two tags required for model asset")
         try:
-            bases = model_folder_paths[folder_name]
+            bases = folder_paths.folder_names_and_paths[tags[1]][0]
         except KeyError:
-            raise ValueError(f"unknown model category '{folder_name}'")
+            raise ValueError(f"unknown model category '{tags[1]}'")
         if not bases:
-            raise ValueError(f"no base path configured for category '{folder_name}'")
+            raise ValueError(f"no base path configured for category '{tags[1]}'")
         base_dir = os.path.abspath(bases[0])
+        raw_subdirs = tags[2:]
     elif root == "input":
         base_dir = os.path.abspath(folder_paths.get_input_directory())
-    else:
+        raw_subdirs = tags[1:]
+    elif root == "output":
         base_dir = os.path.abspath(folder_paths.get_output_directory())
+        raw_subdirs = tags[1:]
+    else:
+        raise ValueError(f"unknown root tag '{tags[0]}'; expected 'models', 'input', or 'output'")
+    _sep_chars = frozenset(("/", "\\", os.sep))
+    for i in raw_subdirs:
+        if i in (".", "..") or _sep_chars & set(i):
+            raise ValueError("invalid path component in tags")
 
-    return base_dir, []
+    return base_dir, raw_subdirs if raw_subdirs else []
 
 
 def validate_path_within_base(candidate: str, base: str) -> None:
@@ -72,79 +65,14 @@ def validate_path_within_base(candidate: str, base: str) -> None:
         raise ValueError("destination escapes base directory")
 
 
-def _compute_relative_path(child: str, parent: str) -> str:
-    rel = os.path.relpath(os.path.abspath(child), os.path.abspath(parent))
-    if rel == ".":
-        return ""
-    return rel.replace(os.sep, "/")
-
-
-def _is_relative_to(child: str, parent: str) -> bool:
-    return Path(os.path.abspath(child)).is_relative_to(os.path.abspath(parent))
-
-
-def compute_asset_response_paths(file_path: str) -> tuple[str, str | None] | None:
-    """Return (logical_path, display_name) for a file path.
-
-    ``logical_path`` is the internal namespaced storage locator (e.g.
-    ``models/checkpoints/foo/bar.safetensors``); ``display_name`` is the
-    human-facing label below that namespace, served on Asset responses. These
-    are storage locators, not model-loader namespaces. Registered model-folder
-    membership is represented by backend tags such as
-    ``model_type:<folder_name>``; these paths only use known storage roots.
+def compute_relative_filename(file_path: str) -> str | None:
     """
-    fp_abs = os.path.abspath(file_path)
-    candidates: list[tuple[int, int, str, str]] = []
-
-    for order, (namespace, base) in enumerate(
-        (
-            ("input", folder_paths.get_input_directory()),
-            ("output", folder_paths.get_output_directory()),
-            ("temp", folder_paths.get_temp_directory()),
-            ("models", getattr(folder_paths, "models_dir", "")),
-        )
-    ):
-        if not base:
-            continue
-        base_abs = os.path.abspath(base)
-        if _is_relative_to(fp_abs, base_abs):
-            candidates.append((len(base_abs), -order, namespace, base_abs))
-
-    if not candidates:
-        return None
-
-    _base_len, _order, namespace, base = max(candidates)
-    rel = _compute_relative_path(fp_abs, base)
-    public_path = f"{namespace}/{rel}" if rel else namespace
-    return public_path, rel or None
-
-
-def compute_display_name(file_path: str) -> str | None:
-    """Return the asset's `display_name`, or None for unknown paths."""
-    result = compute_asset_response_paths(file_path)
-    return result[1] if result else None
-
-
-def compute_logical_path(file_path: str) -> str | None:
-    """Return the internal namespaced storage locator, or None for unknown paths."""
-    result = compute_asset_response_paths(file_path)
-    return result[0] if result else None
-
-
-def compute_loader_path(file_path: str) -> str | None:
-    """
-    Return the asset's in-root loader path: the path relative to the last
-    well-known folder (the model category), using forward slashes, eg:
+    Return the model's path relative to the last well-known folder (the model category),
+    using forward slashes, eg:
       /.../models/checkpoints/flux/123/flux.safetensors -> "flux/123/flux.safetensors"
       /.../models/text_encoders/clip_g.safetensors -> "clip_g.safetensors"
 
-    This is the value model loaders consume (the model category is dropped). It
-    is persisted as ``AssetReference.loader_path`` and served as the public
-    Asset response `loader_path` field. The human-facing `display_name` comes
-    from compute_asset_response_paths().
-
-    For input/output/temp paths the full path relative to that root is returned.
-    For paths outside any known root, returns None.
+    For non-model paths, returns None.
     """
     try:
         root_category, rel_path = get_asset_category_and_relative_path(file_path)
@@ -188,10 +116,9 @@ def get_asset_category_and_relative_path(
     def _compute_relative(child: str, parent: str) -> str:
         # Normalize relative path, stripping any leading ".." components
         # by anchoring to root (os.sep) then computing relpath back from it.
-        rel = os.path.relpath(
+        return os.path.relpath(
             os.path.join(os.sep, os.path.relpath(child, parent)), os.sep
         )
-        return "" if rel == "." else rel.replace(os.sep, "/")
 
     # 1) input
     input_base = os.path.abspath(folder_paths.get_input_directory())
@@ -209,14 +136,8 @@ def get_asset_category_and_relative_path(
         return "temp", _compute_relative(fp_abs, temp_base)
 
     # 4) models (check deepest matching base to avoid ambiguity)
-    ext = os.path.splitext(fp_abs)[1].lower()
     best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
-    for bucket, bases, extensions in get_comfy_models_folders():
-        # A bucket only lists files within its extension set (empty set
-        # accepts any extension), so a bucket that cannot load the file
-        # must not contribute a loader path.
-        if extensions and ext not in extensions:
-            continue
+    for bucket, bases in get_comfy_models_folders():
         for b in bases:
             base_abs = os.path.abspath(b)
             if not _check_is_within(fp_abs, base_abs):
@@ -228,111 +149,25 @@ def get_asset_category_and_relative_path(
     if best is not None:
         _, bucket, rel_inside = best
         combined = os.path.join(bucket, rel_inside)
-        normalized = os.path.relpath(os.path.join(os.sep, combined), os.sep)
-        return "models", normalized.replace(os.sep, "/")
+        return "models", os.path.relpath(os.path.join(os.sep, combined), os.sep)
 
     raise ValueError(
         f"Path is not within input, output, temp, or configured model bases: {file_path}"
     )
 
 
-def get_backend_system_tags_from_path(path: str) -> list[str]:
-    """Return trusted backend tags derived from current filesystem facts.
-
-    The returned tags are only the backend-generated system tags: ``models``,
-    ``model_type:<folder_name>``, ``input``, ``output``, and ``temp``. Model
-    type tags are based on registered folder names, not path components.
-
-    A ``model_type:<folder_name>`` tag is only emitted when the file's
-    extension is accepted by that folder's registered extension set, so
-    categories sharing a base directory tag only the files they can
-    actually load. Files under a model base whose extension matches no
-    category still get the ``models`` tag.
-    """
-    fp_abs = os.path.abspath(path)
-    fp_path = Path(fp_abs)
-    tags: list[str] = []
-
-    def _add(tag: str) -> None:
-        if tag not in tags:
-            tags.append(tag)
-
-    for role, base in (
-        ("input", folder_paths.get_input_directory()),
-        ("output", folder_paths.get_output_directory()),
-        ("temp", folder_paths.get_temp_directory()),
-    ):
-        if fp_path.is_relative_to(os.path.abspath(base)):
-            _add(role)
-
-    ext = os.path.splitext(fp_abs)[1].lower()
-    model_types: list[str] = []
-    under_models_base = False
-    for folder_name, bases, extensions in get_comfy_models_folders():
-        for base in bases:
-            if fp_path.is_relative_to(os.path.abspath(base)):
-                under_models_base = True
-                # Empty set accepts any extension, matching
-                # folder_paths.filter_files_extensions semantics.
-                if not extensions or ext in extensions:
-                    model_types.append(folder_name)
-                break
-
-    if under_models_base:
-        _add("models")
-    for folder_name in model_types:
-        _add(f"model_type:{folder_name}")
-
-    if not tags:
-        raise ValueError(
-            f"Path is not within input, output, temp, or configured model bases: {path}"
-        )
-    return tags
-
-
-def get_known_subfolder_tags(subfolder: str | None) -> list[str]:
-    """Return tags for known UI/input subfolder names."""
-    if subfolder in _KNOWN_SUBFOLDER_TAGS:
-        return [subfolder]
-    return []
-
-
-def get_known_input_subfolder_tags_from_path(path: str) -> list[str]:
-    """Return known input-layout tags for files in canonical input subfolders.
-
-    These are compatibility tags for current UI-origin input directories such as
-    ``pasted`` and ``webcam``. They are intentionally narrow: only files directly
-    inside a known top-level input directory receive the matching tag.
-    """
-    fp_abs = os.path.abspath(path)
-    input_base = os.path.abspath(folder_paths.get_input_directory())
-    if not Path(fp_abs).is_relative_to(input_base):
-        return []
-
-    rel = os.path.relpath(fp_abs, input_base)
-    parts = Path(rel).parts
-    if len(parts) == 2:
-        return get_known_subfolder_tags(parts[0])
-    return []
-
-
-def get_path_derived_tags_from_path(path: str) -> list[str]:
-    """Return all backend-derived tags for an asset path."""
-    tags = get_backend_system_tags_from_path(path)
-    for tag in get_known_input_subfolder_tags_from_path(path):
-        if tag not in tags:
-            tags.append(tag)
-    return tags
-
-
 def get_name_and_tags_from_asset_path(file_path: str) -> tuple[str, list[str]]:
     """Return (name, tags) derived from a filesystem path.
 
     - name: base filename with extension
-    - tags: backend-derived tags from root/model classification and known input
-      subfolder layout conventions
+    - tags: [root_category] + parent folder names in order
 
     Raises:
         ValueError: path does not belong to any known root.
     """
-    return Path(file_path).name, get_path_derived_tags_from_path(file_path)
+    root_category, some_path = get_asset_category_and_relative_path(file_path)
+    p = Path(some_path)
+    parent_parts = [
+        part for part in p.parent.parts if part not in (".", "..", p.anchor)
+    ]
+    return p.name, list(dict.fromkeys(normalize_tags([root_category, *parent_parts])))

app/assets/services/schemas.py

@@ -25,7 +25,6 @@ class ReferenceData:
     preview_id: str | None
     created_at: datetime
     updated_at: datetime
-    loader_path: str | None = None
     system_metadata: dict[str, Any] | None = None
     job_id: str | None = None
     last_access_time: datetime | None = None
@@ -57,6 +56,7 @@ class IngestResult:
 
 class TagUsage(NamedTuple):
     name: str
+    tag_type: str
     count: int
 
 
@@ -71,7 +71,6 @@ class AssetSummaryData:
 class ListAssetsResult:
     items: list[AssetSummaryData]
     total: int
-    next_cursor: str | None = None
 
 
 @dataclass(frozen=True)
@@ -94,7 +93,6 @@ def extract_reference_data(ref: AssetReference) -> ReferenceData:
         id=ref.id,
         name=ref.name,
         file_path=ref.file_path,
-        loader_path=ref.loader_path,
         user_metadata=ref.user_metadata,
         preview_id=ref.preview_id,
         system_metadata=ref.system_metadata,

app/assets/services/tagging.py

@@ -75,7 +75,7 @@ def list_tags(
             owner_id=owner_id,
         )
 
-    return [TagUsage(name, count) for name, count in rows], total
+    return [TagUsage(name, tag_type, count) for name, tag_type, count in rows], total
 
 
 def list_tag_histogram(

app/custom_node_manager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import folder_paths
 import glob

app/database/db.py

@@ -4,8 +4,7 @@ import shutil
 from app.logger import log_startup_warning
 from utils.install_util import get_missing_requirements_message
 from filelock import FileLock, Timeout
-# Import the module so tests that reload comfy.cli_args see the live object.
-import comfy.cli_args
+from comfy.cli_args import args
 
 _DB_AVAILABLE = False
 Session = None
@@ -22,7 +21,6 @@ try:
 
     from app.database.models import Base
     import app.assets.database.models  # noqa: F401 — register models with Base.metadata
-    import app.model_downloader.database.models  # noqa: F401 — register models with Base.metadata
 
     _DB_AVAILABLE = True
 except ImportError as e:
@@ -59,13 +57,13 @@ def get_alembic_config():
 
     config = Config(config_path)
     config.set_main_option("script_location", scripts_path)
-    config.set_main_option("sqlalchemy.url", comfy.cli_args.args.database_url)
+    config.set_main_option("sqlalchemy.url", args.database_url)
 
     return config
 
 
 def get_db_path():
-    url = comfy.cli_args.args.database_url
+    url = args.database_url
     if url.startswith("sqlite:///"):
         return url.split("///")[1]
     else:
@@ -99,7 +97,7 @@ def _is_memory_db(db_url):
 
 
 def init_db():
-    db_url = comfy.cli_args.args.database_url
+    db_url = args.database_url
     logging.debug(f"Database URL: {db_url}")
 
     if _is_memory_db(db_url):

app/frontend_management.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import argparse
 import logging
 import os
@@ -26,7 +27,7 @@ def frontend_install_warning_message():
     return f"""
 {get_missing_requirements_message()}
 
-The ComfyUI frontend is shipped in a pip package so it needs to be updated separately from the ComfyUI code.
+This error is happening because the ComfyUI frontend is no longer shipped as part of the main repo but as a pip package instead.
 """.strip()
 
 def parse_version(version: str) -> tuple[int, int, int]:
@@ -37,63 +38,40 @@ def is_valid_version(version: str) -> bool:
     pattern = r"^(\d+)\.(\d+)\.(\d+)$"
     return bool(re.match(pattern, version))
 
+def get_installed_frontend_version():
+    """Get the currently installed frontend package version."""
+    frontend_version_str = version("comfyui-frontend-package")
+    return frontend_version_str
+
+
 def get_required_frontend_version():
     return get_required_packages_versions().get("comfyui-frontend-package", None)
 
 
-COMFY_PACKAGE_VERSIONS = []
-def get_comfy_package_versions():
-    """List installed/required versions for every comfy* package in requirements.txt."""
-    if COMFY_PACKAGE_VERSIONS:
-        return COMFY_PACKAGE_VERSIONS.copy()
-    out = COMFY_PACKAGE_VERSIONS
-    for name, required in (get_required_packages_versions() or {}).items():
-        if not name.startswith("comfy"):
-            continue
-        try:
-            installed = version(name)
-        except Exception:
-            installed = None
-        out.append({"name": name, "installed": installed, "required": required})
-    return out.copy()
+def check_frontend_version():
+    """Check if the frontend version is up to date."""
 
-
-def check_comfy_packages_versions():
-    """Warn for every comfy* package whose installed version is below requirements.txt."""
-    from packaging.version import InvalidVersion, parse as parse_pep440
-    outdated_packages = []
-
-    for pkg in get_comfy_package_versions():
-        installed_str = pkg["installed"]
-        required_str = pkg["required"]
-        if not installed_str or not required_str:
-            continue
-        try:
-            outdated = parse_pep440(installed_str) < parse_pep440(required_str)
-        except InvalidVersion as e:
-            logging.error(f"Failed to check {pkg['name']} version: {e}")
-            continue
-        if outdated:
-            outdated_packages.append((pkg["name"], installed_str, required_str))
-        else:
-            logging.info("{} version: {}".format(pkg["name"], installed_str))
-
-    if outdated_packages:
-        package_warnings = "\n".join(
-            f"Installed {name} version {installed} is lower than the recommended version {required}."
-            for name, installed, required in outdated_packages
-        )
-        app.logger.log_startup_warning(
-            f"""
+    try:
+        frontend_version_str = get_installed_frontend_version()
+        frontend_version = parse_version(frontend_version_str)
+        required_frontend_str = get_required_frontend_version()
+        required_frontend = parse_version(required_frontend_str)
+        if frontend_version < required_frontend:
+            app.logger.log_startup_warning(
+                f"""
 ________________________________________________________________________
 WARNING WARNING WARNING WARNING WARNING
 
-{package_warnings}
+Installed frontend version {".".join(map(str, frontend_version))} is lower than the recommended version {".".join(map(str, required_frontend))}.
 
-{get_missing_requirements_message()}
+{frontend_install_warning_message()}
 ________________________________________________________________________
 """.strip()
-        )
+            )
+        else:
+            logging.info("ComfyUI frontend version: {}".format(frontend_version_str))
+    except Exception as e:
+        logging.error(f"Failed to check frontend version: {e}")
 
 
 REQUEST_TIMEOUT = 10  # seconds
@@ -223,11 +201,6 @@ class FrontendManager:
     def get_required_templates_version(cls) -> str:
         return get_required_packages_versions().get("comfyui-workflow-templates", None)
 
-    @classmethod
-    def get_comfy_package_versions(cls):
-        """List installed/required versions for every comfy* package in requirements.txt."""
-        return get_comfy_package_versions()
-
     @classmethod
     def default_frontend_path(cls) -> str:
         try:
@@ -368,7 +341,7 @@ comfyui-workflow-templates is not installed.
             main error source might be request timeout or invalid URL.
         """
         if version_string == DEFAULT_VERSION_STRING:
-            check_comfy_packages_versions()
+            check_frontend_version()
             return cls.default_frontend_path()
 
         repo_owner, repo_name, version = cls.parse_version_string(version_string)
@@ -430,7 +403,7 @@ comfyui-workflow-templates is not installed.
         except Exception as e:
             logging.error("Failed to initialize frontend: %s", e)
             logging.info("Falling back to the default frontend.")
-            check_comfy_packages_versions()
+            check_frontend_version()
             return cls.default_frontend_path()
     @classmethod
     def template_asset_handler(cls):

app/logger.py

@@ -5,40 +5,6 @@ import logging
 import sys
 import threading
 
-ANSI_NAMED_COLORS = {
-    'black':   '\033[30m',
-    'red':     '\033[31m',
-    'green':   '\033[32m',
-    'yellow':  '\033[33m',
-    'blue':    '\033[34m',
-    'magenta': '\033[35m',
-    'cyan':    '\033[36m',
-    'white':   '\033[37m',
-}
-
-ANSI_LEVEL_COLORS = {
-    'DEBUG':    ANSI_NAMED_COLORS['cyan'],
-    'INFO':     ANSI_NAMED_COLORS['green'],
-    'WARNING':  ANSI_NAMED_COLORS['yellow'],
-    'ERROR':    ANSI_NAMED_COLORS['red'],
-    'CRITICAL': ANSI_NAMED_COLORS['magenta'],
-}
-
-ANSI_RESET = '\033[0m'
-ANSI_BOLD  = '\033[1m'
-
-
-class ColoredFormatter(logging.Formatter):
-    def format(self, record):
-        color = ANSI_LEVEL_COLORS.get(record.levelname, '')
-        bold  = ANSI_BOLD if record.levelno >= logging.WARNING else ''
-        level_tag = f"{bold}{color}[{record.levelname}]{ANSI_RESET} "
-        message = super().format(record)
-        line_color = ANSI_NAMED_COLORS.get(getattr(record, 'color', ''), '')
-        if line_color:
-            return f"{level_tag}{line_color}{message}{ANSI_RESET}"
-        return level_tag + message
-
 logs = None
 stdout_interceptor = None
 stderr_interceptor = None
@@ -102,10 +68,8 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
     logger = logging.getLogger()
     logger.setLevel(log_level)
 
-    formatter = ColoredFormatter("%(message)s")
-
     stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(formatter)
+    stream_handler.setFormatter(logging.Formatter("%(message)s"))
 
     if use_stdout:
         # Only errors and critical to stderr
@@ -113,7 +77,7 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
 
         # Lesser to stdout
         stdout_handler = logging.StreamHandler(sys.stdout)
-        stdout_handler.setFormatter(formatter)
+        stdout_handler.setFormatter(logging.Formatter("%(message)s"))
         stdout_handler.addFilter(lambda record: record.levelno < logging.ERROR)
         logger.addHandler(stdout_handler)
 

app/model_downloader/api/routes.py

@@ -1,202 +0,0 @@
-"""aiohttp routes for the download manager.
-
-Endpoint surface (all under ``/api/download``), mirroring the response
-envelope used by ``app/assets/api/routes.py``:
-
-  POST   /api/download/enqueue
-  GET    /api/download
-  POST   /api/download/availability
-  POST   /api/download/clear
-  GET    /api/download/auth
-  POST   /api/download/auth/{provider}/login
-  POST   /api/download/auth/{provider}/logout
-  GET    /api/download/{id}
-  DELETE /api/download/{id}
-  POST   /api/download/{id}/pause
-  POST   /api/download/{id}/resume
-  POST   /api/download/{id}/cancel
-  POST   /api/download/{id}/priority
-
-Note on ordering: the static ``auth`` routes are registered before the dynamic
-``/api/download/{id}`` route so a request to ``.../auth`` is not captured as
-``id == "auth"``.
-"""
-
-from __future__ import annotations
-
-import json
-
-from aiohttp import web
-from pydantic import BaseModel, ValidationError
-
-from app.model_downloader.api import schemas_in, schemas_out
-from app.model_downloader.auth.oauth import LoginInProgress, OAuthNotConfigured
-from app.model_downloader.auth.providers import PROVIDERS
-from app.model_downloader.auth.store import AUTH_STORE
-from app.model_downloader.manager import DOWNLOAD_MANAGER, DownloadError
-
-ROUTES = web.RouteTableDef()
-
-
-def register_routes(app: web.Application) -> None:
-    """Wire the download-manager routes into the running aiohttp app."""
-    app.add_routes(ROUTES)
-
-
-# ----- envelope helpers (same shape as app/assets/api/routes.py) -----
-
-
-def _error(status: int, code: str, message: str, details: dict | None = None) -> web.Response:
-    return web.json_response(
-        {"error": {"code": code, "message": message, "details": details or {}}},
-        status=status,
-    )
-
-
-def _ok(payload, status: int = 200) -> web.Response:
-    return web.json_response(payload, status=status)
-
-
-async def _parse(request: web.Request, model: type[BaseModel]):
-    try:
-        raw = await request.json()
-    except json.JSONDecodeError:
-        return _error(400, "INVALID_JSON", "Request body must be valid JSON.")
-    try:
-        return model.model_validate(raw)
-    except ValidationError as ve:
-        return _error(400, "INVALID_BODY", "Validation failed.", {"errors": json.loads(ve.json())})
-
-
-def _from_download_error(e: DownloadError) -> web.Response:
-    return _error(e.http_status, e.code, e.message)
-
-
-# ----- downloads: collection + enqueue + availability -----
-
-
-@ROUTES.post("/api/download/enqueue")
-async def enqueue(request: web.Request) -> web.Response:
-    parsed = await _parse(request, schemas_in.EnqueueRequest)
-    if isinstance(parsed, web.Response):
-        return parsed
-    try:
-        download_id = await DOWNLOAD_MANAGER.enqueue(
-            parsed.url,
-            parsed.model_id,
-            priority=parsed.priority,
-            expected_sha256=parsed.expected_sha256,
-            allow_any_extension=parsed.allow_any_extension,
-        )
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"download_id": download_id, "accepted": True}, status=202)
-
-
-@ROUTES.get("/api/download")
-async def list_downloads(request: web.Request) -> web.Response:
-    return _ok({"downloads": await DOWNLOAD_MANAGER.list()})
-
-
-@ROUTES.post("/api/download/availability")
-async def availability(request: web.Request) -> web.Response:
-    parsed = await _parse(request, schemas_in.AvailabilityRequest)
-    if isinstance(parsed, web.Response):
-        return parsed
-    return _ok({"models": await DOWNLOAD_MANAGER.availability(parsed.models)})
-
-
-@ROUTES.post("/api/download/clear")
-async def clear(request: web.Request) -> web.Response:
-    deleted = await DOWNLOAD_MANAGER.clear()
-    return _ok({"deleted": deleted})
-
-
-# ----- auth (OAuth login + env-key status) — must precede /{id} -----
-
-
-@ROUTES.get("/api/download/auth")
-async def auth_status(request: web.Request) -> web.Response:
-    return _ok({"providers": schemas_out.auth_status()})
-
-
-@ROUTES.post("/api/download/auth/{provider}/login")
-async def auth_login(request: web.Request) -> web.Response:
-    provider = PROVIDERS.get(request.match_info["provider"])
-    if provider is None:
-        return _error(400, "UNKNOWN_PROVIDER", "No such auth provider.")
-    try:
-        authorize_url = await AUTH_STORE.begin_login(provider)
-    except OAuthNotConfigured as e:
-        return _error(400, "OAUTH_NOT_CONFIGURED", str(e))
-    except LoginInProgress as e:
-        return _error(409, "LOGIN_IN_PROGRESS", str(e))
-    return _ok({"authorize_url": authorize_url})
-
-
-@ROUTES.post("/api/download/auth/{provider}/logout")
-async def auth_logout(request: web.Request) -> web.Response:
-    provider = PROVIDERS.get(request.match_info["provider"])
-    if provider is None:
-        return _error(400, "UNKNOWN_PROVIDER", "No such auth provider.")
-    AUTH_STORE.clear(provider.name)
-    return _ok({"logged_out": True})
-
-
-# ----- single download by id (dynamic; registered last) -----
-
-
-@ROUTES.get("/api/download/{id}")
-async def get_download(request: web.Request) -> web.Response:
-    view = await DOWNLOAD_MANAGER.status(request.match_info["id"])
-    if view is None:
-        return _error(404, "NOT_FOUND", "No such download.")
-    return _ok(view)
-
-
-@ROUTES.delete("/api/download/{id}")
-async def delete_download(request: web.Request) -> web.Response:
-    try:
-        await DOWNLOAD_MANAGER.delete(request.match_info["id"])
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"deleted": True})
-
-
-@ROUTES.post("/api/download/{id}/pause")
-async def pause(request: web.Request) -> web.Response:
-    try:
-        await DOWNLOAD_MANAGER.pause(request.match_info["id"])
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"ok": True})
-
-
-@ROUTES.post("/api/download/{id}/resume")
-async def resume(request: web.Request) -> web.Response:
-    try:
-        await DOWNLOAD_MANAGER.resume(request.match_info["id"])
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"ok": True})
-
-
-@ROUTES.post("/api/download/{id}/cancel")
-async def cancel(request: web.Request) -> web.Response:
-    try:
-        await DOWNLOAD_MANAGER.cancel(request.match_info["id"])
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"ok": True})
-
-
-@ROUTES.post("/api/download/{id}/priority")
-async def set_priority(request: web.Request) -> web.Response:
-    parsed = await _parse(request, schemas_in.PriorityRequest)
-    if isinstance(parsed, web.Response):
-        return parsed
-    try:
-        await DOWNLOAD_MANAGER.set_priority(request.match_info["id"], parsed.priority)
-    except DownloadError as e:
-        return _from_download_error(e)
-    return _ok({"ok": True})

app/model_downloader/api/schemas_in.py

@@ -1,46 +0,0 @@
-"""Request schemas for the download manager API.
-
-Pydantic enforces shape at the boundary; handlers operate only on validated
-values past that point.
-"""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class EnqueueRequest(BaseModel):
-    url: str
-    model_id: str
-    priority: int = 0
-    expected_sha256: Optional[str] = None
-    allow_any_extension: bool = False
-
-    @field_validator("url")
-    @classmethod
-    def _strip_url(cls, v: str) -> str:
-        return v.strip()
-
-
-class PriorityRequest(BaseModel):
-    priority: int
-
-
-class AvailabilityRequest(BaseModel):
-    """``{model_id: url}`` — the URLs declared in the workflow JSON."""
-
-    models: dict[str, str] = Field(default_factory=dict)
-
-    @field_validator("models")
-    @classmethod
-    def _strip_urls(cls, v: dict[str, str]) -> dict[str, str]:
-        return {k: url.strip() for k, url in v.items()}
-
-
-__all__ = [
-    "EnqueueRequest",
-    "PriorityRequest",
-    "AvailabilityRequest",
-]

app/model_downloader/api/schemas_out.py

@@ -1,15 +0,0 @@
-"""Response helpers for the download manager API.
-
-The download/status read models are plain dicts produced by the manager. This
-module serializes the per-provider auth status (never a token) for the API.
-"""
-
-from __future__ import annotations
-
-from app.model_downloader.auth.providers import PROVIDERS
-from app.model_downloader.auth.store import AUTH_STORE
-
-
-def auth_status() -> list[dict]:
-    """Per-provider auth status — never includes a token."""
-    return [AUTH_STORE.status(p) for p in PROVIDERS.values()]

app/model_downloader/auth/oauth.py

@@ -1,269 +0,0 @@
-"""Generic OAuth 2.0 PKCE engine + transient loopback callback server.
-
-The flow, per provider:
-
-1. :func:`start_login_flow` builds a PKCE challenge, binds a loopback callback
-   server on ``127.0.0.1:<CALLBACK_PORT>`` at ``/callback/<provider>``, and
-   returns the provider's authorize URL for the user to open.
-2. The provider redirects the browser back to the loopback URL with a ``code``
-   and the ``state`` we generated. The server validates ``state``, exchanges the
-   code for a :class:`Token`, hands it to the ``deliver`` sink, and tears down.
-3. If no callback arrives within :data:`_LOGIN_TIMEOUT`, the server tears down.
-
-The callback runs on its own bare server, not ComfyUI's main server: the main
-server rejects cross-site navigations (``Sec-Fetch-Site: cross-site`` → 403),
-and an OAuth redirect from the provider is exactly such a navigation. The port
-is fixed because HuggingFace and Civitai require an exact registered
-``redirect_uri`` (port included); only one login runs at a time so the port
-never contends with itself.
-
-Only public PKCE clients are supported (no client secret). All outbound calls
-go to the provider's own authorize/token endpoints, strictly user-initiated.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import hashlib
-import logging
-import os
-import secrets
-import time
-from typing import Callable
-from urllib.parse import urlencode
-
-from aiohttp import web
-
-from app.model_downloader.auth.providers import Provider
-from app.model_downloader.auth.token_store import Token
-from app.model_downloader.net.session import get_session, ssl_context
-
-CALLBACK_HOST = "127.0.0.1"
-# Fixed loopback port for the OAuth redirect. Must match the redirect URI
-# registered on the provider's OAuth app; override in lockstep if you change it.
-CALLBACK_PORT = int(os.environ.get("COMFY_OAUTH_CALLBACK_PORT", "41954"))
-_LOGIN_TIMEOUT = 300.0  # seconds to wait for the browser callback
-
-# The auth tab is opened by the frontend via window.open, so window.close() is
-# allowed here; the visible text is the fallback when the browser blocks it.
-_SUCCESS_HTML = (
-    "<!doctype html><meta charset=utf-8><title>ComfyUI</title>"
-    "<p>Login successful. You can close this window and return to ComfyUI.</p>"
-    "<script>window.close()</script>"
-)
-
-# Token sink: called with the provider name and the exchanged Token.
-TokenSink = Callable[[str, Token], None]
-
-
-class OAuthError(Exception):
-    """A user-facing OAuth failure."""
-
-
-class OAuthNotConfigured(OAuthError):
-    """The provider has no public client id configured."""
-
-
-class LoginInProgress(OAuthError):
-    """A login flow for this provider is already running."""
-
-
-def _b64url(data: bytes) -> str:
-    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
-
-
-def _make_pkce() -> tuple[str, str]:
-    """Return ``(verifier, challenge)`` for the S256 PKCE method."""
-    verifier = _b64url(secrets.token_bytes(32))
-    challenge = _b64url(hashlib.sha256(verifier.encode("ascii")).digest())
-    return verifier, challenge
-
-
-def build_authorize_url(
-    provider: Provider, challenge: str, state: str, redirect_uri: str
-) -> str:
-    params = {
-        "response_type": "code",
-        "client_id": provider.client_id,
-        "redirect_uri": redirect_uri,
-        "scope": provider.scope,
-        "state": state,
-        "code_challenge": challenge,
-        "code_challenge_method": "S256",
-    }
-    return f"{provider.authorize_url}?{urlencode(params)}"
-
-
-def _token_from_payload(payload: dict) -> Token:
-    expires_in = payload.get("expires_in")
-    expires_at = int(time.time()) + int(expires_in) if expires_in else 0
-    return Token(
-        access_token=payload["access_token"],
-        refresh_token=payload.get("refresh_token"),
-        expires_at=expires_at,
-        token_type=payload.get("token_type", "Bearer"),
-        scope=payload.get("scope"),
-    )
-
-
-async def _post_token(provider: Provider, data: dict) -> Token:
-    session = await get_session()
-    resp = await session.post(
-        provider.token_url,
-        data=data,
-        headers={"Accept": "application/json"},
-        ssl=ssl_context(),
-    )
-    try:
-        if resp.status != 200:
-            body = await resp.text()
-            raise OAuthError(
-                f"{provider.name} token endpoint returned HTTP {resp.status}: {body[:200]}"
-            )
-        payload = await resp.json()
-    finally:
-        await resp.release()
-    if "access_token" not in payload:
-        raise OAuthError(f"{provider.name} token response missing access_token")
-    return _token_from_payload(payload)
-
-
-async def exchange_code(
-    provider: Provider, code: str, verifier: str, redirect_uri: str
-) -> Token:
-    return await _post_token(
-        provider,
-        {
-            "grant_type": "authorization_code",
-            "code": code,
-            "redirect_uri": redirect_uri,
-            "client_id": provider.client_id,
-            "code_verifier": verifier,
-        },
-    )
-
-
-async def refresh_access_token(provider: Provider, token: Token) -> Token:
-    if not token.refresh_token:
-        raise OAuthError(f"{provider.name} token is not refreshable")
-    refreshed = await _post_token(
-        provider,
-        {
-            "grant_type": "refresh_token",
-            "refresh_token": token.refresh_token,
-            "client_id": provider.client_id,
-        },
-    )
-    # Some providers omit a new refresh token on refresh; keep the old one.
-    if refreshed.refresh_token is None:
-        refreshed.refresh_token = token.refresh_token
-    return refreshed
-
-
-class _LoginFlow:
-    """A single in-flight login: owns the loopback server and PKCE state."""
-
-    def __init__(self, provider: Provider, deliver: TokenSink) -> None:
-        self.provider = provider
-        self.deliver = deliver
-        self.verifier, self.challenge = _make_pkce()
-        self.state = secrets.token_urlsafe(24)
-        self.redirect_uri = f"http://{CALLBACK_HOST}:{CALLBACK_PORT}/callback/{provider.name}"
-        self._runner: web.AppRunner | None = None
-        self._timeout_handle: asyncio.TimerHandle | None = None
-
-    async def start(self) -> str:
-        app = web.Application()
-        app.router.add_get("/callback/{provider}", self._handle_callback)
-        self._runner = web.AppRunner(app)
-        await self._runner.setup()
-        site = web.TCPSite(self._runner, CALLBACK_HOST, CALLBACK_PORT, reuse_address=True)
-        try:
-            await site.start()
-        except OSError as e:
-            await self._runner.cleanup()
-            self._runner = None
-            raise OAuthError(f"could not bind callback port {CALLBACK_PORT}: {e}")
-        loop = asyncio.get_running_loop()
-        self._timeout_handle = loop.call_later(
-            _LOGIN_TIMEOUT, lambda: asyncio.ensure_future(self._teardown())
-        )
-        return build_authorize_url(
-            self.provider, self.challenge, self.state, self.redirect_uri
-        )
-
-    async def _handle_callback(self, request: web.Request) -> web.Response:
-        if request.match_info.get("provider") != self.provider.name:
-            return web.Response(text="Unknown login.", content_type="text/plain", status=404)
-        error = request.query.get("error")
-        if error:
-            asyncio.ensure_future(self._teardown())
-            return web.Response(
-                text=f"Login failed: {error}", content_type="text/plain", status=400
-            )
-        if request.query.get("state") != self.state:
-            return web.Response(
-                text="Login failed: state mismatch.",
-                content_type="text/plain",
-                status=400,
-            )
-        code = request.query.get("code")
-        if not code:
-            return web.Response(
-                text="Login failed: no authorization code.",
-                content_type="text/plain",
-                status=400,
-            )
-        try:
-            token = await exchange_code(
-                self.provider, code, self.verifier, self.redirect_uri
-            )
-        except OAuthError as e:
-            logging.warning("[model_downloader] %s login failed: %s", self.provider.name, e)
-            asyncio.ensure_future(self._teardown())
-            return web.Response(
-                text=f"Login failed: {e}", content_type="text/plain", status=502
-            )
-        self.deliver(self.provider.name, token)
-        asyncio.ensure_future(self._teardown())
-        return web.Response(text=_SUCCESS_HTML, content_type="text/html")
-
-    async def _teardown(self) -> None:
-        _ACTIVE.pop(self.provider.name, None)
-        if self._timeout_handle is not None:
-            self._timeout_handle.cancel()
-            self._timeout_handle = None
-        if self._runner is not None:
-            try:
-                await self._runner.cleanup()
-            except Exception:
-                logging.debug("[model_downloader] callback server cleanup error", exc_info=True)
-            self._runner = None
-
-
-_ACTIVE: dict[str, _LoginFlow] = {}
-
-
-def login_in_progress(provider_name: str) -> bool:
-    return provider_name in _ACTIVE
-
-
-async def start_login_flow(provider: Provider, deliver: TokenSink) -> str:
-    """Begin a login flow and return the authorize URL to open in a browser.
-
-    Binds the fixed-port loopback callback server; only one login may run at a
-    time since that port is shared.
-    """
-    if not provider.client_id:
-        raise OAuthNotConfigured(
-            f"OAuth app not configured for {provider.name}; set "
-            f"{provider.client_id_env} or use an env API key."
-        )
-    if _ACTIVE:
-        active = next(iter(_ACTIVE))
-        raise LoginInProgress(f"A login for {active} is already in progress.")
-    flow = _LoginFlow(provider, deliver)
-    authorize_url = await flow.start()
-    _ACTIVE[provider.name] = flow
-    return authorize_url

app/model_downloader/auth/providers.py

@@ -1,87 +0,0 @@
-"""Provider registry for download authentication.
-
-A :class:`Provider` describes a hub that can authenticate downloads either from
-an environment API key or from an OAuth 2.0 access token. Both HuggingFace and
-Civitai are public PKCE clients, so no client secret is ever stored; the public
-``client_id`` is a placeholder overridable via env.
-"""
-
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass
-from urllib.parse import urlsplit
-
-
-def normalize_host(host: str) -> str:
-    """Lowercase, strip port, IDNA-encode."""
-    if not host:
-        return ""
-    host = host.strip()
-    if "://" in host:  # a full URL was pasted — extract just the host
-        host = urlsplit(host).hostname or ""
-    host = host.lower()
-    if host.startswith("[") and "]" in host:  # bracketed IPv6 literal
-        host = host[1 : host.index("]")]
-    elif host.count(":") == 1:  # host:port (not IPv6)
-        host = host.split(":", 1)[0]
-    try:
-        host = host.encode("idna").decode("ascii")
-    except (UnicodeError, ValueError):
-        pass
-    return host
-
-
-@dataclass(frozen=True)
-class Provider:
-    name: str
-    host: str
-    authorize_url: str
-    token_url: str
-    scope: str
-    # Env vars to try, in order, for a plain API key.
-    env_keys: tuple[str, ...]
-    # Env var overriding the public OAuth client id.
-    client_id_env: str
-    # Public PKCE client id. Empty means "not configured" until the env sets it.
-    default_client_id: str = ""
-
-    @property
-    def client_id(self) -> str:
-        return os.environ.get(self.client_id_env, self.default_client_id) or ""
-
-    def env_token(self) -> str | None:
-        for var in self.env_keys:
-            token = os.environ.get(var)
-            if token:
-                return token
-        return None
-
-
-PROVIDERS: dict[str, Provider] = {
-    "huggingface": Provider(
-        name="huggingface",
-        host="huggingface.co",
-        authorize_url="https://huggingface.co/oauth/authorize",
-        token_url="https://huggingface.co/oauth/token",
-        scope="openid read-repos gated-repos",
-        env_keys=("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"),
-        client_id_env="COMFY_HF_OAUTH_CLIENT_ID",
-    ),
-    "civitai": Provider(
-        name="civitai",
-        host="civitai.com",
-        authorize_url="https://auth.civitai.com/api/auth/oauth/authorize",
-        token_url="https://auth.civitai.com/api/auth/oauth/token",
-        scope="4",  # ModelsRead; UserRead is auto-granted
-        env_keys=("CIVITAI_API_TOKEN", "CIVITAI_API_KEY"),
-        client_id_env="COMFY_CIVITAI_OAUTH_CLIENT_ID",
-    ),
-}
-
-_HOST_TO_PROVIDER = {p.host: p for p in PROVIDERS.values()}
-
-
-def provider_for_host(host: str) -> Provider | None:
-    """Return the provider whose host exactly matches ``host`` (normalized)."""
-    return _HOST_TO_PROVIDER.get(normalize_host(host))

app/model_downloader/auth/resolver.py

@@ -1,42 +0,0 @@
-"""Per-hop auth resolution (https only).
-
-Recomputed from scratch on every redirect hop: a hop only gets a bearer token
-when *its own host* matches a configured provider, so a token bound to
-``huggingface.co`` is silently dropped when the request is redirected to a
-presigned CDN host — which is exactly what these hubs expect.
-
-For a matching hop: env API key first, then the provider's OAuth access token
-(refreshed if expired), else no auth.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from app.model_downloader.auth.providers import provider_for_host
-from app.model_downloader.auth.store import AUTH_STORE
-
-
-@dataclass
-class RequestAuth:
-    """How to modify a single request to carry a bearer token."""
-
-    headers: dict[str, str] = field(default_factory=dict)
-
-
-async def resolve_auth_for_hop(host: str, scheme: str) -> RequestAuth | None:
-    """Resolve the bearer token (if any) to attach for one request hop."""
-    if scheme.lower() != "https":
-        return None
-    provider = provider_for_host(host)
-    if provider is None:
-        return None
-
-    token = provider.env_token()
-    if token:
-        return RequestAuth(headers={"Authorization": f"Bearer {token}"})
-
-    access = await AUTH_STORE.get_valid_token(provider)
-    if access:
-        return RequestAuth(headers={"Authorization": f"Bearer {access}"})
-    return None

app/model_downloader/auth/store.py

@@ -1,64 +0,0 @@
-"""In-memory OAuth token cache over the on-disk token store.
-
-:data:`AUTH_STORE` is the process singleton the resolver and API talk to. It
-lazily loads each provider's token from disk, refreshes an expired access token
-via its refresh token, and orchestrates the login flow (delegating the loopback
-callback server to :mod:`oauth`).
-"""
-
-from __future__ import annotations
-
-from app.model_downloader.auth import oauth, token_store
-from app.model_downloader.auth.providers import Provider
-from app.model_downloader.auth.token_store import Token
-
-
-class AuthStore:
-    def __init__(self) -> None:
-        # provider name -> Token, or None when known to be absent. A missing key
-        # means "not yet loaded from disk".
-        self._cache: dict[str, Token | None] = {}
-
-    def _load(self, name: str) -> Token | None:
-        if name not in self._cache:
-            self._cache[name] = token_store.load(name)
-        return self._cache[name]
-
-    def set_token(self, name: str, token: Token) -> None:
-        self._cache[name] = token
-        token_store.save(name, token)
-
-    def clear(self, name: str) -> None:
-        self._cache[name] = None
-        token_store.delete(name)
-
-    async def get_valid_token(self, provider: Provider) -> str | None:
-        """Return a valid access token string for ``provider``, or ``None``.
-
-        Refreshes an expired token when a refresh token is available.
-        """
-        token = self._load(provider.name)
-        if token is None or not token.access_token:
-            return None
-        if token.is_expired():
-            if not token.refresh_token:
-                return None
-            token = await oauth.refresh_access_token(provider, token)
-            self.set_token(provider.name, token)
-        return token.access_token
-
-    async def begin_login(self, provider: Provider) -> str:
-        """Start a login flow; returns the authorize URL to open in a browser."""
-        return await oauth.start_login_flow(provider, self.set_token)
-
-    def status(self, provider: Provider) -> dict:
-        token = self._load(provider.name)
-        return {
-            "provider": provider.name,
-            "logged_in": token is not None and bool(token.access_token),
-            "login_in_progress": oauth.login_in_progress(provider.name),
-            "env_key_present": provider.env_token() is not None,
-        }
-
-
-AUTH_STORE = AuthStore()

app/model_downloader/auth/token_store.py

@@ -1,186 +0,0 @@
-"""On-disk OAuth token persistence — one machine-bound blob per provider.
-
-Tokens live under ``folder_paths.get_system_user_directory("download_auth")``,
-never in the SQLite DB. Each provider file is written ``0600`` and holds an
-opaque blob, not readable JSON: the token JSON is XORed with an HMAC-SHA256
-keystream whose key is derived from stable machine/install attributes plus a
-per-install random salt.
-
-This is obfuscation, not confidentiality. It stops a token from being read by a
-human browsing files, grepped out of a backup, or lifted from a folder copied to
-another machine (the blob won't decrypt off its origin machine). It does not
-protect against code running inside this process (custom nodes) or an attacker
-who reads this source and recomputes the key.
-"""
-
-from __future__ import annotations
-
-import base64
-import getpass
-import hashlib
-import hmac
-import json
-import os
-import platform
-import secrets
-import time
-from dataclasses import asdict, dataclass
-
-import folder_paths
-
-_SALT_FILE = ".salt"
-_SALT_LEN = 32
-_NONCE_LEN = 16
-_PBKDF2_ITERS = 200_000
-
-
-@dataclass
-class Token:
-    access_token: str
-    refresh_token: str | None = None
-    # Epoch seconds when the access token expires; 0 means "unknown / no expiry".
-    expires_at: int = 0
-    token_type: str = "Bearer"
-    scope: str | None = None
-
-    def is_expired(self, skew: int = 60) -> bool:
-        if not self.expires_at:
-            return False
-        return time.time() + skew >= self.expires_at
-
-
-def _auth_dir() -> str:
-    path = folder_paths.get_system_user_directory("download_auth")
-    os.makedirs(path, exist_ok=True)
-    return path
-
-
-def _token_path(provider: str) -> str:
-    return os.path.join(_auth_dir(), f"{provider}.bin")
-
-
-def _machine_id() -> bytes:
-    """A stable per-machine identifier, best-effort across platforms."""
-    for path in ("/etc/machine-id", "/var/lib/dbus/machine-id"):
-        try:
-            with open(path, "rb") as f:
-                return f.read().strip()
-        except OSError:
-            pass
-    if os.name == "nt":
-        import winreg
-
-        try:
-            key = winreg.OpenKey(
-                winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Cryptography"
-            )
-            try:
-                guid, _ = winreg.QueryValueEx(key, "MachineGuid")
-                return str(guid).encode("utf-8")
-            finally:
-                winreg.CloseKey(key)
-        except OSError:
-            pass
-    return platform.node().encode("utf-8")
-
-
-def _machine_material(auth_dir: str) -> bytes:
-    try:
-        user = getpass.getuser()
-    except Exception:
-        user = ""
-    parts = (_machine_id(), platform.node().encode("utf-8"), user.encode("utf-8"), auth_dir.encode("utf-8"))
-    return b"\x00".join(parts)
-
-
-def _load_or_create_salt(auth_dir: str) -> bytes | None:
-    path = os.path.join(auth_dir, _SALT_FILE)
-    try:
-        with open(path, "rb") as f:
-            salt = f.read()
-        if len(salt) == _SALT_LEN:
-            return salt
-    except FileNotFoundError:
-        pass
-    except OSError:
-        return None
-    salt = secrets.token_bytes(_SALT_LEN)
-    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    with os.fdopen(fd, "wb") as f:
-        f.write(salt)
-    os.chmod(path, 0o600)
-    return salt
-
-
-def _derive_key(salt: bytes, auth_dir: str) -> bytes:
-    return hashlib.pbkdf2_hmac(
-        "sha256", _machine_material(auth_dir), salt, _PBKDF2_ITERS, dklen=32
-    )
-
-
-def _keystream(key: bytes, nonce: bytes, n: int) -> bytes:
-    out = bytearray()
-    counter = 0
-    while len(out) < n:
-        out.extend(hmac.new(key, nonce + counter.to_bytes(8, "big"), hashlib.sha256).digest())
-        counter += 1
-    return bytes(out[:n])
-
-
-def _xor(data: bytes, stream: bytes) -> bytes:
-    return bytes(a ^ b for a, b in zip(data, stream))
-
-
-def load(provider: str) -> Token | None:
-    auth_dir = _auth_dir()
-    try:
-        with open(_token_path(provider), "rb") as f:
-            blob = base64.b64decode(f.read())
-    except FileNotFoundError:
-        return None
-    except (ValueError, OSError):
-        return None
-    salt = _load_or_create_salt(auth_dir)
-    if salt is None or len(blob) <= _NONCE_LEN:
-        return None
-    nonce, ciphertext = blob[:_NONCE_LEN], blob[_NONCE_LEN:]
-    key = _derive_key(salt, auth_dir)
-    plaintext = _xor(ciphertext, _keystream(key, nonce, len(ciphertext)))
-    # A wrong machine / corrupt file decrypts to garbage; treat as logged out.
-    try:
-        data = json.loads(plaintext)
-    except ValueError:
-        return None
-    if not isinstance(data, dict) or "access_token" not in data:
-        return None
-    return Token(
-        access_token=data.get("access_token", ""),
-        refresh_token=data.get("refresh_token"),
-        expires_at=int(data.get("expires_at", 0) or 0),
-        token_type=data.get("token_type", "Bearer"),
-        scope=data.get("scope"),
-    )
-
-
-def save(provider: str, token: Token) -> None:
-    auth_dir = _auth_dir()
-    salt = _load_or_create_salt(auth_dir)
-    if salt is None:
-        return
-    key = _derive_key(salt, auth_dir)
-    nonce = secrets.token_bytes(_NONCE_LEN)
-    plaintext = json.dumps(asdict(token)).encode("utf-8")
-    ciphertext = _xor(plaintext, _keystream(key, nonce, len(plaintext)))
-    blob = base64.b64encode(nonce + ciphertext)
-    path = _token_path(provider)
-    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    with os.fdopen(fd, "wb") as f:
-        f.write(blob)
-    os.chmod(path, 0o600)
-
-
-def delete(provider: str) -> None:
-    try:
-        os.remove(_token_path(provider))
-    except FileNotFoundError:
-        pass

app/model_downloader/constants.py

@@ -1,32 +0,0 @@
-"""Shared constants for the download manager.
-
-Status values are persisted as TEXT in the ``downloads`` table; keep them
-stable. The lifecycle is:
-
-    queued -> active -> verifying -> completed
-       |        |-> paused -> (resume) -> active
-       |        |-> failed (network, retryable) -> queued (backoff)
-       |-> cancelled
-"""
-
-from __future__ import annotations
-
-
-class DownloadStatus:
-    QUEUED = "queued"
-    ACTIVE = "active"
-    PAUSED = "paused"
-    VERIFYING = "verifying"
-    COMPLETED = "completed"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
-
-    #: States from which a worker is doing (or about to do) network I/O.
-    LIVE = (QUEUED, ACTIVE, VERIFYING)
-    #: Terminal states — the job will not transition again on its own.
-    TERMINAL = (COMPLETED, FAILED, CANCELLED)
-
-
-# Default temp-file suffix. Distinctive so the startup orphan sweep only
-# removes files THIS subsystem created, never unrelated *.tmp files.
-TMP_SUFFIX = ".comfy-download.part"

app/model_downloader/database/models.py

@@ -1,125 +0,0 @@
-"""SQLAlchemy models for the download manager.
-
-Two tables:
-
-- ``downloads``         one row per requested file (job + queue state).
-- ``download_segments`` per-segment byte progress, for segmented resume.
-
-On completion a finished file is registered into the assets catalog;
-``downloads`` is kept only as job history.
-"""
-
-from __future__ import annotations
-
-import time
-import uuid
-
-from sqlalchemy import (
-    BigInteger,
-    Boolean,
-    CheckConstraint,
-    ForeignKey,
-    Index,
-    Integer,
-    String,
-    Text,
-)
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-
-from app.database.models import Base
-
-
-def _uuid() -> str:
-    return str(uuid.uuid4())
-
-
-def _now() -> int:
-    return int(time.time())
-
-
-class Download(Base):
-    __tablename__ = "downloads"
-
-    id: Mapped[str] = mapped_column(String(36), primary_key=True, default=_uuid)
-    # Original requested URL and the final URL after validated redirects.
-    url: Mapped[str] = mapped_column(Text, nullable=False)
-    final_url: Mapped[str | None] = mapped_column(Text, nullable=True)
-    # Canonical "<directory>/<filename>" identifier (resolved via folder_paths).
-    model_id: Mapped[str] = mapped_column(String(1024), nullable=False)
-    # Final on-disk location and the .part write target.
-    dest_path: Mapped[str] = mapped_column(Text, nullable=False)
-    temp_path: Mapped[str] = mapped_column(Text, nullable=False)
-
-    status: Mapped[str] = mapped_column(String(16), nullable=False)
-    priority: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-
-    total_bytes: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
-    bytes_done: Mapped[int] = mapped_column(BigInteger, nullable=False, default=0)
-
-    etag: Mapped[str | None] = mapped_column(String(512), nullable=True)
-    last_modified: Mapped[str | None] = mapped_column(String(128), nullable=True)
-    accept_ranges: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-
-    # Optional hub-provided checksum to verify against (NOT the dedup key).
-    expected_sha256: Mapped[str | None] = mapped_column(String(64), nullable=True)
-
-    allow_any_extension: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, default=False
-    )
-    # How many retryable failures we have seen (for backoff capping).
-    attempts: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-
-    error: Mapped[str | None] = mapped_column(Text, nullable=True)
-    created_at: Mapped[int] = mapped_column(BigInteger, nullable=False, default=_now)
-    updated_at: Mapped[int] = mapped_column(
-        BigInteger, nullable=False, default=_now, onupdate=_now
-    )
-
-    segments: Mapped[list[DownloadSegment]] = relationship(
-        "DownloadSegment",
-        back_populates="download",
-        cascade="all,delete-orphan",
-        passive_deletes=True,
-        order_by="DownloadSegment.idx",
-    )
-
-    __table_args__ = (
-        Index("ix_downloads_status", "status"),
-        Index("ix_downloads_priority", "priority"),
-        Index("ix_downloads_model_id", "model_id"),
-        CheckConstraint("bytes_done >= 0", name="ck_downloads_bytes_done_nonneg"),
-        CheckConstraint(
-            "total_bytes IS NULL OR total_bytes >= 0",
-            name="ck_downloads_total_bytes_nonneg",
-        ),
-    )
-
-    def __repr__(self) -> str:
-        return f"<Download id={self.id} model_id={self.model_id!r} status={self.status}>"
-
-
-class DownloadSegment(Base):
-    __tablename__ = "download_segments"
-
-    download_id: Mapped[str] = mapped_column(
-        String(36),
-        ForeignKey("downloads.id", ondelete="CASCADE"),
-        primary_key=True,
-    )
-    idx: Mapped[int] = mapped_column(Integer, primary_key=True)
-    start_offset: Mapped[int] = mapped_column(BigInteger, nullable=False)
-    end_offset: Mapped[int] = mapped_column(BigInteger, nullable=False)
-    bytes_done: Mapped[int] = mapped_column(BigInteger, nullable=False, default=0)
-
-    download: Mapped[Download] = relationship("Download", back_populates="segments")
-
-    __table_args__ = (
-        CheckConstraint("bytes_done >= 0", name="ck_segments_bytes_done_nonneg"),
-        CheckConstraint("end_offset >= start_offset", name="ck_segments_range"),
-    )
-
-    def __repr__(self) -> str:
-        return (
-            f"<DownloadSegment {self.download_id}#{self.idx} "
-            f"{self.start_offset}-{self.end_offset} done={self.bytes_done}>"
-        )

app/model_downloader/database/queries.py

@@ -1,177 +0,0 @@
-"""Synchronous DB access for the download manager.
-
-All functions open their own short-lived session via ``create_session`` and
-commit before returning, mirroring ``app/assets`` usage. They are blocking
-(SQLite) and should be called from async code through ``asyncio.to_thread``.
-"""
-
-from __future__ import annotations
-
-import time
-from typing import Optional
-
-from sqlalchemy import delete, select
-
-from app.database.db import create_session
-from app.model_downloader.constants import DownloadStatus
-from app.model_downloader.database.models import Download, DownloadSegment
-
-
-# ----- downloads -----
-
-
-def insert_download(values: dict) -> None:
-    with create_session() as session:
-        session.add(Download(**values))
-        session.commit()
-
-
-def get_download(download_id: str) -> Optional[Download]:
-    with create_session() as session:
-        row = session.get(Download, download_id)
-        if row is not None:
-            session.expunge_all()
-        return row
-
-
-def list_downloads() -> list[Download]:
-    with create_session() as session:
-        rows = list(
-            session.execute(
-                select(Download).order_by(Download.created_at.desc())
-            ).scalars()
-        )
-        session.expunge_all()
-        return rows
-
-
-def has_live_download_for_model(
-    model_id: str, live_statuses: tuple[str, ...], exclude_id: Optional[str] = None
-) -> bool:
-    with create_session() as session:
-        stmt = select(Download.id).where(
-            Download.model_id == model_id,
-            Download.status.in_(live_statuses),
-        ).limit(1)
-        if exclude_id is not None:
-            stmt = stmt.where(Download.id != exclude_id)
-        return session.execute(stmt).first() is not None
-
-
-def list_segments(download_id: str) -> list[DownloadSegment]:
-    with create_session() as session:
-        rows = list(
-            session.execute(
-                select(DownloadSegment)
-                .where(DownloadSegment.download_id == download_id)
-                .order_by(DownloadSegment.idx)
-            ).scalars()
-        )
-        session.expunge_all()
-        return rows
-
-
-def update_download(download_id: str, **fields) -> None:
-    if not fields:
-        return
-    fields.setdefault("updated_at", int(time.time()))
-    with create_session() as session:
-        row = session.get(Download, download_id)
-        if row is None:
-            return
-        for key, value in fields.items():
-            setattr(row, key, value)
-        session.commit()
-
-
-def delete_download(download_id: str) -> None:
-    with create_session() as session:
-        row = session.get(Download, download_id)
-        if row is not None:
-            session.delete(row)
-            session.commit()
-
-
-def delete_downloads(download_ids: list[str]) -> int:
-    """Delete many downloads in one transaction; returns the number removed.
-
-    Uses a bulk ``DELETE ... WHERE id IN (...)``. Segment rows are removed by
-    the ``ON DELETE CASCADE`` foreign key (SQLite ``PRAGMA foreign_keys=ON`` is
-    set in ``app/database/db.py``), so this stays consistent without loading the
-    ORM relationship.
-    """
-    if not download_ids:
-        return 0
-    with create_session() as session:
-        result = session.execute(
-            delete(Download).where(Download.id.in_(download_ids))
-        )
-        session.commit()
-        return result.rowcount or 0
-
-
-def replace_segments(download_id: str, segments: list[dict]) -> None:
-    """Atomically replace the segment plan for a download."""
-    with create_session() as session:
-        session.query(DownloadSegment).filter(
-            DownloadSegment.download_id == download_id
-        ).delete()
-        for seg in segments:
-            session.add(DownloadSegment(download_id=download_id, **seg))
-        session.commit()
-
-
-def update_segment_progress(download_id: str, idx: int, bytes_done: int) -> None:
-    with create_session() as session:
-        row = session.get(DownloadSegment, {"download_id": download_id, "idx": idx})
-        if row is None:
-            return
-        row.bytes_done = bytes_done
-        session.commit()
-
-
-def list_queued_downloads() -> list[Download]:
-    """Queued rows ordered for admission (priority desc, then FIFO)."""
-    with create_session() as session:
-        rows = list(
-            session.execute(
-                select(Download)
-                .where(Download.status == DownloadStatus.QUEUED)
-                .order_by(Download.priority.desc(), Download.created_at.asc())
-            ).scalars()
-        )
-        session.expunge_all()
-        return rows
-
-
-def reconcile_live_downloads() -> list[Download]:
-    """Reset any ``active``/``verifying`` rows left by a previous run.
-
-    On a clean restart there can be no live worker, so anything still marked
-    live is stale. Move it back to ``queued`` (offsets are preserved on the
-    segment rows) so the scheduler re-admits it. Returns the rows that should
-    be re-queued by the scheduler (queued + paused).
-    """
-    with create_session() as session:
-        stale = list(
-            session.execute(
-                select(Download).where(
-                    Download.status.in_([DownloadStatus.ACTIVE, DownloadStatus.VERIFYING])
-                )
-            ).scalars()
-        )
-        now = int(time.time())
-        for row in stale:
-            row.status = DownloadStatus.QUEUED
-            row.updated_at = now
-        session.commit()
-
-        resumable = list(
-            session.execute(
-                select(Download)
-                .where(Download.status == DownloadStatus.QUEUED)
-                .order_by(Download.priority.desc(), Download.created_at.asc())
-            ).scalars()
-        )
-        session.expunge_all()
-        return resumable

app/model_downloader/engine/job.py

@@ -1,611 +0,0 @@
-"""The per-download worker.
-
-One :class:`DownloadJob` drives a single file from probe to verified, cataloged
-completion. It supports cooperative pause / resume / cancel, segmented
-multi-connection transfer with positioned writes, and a verification gate
-(size + structural + optional sha256) before the atomic rename into place.
-
-Control is cooperative: external callers flip ``_control`` via
-:meth:`request_pause` / :meth:`request_cancel`; segment loops observe it between
-chunks and raise, which unwinds cleanly and persists resume offsets.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import time
-from dataclasses import dataclass, field
-from typing import Callable, Optional
-
-from comfy.cli_args import args
-from app.model_downloader.constants import DownloadStatus
-from app.model_downloader.database import queries
-from app.model_downloader.engine.planner import (
-    effective_segment_count,
-    plan_segments,
-)
-from app.model_downloader.engine.writer import FileWriter
-from app.model_downloader.net.http import open_validated, redact_url
-from app.model_downloader.net.probe import gated_error_message, probe
-from app.model_downloader.verify import checksum, dedup, structural
-
-_RETRYABLE_STATUSES = {408, 429, 500, 502, 503, 504}
-_PERSIST_INTERVAL = 2.0  # seconds between throttled progress persists
-
-
-class Paused(Exception):
-    pass
-
-
-class Cancelled(Exception):
-    pass
-
-
-class RemoteChanged(Exception):
-    """The remote file changed under a resume (got 200 where 206 expected)."""
-
-
-class RetryableError(Exception):
-    pass
-
-
-class FatalError(Exception):
-    """Non-retryable: 4xx, checksum mismatch, structural failure, gated, etc."""
-
-
-@dataclass
-class SegmentRuntime:
-    idx: int
-    start: int
-    end: int  # inclusive; may be -1 for unknown-size single stream
-    bytes_done: int = 0
-
-    @property
-    def length(self) -> int:
-        return self.end - self.start + 1
-
-
-@dataclass
-class RuntimeState:
-    download_id: str
-    model_id: str
-    url: str
-    priority: int
-    status: str
-    total_bytes: Optional[int] = None
-    bytes_done: int = 0
-    error: Optional[str] = None
-    segments: list[SegmentRuntime] = field(default_factory=list)
-    started_at: float = field(default_factory=time.monotonic)
-    _last_bytes: int = 0
-    _last_time: float = field(default_factory=time.monotonic)
-    speed_bps: float = 0.0
-
-    @property
-    def progress(self) -> Optional[float]:
-        if not self.total_bytes:
-            return None
-        return min(1.0, self.bytes_done / self.total_bytes)
-
-    @property
-    def eta_seconds(self) -> Optional[float]:
-        if not self.total_bytes or self.speed_bps <= 0:
-            return None
-        remaining = max(0, self.total_bytes - self.bytes_done)
-        return remaining / self.speed_bps
-
-
-@dataclass
-class JobSpec:
-    download_id: str
-    url: str
-    model_id: str
-    dest_path: str
-    temp_path: str
-    priority: int = 0
-    expected_sha256: Optional[str] = None
-    allow_any_extension: bool = False
-    etag: Optional[str] = None
-    attempts: int = 0
-
-
-class DownloadJob:
-    def __init__(
-        self, spec: JobSpec, notify_cb: Optional[Callable[[str], None]] = None
-    ) -> None:
-        self.spec = spec
-        self._notify = notify_cb
-        self._control = "run"  # run | pause | cancel
-        self.state = RuntimeState(
-            download_id=spec.download_id,
-            model_id=spec.model_id,
-            url=spec.url,
-            priority=spec.priority,
-            status=DownloadStatus.QUEUED,
-        )
-        self._writer: Optional[FileWriter] = None
-        self._etag: Optional[str] = spec.etag
-        self._last_persist = 0.0
-
-    # ----- external control -----
-
-    def request_pause(self) -> None:
-        if self._control == "run":
-            self._control = "pause"
-
-    def request_cancel(self) -> None:
-        self._control = "cancel"
-
-    def _check_control(self) -> None:
-        if self._control == "cancel":
-            raise Cancelled()
-        if self._control == "pause":
-            raise Paused()
-
-    # ----- lifecycle -----
-
-    async def run(self) -> str:
-        """Run to a terminal/paused state; returns the final status string."""
-        await self._set_status(DownloadStatus.ACTIVE, error=None)
-        try:
-            pr = await self._probe_and_plan()
-            await self._transfer(pr)
-            await self._finalize()
-            await self._set_status(DownloadStatus.COMPLETED)
-        except Paused:
-            await self._persist_progress(force=True)
-            await self._set_status(DownloadStatus.PAUSED)
-        except Cancelled:
-            await self._close_writer()
-            self._remove_temp()
-            await self._set_status(DownloadStatus.CANCELLED)
-        except RemoteChanged:
-            await self._reset_for_restart()
-            await self._set_status(
-                DownloadStatus.QUEUED, error="remote file changed; restarting"
-            )
-        except RetryableError as e:
-            await self._persist_progress(force=True)
-            await self._set_status(DownloadStatus.QUEUED, error=str(e))
-        except FatalError as e:
-            await self._close_writer()
-            self._remove_temp()
-            await self._set_status(DownloadStatus.FAILED, error=str(e))
-        except Exception as e:  # unexpected -> treat as retryable
-            logging.warning(
-                "[model_downloader] %s unexpected error: %s",
-                self.spec.model_id, e, exc_info=True,
-            )
-            await self._persist_progress(force=True)
-            await self._set_status(DownloadStatus.QUEUED, error=f"{type(e).__name__}: {e}")
-        finally:
-            await self._close_writer()
-        return self.state.status
-
-    # ----- probe + plan -----
-
-    async def _probe_and_plan(self):
-        pr = await probe(self.spec.url)
-        if not pr.ok:
-            if pr.gated:
-                raise FatalError(gated_error_message(self.spec.url, pr))
-            if pr.status == 0 or pr.status in _RETRYABLE_STATUSES:
-                raise RetryableError(pr.error or "probe failed")
-            raise FatalError(pr.error or f"probe returned HTTP {pr.status}")
-
-        max_bytes = self._max_download_bytes()
-        if max_bytes is not None and pr.total_bytes is not None and pr.total_bytes > max_bytes:
-            raise FatalError(
-                f"file size {pr.total_bytes} exceeds the maximum allowed "
-                f"download size {max_bytes} (--download-max-bytes)"
-            )
-
-        self._etag = pr.etag or self._etag
-        self.state.total_bytes = pr.total_bytes
-        await asyncio.to_thread(
-            queries.update_download,
-            self.spec.download_id,
-            final_url=pr.final_url,
-            total_bytes=pr.total_bytes,
-            accept_ranges=pr.accept_ranges,
-            etag=pr.etag,
-            last_modified=pr.last_modified,
-        )
-
-        seg_count = effective_segment_count(
-            pr.total_bytes, pr.accept_ranges, max(1, args.download_segments)
-        )
-        existing = await asyncio.to_thread(queries.list_segments, self.spec.download_id)
-        can_resume_segmented = (
-            seg_count > 1
-            and existing
-            and pr.total_bytes is not None
-            and existing[-1].end_offset == pr.total_bytes - 1
-        )
-        if can_resume_segmented and not self._segmented_part_valid(pr.total_bytes):
-            # The persisted per-segment offsets describe bytes in a preallocated
-            # .part that is now gone or the wrong size (e.g. the partial of a
-            # failed download was swept on restart, or removed by a fatal
-            # error). Trusting them would skip already-"complete" segments and
-            # leave zero-filled holes. Discard the offsets and re-plan fresh.
-            logging.info(
-                "[model_downloader] %s discarding segmented resume offsets "
-                "(preallocated .part missing or wrong size); restarting",
-                self.spec.model_id,
-            )
-            self._remove_temp()
-            await asyncio.to_thread(
-                queries.replace_segments, self.spec.download_id, []
-            )
-            await asyncio.to_thread(
-                queries.update_download, self.spec.download_id, bytes_done=0
-            )
-            existing = []
-            can_resume_segmented = False
-
-        if can_resume_segmented:
-            # Resume an existing segmented plan.
-            self.state.segments = [
-                SegmentRuntime(s.idx, s.start_offset, s.end_offset, s.bytes_done)
-                for s in existing
-            ]
-        elif seg_count > 1 and pr.total_bytes is not None:
-            plans = plan_segments(pr.total_bytes, seg_count)
-            await asyncio.to_thread(
-                queries.replace_segments,
-                self.spec.download_id,
-                [
-                    {"idx": p.idx, "start_offset": p.start, "end_offset": p.end, "bytes_done": 0}
-                    for p in plans
-                ],
-            )
-            self.state.segments = [SegmentRuntime(p.idx, p.start, p.end, 0) for p in plans]
-        else:
-            # Single-stream: one logical segment; bytes_done tracked on the row.
-            row = await asyncio.to_thread(queries.get_download, self.spec.download_id)
-            resume_from = row.bytes_done if row else 0
-            end = (pr.total_bytes - 1) if pr.total_bytes else -1
-            # ``row.bytes_done`` may be the SUM of per-segment offsets from a
-            # prior segmented run (a preallocated, non-contiguous .part). A
-            # single-stream resume writes a contiguous prefix, so the offset is
-            # only trustworthy when the on-disk file is exactly that many
-            # contiguous bytes. This guards the case where a download that ran
-            # segmented now resolves to one segment (server dropped
-            # Accept-Ranges, or --download-segments was lowered between runs):
-            # resuming over non-contiguous data would corrupt the output.
-            if resume_from > 0 and not self._contiguous_prefix_valid(resume_from):
-                logging.info(
-                    "[model_downloader] %s discarding untrusted resume offset "
-                    "%d (on-disk .part not a contiguous prefix); restarting",
-                    self.spec.model_id, resume_from,
-                )
-                resume_from = 0
-                self._remove_temp()
-                if await asyncio.to_thread(queries.list_segments, self.spec.download_id):
-                    await asyncio.to_thread(
-                        queries.replace_segments, self.spec.download_id, []
-                    )
-                await asyncio.to_thread(
-                    queries.update_download, self.spec.download_id, bytes_done=0
-                )
-            self.state.segments = [SegmentRuntime(0, 0, end, resume_from)]
-        self._recompute_bytes_done()
-        return pr
-
-    # ----- transfer -----
-
-    async def _transfer(self, pr) -> None:
-        self._writer = FileWriter(self.spec.temp_path)
-        await self._writer.open()
-
-        segmented = len(self.state.segments) > 1
-        if segmented and self.state.total_bytes:
-            await self._writer.preallocate(self.state.total_bytes)
-            await self._run_segmented()
-        else:
-            await self._run_single()
-
-        await self._writer.flush()
-
-    async def _run_segmented(self) -> None:
-        pending = [
-            asyncio.ensure_future(self._run_segment(seg))
-            for seg in self.state.segments
-            if seg.bytes_done < seg.length
-        ]
-        if not pending:
-            return
-        done, not_done = await asyncio.wait(
-            pending, return_when=asyncio.FIRST_EXCEPTION
-        )
-        first_exc: Optional[BaseException] = None
-        for task in done:
-            exc = task.exception()
-            if exc is not None and first_exc is None:
-                first_exc = exc
-        if first_exc is not None:
-            for task in not_done:
-                task.cancel()
-            await asyncio.gather(*not_done, return_exceptions=True)
-            raise first_exc
-
-    async def _run_segment(self, seg: SegmentRuntime) -> None:
-        offset = seg.start + seg.bytes_done
-        headers = {
-            "Range": f"bytes={offset}-{seg.end}",
-            "Accept-Encoding": "identity",
-        }
-        if self._etag:
-            headers["If-Range"] = self._etag
-        async with open_validated(
-            "GET", self.spec.url, headers=headers
-        ) as (resp, _final):
-            if resp.status == 200:
-                # Server ignored the range -> remote changed / no resume support.
-                raise RemoteChanged()
-            if resp.status not in (206,):
-                self._raise_for_status(resp.status)
-            async for chunk in resp.content.iter_chunked(args.download_chunk_size):
-                self._check_control()
-                # Never write past this segment's planned range: a
-                # non-conforming 206 that returns more than the requested
-                # bytes would otherwise overrun adjacent segments and the
-                # preallocated file. Cap the write and abort on overflow.
-                remaining = seg.length - seg.bytes_done
-                if remaining <= 0:
-                    raise FatalError(
-                        f"segment {seg.idx}: server returned more than the "
-                        f"requested {seg.length} bytes"
-                    )
-                overflow = len(chunk) > remaining
-                if overflow:
-                    chunk = chunk[:remaining]
-                await self._writer.write_at(offset, chunk)
-                offset += len(chunk)
-                seg.bytes_done += len(chunk)
-                self._recompute_bytes_done()
-                await self._persist_progress()
-                if overflow:
-                    raise FatalError(
-                        f"segment {seg.idx}: server returned more than the "
-                        f"requested {seg.length} bytes"
-                    )
-
-    async def _run_single(self) -> None:
-        seg = self.state.segments[0]
-        offset = seg.bytes_done  # resume from here for single-stream
-        headers = {"Accept-Encoding": "identity"}
-        if offset > 0:
-            headers["Range"] = f"bytes={offset}-"
-            if self._etag:
-                headers["If-Range"] = self._etag
-        async with open_validated(
-            "GET", self.spec.url, headers=headers
-        ) as (resp, _final):
-            if offset > 0 and resp.status == 200:
-                # Resume not honoured -> start over from the beginning. Truncate
-                # the existing partial so stale trailing bytes from the prior
-                # attempt cannot survive past the new (possibly shorter) end.
-                offset = 0
-                seg.bytes_done = 0
-                self.state.bytes_done = 0
-                await self._writer.truncate(0)
-            elif offset > 0 and resp.status != 206:
-                self._raise_for_status(resp.status)
-            elif offset == 0 and resp.status != 200:
-                self._raise_for_status(resp.status)
-            # Byte ceiling for this stream: the known total when the server
-            # reported a size, otherwise the configured maximum download size.
-            # Without a bound, a non-conforming response or an unknown-length
-            # stream (end == -1) that never closes could fill the disk (DoS).
-            limit = (seg.end + 1) if seg.end >= 0 else self._max_download_bytes()
-            async for chunk in resp.content.iter_chunked(args.download_chunk_size):
-                self._check_control()
-                overflow = False
-                if limit is not None:
-                    remaining = limit - offset
-                    if remaining <= 0:
-                        raise FatalError(
-                            f"download exceeded the maximum size {limit} bytes"
-                        )
-                    if len(chunk) > remaining:
-                        chunk = chunk[:remaining]
-                        overflow = True
-                await self._writer.write_at(offset, chunk)
-                offset += len(chunk)
-                seg.bytes_done = offset
-                self.state.bytes_done = offset
-                await self._persist_progress()
-                if overflow:
-                    raise FatalError(
-                        f"download exceeded the maximum size {limit} bytes"
-                    )
-
-    def _max_download_bytes(self) -> Optional[int]:
-        """Configured maximum download size in bytes, or ``None`` if disabled."""
-        cap = getattr(args, "download_max_bytes", 0)
-        return cap if cap and cap > 0 else None
-
-    def _raise_for_status(self, status: int) -> None:
-        if status in (401, 403):
-            raise FatalError(
-                f"{redact_url(self.spec.url)} returned {status}; authenticate this "
-                f"host via /api/download/auth or set its API key env var."
-            )
-        if status in _RETRYABLE_STATUSES:
-            raise RetryableError(f"HTTP {status}")
-        raise FatalError(f"unexpected HTTP {status}")
-
-    # ----- finalize / verify (PRD section 8.4) -----
-
-    async def _finalize(self) -> None:
-        self._check_control()
-        await self._close_writer()
-        await self._set_status(DownloadStatus.VERIFYING)
-
-        total = self.state.total_bytes
-        segmented = len(self.state.segments) > 1
-        if segmented:
-            # The .part was preallocated to total_bytes, so its on-disk size is
-            # not evidence of completeness: a segment that ends short (truncated
-            # 206 / server closes mid-range) leaves a zero-filled hole while the
-            # file size still equals total. Verify each segment wrote its full
-            # planned range, and trust the byte counter (== sum of segments)
-            # rather than os.path.getsize for the total check.
-            for seg in self.state.segments:
-                if seg.bytes_done != seg.length:
-                    raise FatalError(
-                        f"segment {seg.idx} incomplete: wrote {seg.bytes_done} "
-                        f"of {seg.length} bytes"
-                    )
-            observed = self.state.bytes_done
-        else:
-            # Single-stream writes a contiguous prefix, so the on-disk size is
-            # an independent witness of how much actually landed.
-            observed = os.path.getsize(self.spec.temp_path)
-        if total is not None and observed != total:
-            raise FatalError(
-                f"size mismatch: wrote {observed} of {total} bytes"
-            )
-
-        # Structural gate (cheap, no full read) then optional sha256 (full read).
-        # Both failures are non-retryable (a truncated/corrupt or mismatched file
-        # will not heal on retry), so surface them as FatalError rather than
-        # letting the plain Exceptions fall through to the retryable handler.
-        # ``temp_path`` carries the ``.part`` suffix; pass ``dest_path`` so the
-        # structural check detects the real file format instead of skipping it.
-        try:
-            await asyncio.to_thread(
-                structural.validate, self.spec.temp_path, self.spec.dest_path
-            )
-            if self.spec.expected_sha256:
-                await asyncio.to_thread(
-                    checksum.verify_sha256,
-                    self.spec.temp_path,
-                    self.spec.expected_sha256,
-                )
-        except (structural.StructuralError, checksum.ChecksumError) as e:
-            raise FatalError(str(e)) from e
-
-        os.makedirs(os.path.dirname(self.spec.dest_path), exist_ok=True)
-        os.replace(self.spec.temp_path, self.spec.dest_path)
-        logging.info(
-            "[model_downloader] completed %s (%d bytes)",
-            self.spec.model_id, observed,
-        )
-        # Catalog into the assets system (blake3 dedup identity). Best-effort.
-        await dedup.register_completed(self.spec.dest_path)
-
-    # ----- helpers -----
-
-    def _recompute_bytes_done(self) -> None:
-        self.state.bytes_done = sum(s.bytes_done for s in self.state.segments)
-        now = time.monotonic()
-        dt = now - self.state._last_time
-        if dt >= 0.5:
-            self.state.speed_bps = (self.state.bytes_done - self.state._last_bytes) / dt
-            self.state._last_bytes = self.state.bytes_done
-            self.state._last_time = now
-
-    async def _persist_progress(self, force: bool = False) -> None:
-        # Both the DB write and the websocket notify are gated by the same
-        # throttle: persisting hits SQLite, and notifying broadcasts to every
-        # client, so doing either per-chunk (small --download-chunk-size or
-        # many concurrent segments) would overwhelm both. Skip entirely inside
-        # the window; the next persist (or a forced one) ships the latest bytes.
-        now = time.monotonic()
-        if not force and now - self._last_persist < _PERSIST_INTERVAL:
-            return
-        self._last_persist = now
-        # SQLite is blocking; run it off the event loop per the queries module
-        # contract so progress persists don't stall the web server.
-        await asyncio.to_thread(self._write_progress)
-        if self._notify:
-            self._notify(self.spec.download_id)
-
-    def _write_progress(self) -> None:
-        queries.update_download(self.spec.download_id, bytes_done=self.state.bytes_done)
-        for seg in self.state.segments:
-            if seg.end >= seg.start:  # skip unknown-size sentinel
-                queries.update_segment_progress(
-                    self.spec.download_id, seg.idx, seg.bytes_done
-                )
-
-    async def _reset_for_restart(self) -> None:
-        await self._close_writer()
-        self._remove_temp()
-        for seg in self.state.segments:
-            seg.bytes_done = 0
-        self.state.bytes_done = 0
-        await asyncio.to_thread(
-            queries.update_download, self.spec.download_id, bytes_done=0
-        )
-        if await asyncio.to_thread(queries.list_segments, self.spec.download_id):
-            await asyncio.to_thread(
-                queries.replace_segments, self.spec.download_id, []
-            )
-
-    async def _close_writer(self) -> None:
-        if self._writer is not None:
-            try:
-                await self._writer.close()
-            except Exception:
-                logging.debug("[model_downloader] writer close error", exc_info=True)
-            self._writer = None
-
-    def _segmented_part_valid(self, total_bytes: int) -> bool:
-        """True when the temp file is the preallocated segmented ``.part``.
-
-        A segmented transfer preallocates the .part to ``total_bytes`` up front
-        and tracks how much of each range landed via per-segment offsets. Those
-        offsets are only trustworthy when the file they describe is still on
-        disk at its full preallocated size. A missing file (swept after a
-        failure, removed on a fatal error, deleted by hand) or a wrong-sized one
-        means the persisted offsets no longer correspond to real bytes and must
-        not be resumed over. Doing so would skip "complete" segments and leave
-        zero-filled holes that pass the size-only verification gate.
-        """
-        try:
-            return os.path.getsize(self.spec.temp_path) == total_bytes
-        except OSError:
-            return False
-
-    def _contiguous_prefix_valid(self, prefix_len: int) -> bool:
-        """True when the temp file is exactly ``prefix_len`` contiguous bytes.
-
-        Single-stream resume appends sequentially, so a valid resume point
-        implies the .part size equals the persisted offset. A larger file (e.g.
-        one preallocated to ``total_bytes`` by a previous segmented run) or a
-        missing/short file means the persisted offset is not a trustworthy
-        contiguous prefix and must not be resumed over.
-        """
-        try:
-            return os.path.getsize(self.spec.temp_path) == prefix_len
-        except OSError:
-            return False
-
-    def _remove_temp(self) -> None:
-        try:
-            os.remove(self.spec.temp_path)
-        except FileNotFoundError:
-            pass
-        except OSError as e:
-            logging.warning(
-                "[model_downloader] could not remove %s: %s", self.spec.temp_path, e
-            )
-
-    async def _set_status(self, status: str, error: Optional[str] = None) -> None:
-        # ``error`` is authoritative: passing None clears any prior failure
-        # text so transitions out of a failure state (retry/success) don't
-        # leave stale messages on RuntimeState or in the persisted row.
-        self.state.status = status
-        self.state.error = error
-        fields = {"status": status, "bytes_done": self.state.bytes_done, "error": error}
-        if status == DownloadStatus.QUEUED:
-            fields["attempts"] = self.spec.attempts + 1
-            self.spec.attempts += 1
-        await asyncio.to_thread(queries.update_download, self.spec.download_id, **fields)
-        if self._notify:
-            self._notify(self.spec.download_id)

app/model_downloader/engine/planner.py

@@ -1,51 +0,0 @@
-"""Segment planning.
-
-Split a known byte range into S roughly-equal segments, each fetched by its
-own coroutine with ``Range: bytes=start-end``. Falls back to a single segment
-when the server doesn't support ranges or the size is unknown/too small for
-segmentation to be worthwhile.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-# Below this size, the per-connection setup cost outweighs any parallelism.
-_MIN_SEGMENT_BYTES = 1 * 1024 * 1024
-
-
-@dataclass(frozen=True)
-class SegmentPlan:
-    idx: int
-    start: int
-    end: int  # inclusive
-
-    @property
-    def length(self) -> int:
-        return self.end - self.start + 1
-
-
-def effective_segment_count(
-    total_bytes: int | None, accept_ranges: bool, configured: int
-) -> int:
-    """How many segments to actually use for this file."""
-    if not accept_ranges or total_bytes is None or total_bytes <= 0:
-        return 1
-    by_size = max(1, total_bytes // _MIN_SEGMENT_BYTES)
-    return max(1, min(configured, by_size))
-
-
-def plan_segments(total_bytes: int, num_segments: int) -> list[SegmentPlan]:
-    """Return ``num_segments`` contiguous, inclusive byte ranges covering [0, total)."""
-    if total_bytes <= 0 or num_segments <= 1:
-        return [SegmentPlan(idx=0, start=0, end=max(0, total_bytes - 1))]
-    base = total_bytes // num_segments
-    plans: list[SegmentPlan] = []
-    start = 0
-    for i in range(num_segments):
-        # Last segment soaks up the remainder.
-        length = base if i < num_segments - 1 else total_bytes - start
-        end = start + length - 1
-        plans.append(SegmentPlan(idx=i, start=start, end=end))
-        start = end + 1
-    return plans

app/model_downloader/engine/writer.py

@@ -1,110 +0,0 @@
-"""Positioned, off-loop file writes.
-
-Network I/O stays on the event loop; every blocking disk op (preallocate,
-positioned write, fsync) is run in a bounded thread pool via
-``run_in_executor`` so downloads never stall inference or the web server.
-
-A single file descriptor is opened for the whole download. Segments write to
-their own offsets with ``os.pwrite`` — which is offset-addressed and atomic
-per call, so concurrent segment writers need no extra locking. Per-chunk
-fsync is avoided; we fsync once at completion.
-
-``os.pwrite`` is unavailable on Windows, so there we fall back to
-``os.lseek`` + ``os.write`` guarded by a per-writer lock (the seek/write pair
-is not atomic, so concurrent segment writers must be serialized).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import threading
-from concurrent.futures import ThreadPoolExecutor
-from typing import Optional
-
-# One shared, bounded pool for all download disk I/O.
-_EXECUTOR = ThreadPoolExecutor(max_workers=8, thread_name_prefix="dl-writer")
-
-_HAS_PWRITE = hasattr(os, "pwrite")
-
-# On Windows ``os.open`` defaults to text mode, which translates every ``\n``
-# byte into ``\r\n`` on write and corrupts binary payloads (the file grows by
-# one byte per 0x0A). ``O_BINARY`` disables that translation; it does not exist
-# on POSIX, where the default is already binary.
-_O_BINARY = getattr(os, "O_BINARY", 0)
-
-
-class FileWriter:
-    """Owns the ``.part`` file descriptor for one download."""
-
-    def __init__(self, path: str) -> None:
-        self.path = path
-        self._fd: Optional[int] = None
-        # Serializes lseek+write on platforms without os.pwrite (Windows).
-        self._seek_lock = threading.Lock()
-
-    def _open(self) -> None:
-        os.makedirs(os.path.dirname(self.path), exist_ok=True)
-        self._fd = os.open(self.path, os.O_RDWR | os.O_CREAT | _O_BINARY, 0o644)
-
-    async def open(self) -> None:
-        await asyncio.get_running_loop().run_in_executor(_EXECUTOR, self._open)
-
-    async def preallocate(self, size: int) -> None:
-        """Grow the file to ``size`` so segments write to their offsets."""
-        if self._fd is None or size <= 0:
-            return
-        await asyncio.get_running_loop().run_in_executor(
-            _EXECUTOR, os.ftruncate, self._fd, size
-        )
-
-    async def truncate(self, size: int = 0) -> None:
-        """Truncate the file to ``size`` bytes (default: empty it)."""
-        if self._fd is None:
-            return
-        await asyncio.get_running_loop().run_in_executor(
-            _EXECUTOR, os.ftruncate, self._fd, size
-        )
-
-    def _pwrite_all(self, data: bytes, offset: int) -> None:
-        """A positioned write may write fewer bytes than requested (signal
-        interruption, near-ENOSPC); loop until every byte lands so we never
-        leave a gap while the caller advances by the full chunk length.
-
-        Uses ``os.pwrite`` where available (offset-addressed, atomic per call).
-        On Windows it falls back to ``os.lseek`` + ``os.write`` under a lock,
-        since that pair is not atomic across concurrent segment writers."""
-        assert self._fd is not None, "writer not opened"
-        view = memoryview(data)
-        written = 0
-        total = len(view)
-        while written < total:
-            if _HAS_PWRITE:
-                n = os.pwrite(self._fd, view[written:], offset + written)
-            else:
-                with self._seek_lock:
-                    os.lseek(self._fd, offset + written, os.SEEK_SET)
-                    n = os.write(self._fd, view[written:])
-            if n == 0:
-                raise OSError(
-                    f"positioned write wrote 0 bytes at offset {offset + written} "
-                    f"({written}/{total} bytes written)"
-                )
-            written += n
-
-    async def write_at(self, offset: int, data: bytes) -> None:
-        assert self._fd is not None, "writer not opened"
-        await asyncio.get_running_loop().run_in_executor(
-            _EXECUTOR, self._pwrite_all, data, offset
-        )
-
-    async def flush(self) -> None:
-        if self._fd is None:
-            return
-        await asyncio.get_running_loop().run_in_executor(_EXECUTOR, os.fsync, self._fd)
-
-    async def close(self) -> None:
-        if self._fd is None:
-            return
-        fd, self._fd = self._fd, None
-        await asyncio.get_running_loop().run_in_executor(_EXECUTOR, os.close, fd)

app/model_downloader/manager.py

@@ -1,444 +0,0 @@
-"""Public facade for the download manager.
-
-This is the only object the server imports. It validates requests, owns the
-:class:`Scheduler`, and exposes a small async API plus read models for status.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import uuid
-from typing import Callable, Optional
-
-from app.model_downloader.constants import DownloadStatus
-from app.model_downloader.database import queries
-from app.model_downloader.net.probe import gated_error_message, probe
-from app.model_downloader.scheduler import SCHEDULER
-from app.model_downloader.security import paths
-from app.model_downloader.net.http import redact_url
-from app.model_downloader.security.allowlist import (
-    ALLOWED_MODEL_EXTENSIONS,
-    filename_extension,
-    is_host_allowed_url,
-    is_url_downloadable,
-    url_path_extension,
-)
-from app.model_downloader.security.paths import InvalidModelId
-
-# Non-terminal statuses: an existing row in one of these blocks a re-enqueue.
-_LIVE_STATUSES = (
-    DownloadStatus.QUEUED,
-    DownloadStatus.ACTIVE,
-    DownloadStatus.PAUSED,
-    DownloadStatus.VERIFYING,
-)
-
-
-class DownloadError(Exception):
-    """A user-facing error with a stable machine-readable code."""
-
-    def __init__(self, code: str, message: str, status: int = 400) -> None:
-        super().__init__(message)
-        self.code = code
-        self.message = message
-        self.http_status = status
-
-
-class DownloadManager:
-    def __init__(self) -> None:
-        self._scheduler = SCHEDULER
-        self._notify_cb: Optional[Callable[[str], None]] = None
-        # Serializes the "check for a live download, then write" critical section
-        # per model_id. ``downloads`` has no uniqueness constraint on model_id
-        # (history rows are kept), so without this two concurrent enqueue/resume
-        # calls could both pass the live check and admit two jobs sharing one
-        # temp/dest path. The manager is a process singleton over a local SQLite
-        # DB, so an in-process lock is sufficient (and avoids a migration).
-        self._model_locks: dict[str, asyncio.Lock] = {}
-
-    def set_notify(self, cb: Optional[Callable[[str], None]]) -> None:
-        self._notify_cb = cb
-        self._scheduler.set_notify(cb)
-
-    async def start(self) -> None:
-        await self._scheduler.start()
-
-    # ----- enqueue -----
-
-    async def enqueue(
-        self,
-        url: str,
-        model_id: str,
-        *,
-        priority: int = 0,
-        expected_sha256: Optional[str] = None,
-        allow_any_extension: bool = False,
-    ) -> str:
-        # Coarse gate first: host/scheme must be allowlisted, and any extension
-        # present in the URL path must be a known model type. A URL whose path
-        # carries NO extension (e.g. Civitai's ``/api/download/models/<id>``) is
-        # admitted here and its real extension is resolved from the network
-        # below before the download is finally accepted.
-        if allow_any_extension:
-            if not is_host_allowed_url(url):
-                raise DownloadError(
-                    "URL_NOT_ALLOWED",
-                    "URL is not on the download allowlist (host/scheme).",
-                )
-        elif not is_url_downloadable(url):
-            raise DownloadError(
-                "URL_NOT_ALLOWED",
-                "URL is not on the download allowlist (host/scheme/extension).",
-            )
-
-        # When the URL path has no extension, follow it to where it resolves and
-        # adopt the real extension from the response, forcing the stored
-        # filename to match. Skipped when the caller opted into any extension.
-        if not allow_any_extension and url_path_extension(url) == "":
-            resolved_ext = await self._resolve_extension(url)
-            model_id = paths.apply_extension(model_id, resolved_ext)
-
-        try:
-            paths.parse_model_id(model_id, allow_any_extension)
-            dest_path, temp_path = paths.resolve_destination(model_id, allow_any_extension)
-        except InvalidModelId as e:
-            raise DownloadError("INVALID_MODEL_ID", str(e))
-
-        if await asyncio.to_thread(
-            paths.resolve_existing, model_id, allow_any_extension
-        ):
-            raise DownloadError(
-                "ALREADY_AVAILABLE",
-                f"Model already exists on disk: {model_id}",
-                status=409,
-            )
-        download_id = str(uuid.uuid4())
-        # Hold the per-model lock across the live check and the insert so a
-        # concurrent enqueue/resume for the same model_id cannot interleave
-        # between them and create a second job against the same temp/dest path.
-        async with self._model_lock(model_id):
-            if await self._has_live_download(model_id):
-                raise DownloadError(
-                    "ALREADY_DOWNLOADING",
-                    f"A download for {model_id} is already in progress.",
-                    status=409,
-                )
-            await asyncio.to_thread(
-                queries.insert_download,
-                {
-                    "id": download_id,
-                    "url": url,
-                    "model_id": model_id,
-                    "dest_path": dest_path,
-                    "temp_path": temp_path,
-                    "status": DownloadStatus.QUEUED,
-                    "priority": priority,
-                    "expected_sha256": expected_sha256,
-                    "allow_any_extension": allow_any_extension,
-                },
-            )
-        logging.info("[model_downloader] enqueued %s -> %s", redact_url(url), model_id)
-        await self._scheduler.pump()
-        return download_id
-
-    async def _resolve_extension(self, url: str) -> str:
-        """Follow ``url`` to its final response and return the real extension.
-
-        Used for allowlisted URLs whose path has no extension (e.g. Civitai
-        download endpoints): the filename lives in the ``Content-Disposition``
-        header or the post-redirect URL. Raises :class:`DownloadError` when the
-        URL can't be resolved, needs authentication, or resolves to something
-        that is not a known model file — so we never persist a bogus destination.
-        """
-        pr = await probe(url)
-        if not pr.ok:
-            if pr.gated:
-                raise DownloadError(
-                    "GATED_REPO" if pr.is_gated_repo else "CREDENTIALS_REQUIRED",
-                    gated_error_message(url, pr),
-                    status=401,
-                )
-            raise DownloadError(
-                "URL_RESOLVE_FAILED",
-                f"Could not resolve {redact_url(url)}: {pr.error or 'unknown error'}",
-                status=502,
-            )
-        ext = filename_extension(pr.filename) if pr.filename else ""
-        if ext not in ALLOWED_MODEL_EXTENSIONS:
-            raise DownloadError(
-                "URL_NOT_ALLOWED",
-                f"URL resolves to {pr.filename or '<unknown>'!r}, which is not a "
-                f"known model file type {ALLOWED_MODEL_EXTENSIONS}.",
-            )
-        return ext
-
-    def _model_lock(self, model_id: str) -> asyncio.Lock:
-        # Lazily create one lock per model_id. There is no ``await`` between the
-        # lookup and the insert, so under the single asyncio thread this is
-        # atomic and cannot hand out two different locks for the same model_id.
-        lock = self._model_locks.get(model_id)
-        if lock is None:
-            lock = asyncio.Lock()
-            self._model_locks[model_id] = lock
-        return lock
-
-    async def _has_live_download(
-        self, model_id: str, *, exclude_id: Optional[str] = None
-    ) -> bool:
-        return await asyncio.to_thread(
-            queries.has_live_download_for_model, model_id, _LIVE_STATUSES, exclude_id
-        )
-
-    # ----- control -----
-
-    async def pause(self, download_id: str) -> None:
-        job = self._scheduler.get_job(download_id)
-        if job is not None:
-            job.request_pause()
-            return
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        if row is None:
-            raise DownloadError("NOT_FOUND", "No such download.", status=404)
-        if row.status == DownloadStatus.QUEUED:
-            await asyncio.to_thread(
-                queries.update_download, download_id, status=DownloadStatus.PAUSED
-            )
-
-    async def resume(self, download_id: str) -> None:
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        if row is None:
-            raise DownloadError("NOT_FOUND", "No such download.", status=404)
-        if row.status not in (DownloadStatus.PAUSED, DownloadStatus.FAILED):
-            return
-        # Re-queueing a paused/failed row must respect the single-live-per-model
-        # invariant: another download (e.g. a newer enqueue) may already be live
-        # for this model_id and would share this row's temp/dest path. Hold the
-        # per-model lock across the check and the status flip, and exclude this
-        # row itself (a paused row is already a "live" status).
-        async with self._model_lock(row.model_id):
-            if await self._has_live_download(row.model_id, exclude_id=download_id):
-                raise DownloadError(
-                    "ALREADY_DOWNLOADING",
-                    f"A download for {row.model_id} is already in progress.",
-                    status=409,
-                )
-            await asyncio.to_thread(
-                queries.update_download,
-                download_id,
-                status=DownloadStatus.QUEUED,
-                error=None,
-            )
-        await self._scheduler.pump()
-
-    async def cancel(self, download_id: str) -> None:
-        job = self._scheduler.get_job(download_id)
-        if job is not None:
-            job.request_cancel()
-            return
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        if row is None:
-            raise DownloadError("NOT_FOUND", "No such download.", status=404)
-        if row.status in _LIVE_STATUSES:
-            try:
-                os.remove(row.temp_path)
-            except OSError:
-                pass
-            await asyncio.to_thread(
-                queries.update_download, download_id, status=DownloadStatus.CANCELLED
-            )
-
-    async def set_priority(self, download_id: str, priority: int) -> None:
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        if row is None:
-            raise DownloadError("NOT_FOUND", "No such download.", status=404)
-        await asyncio.to_thread(
-            queries.update_download, download_id, priority=priority
-        )
-        # Admission-order only; a higher priority is
-        # picked up the next time a slot frees. Pump in case a slot is free now.
-        await self._scheduler.pump()
-
-    async def delete(self, download_id: str) -> None:
-        """Delete a terminal download so it stays gone from history.
-
-        Refuses to delete a live download so a record is never removed out from
-        under a running worker; cancel it first. Any leftover ``.part`` temp
-        file (e.g. from a failed transfer) is removed, but the finished model
-        file on disk is never touched.
-        """
-        if self._scheduler.get_job(download_id) is not None:
-            raise DownloadError(
-                "DOWNLOAD_ACTIVE",
-                "Cannot delete a download that is still in progress.",
-                status=409,
-            )
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        if row is None:
-            raise DownloadError("NOT_FOUND", "No such download.", status=404)
-        if row.status in _LIVE_STATUSES:
-            raise DownloadError(
-                "DOWNLOAD_ACTIVE",
-                "Cannot delete a download that is still in progress.",
-                status=409,
-            )
-
-        try:
-            os.remove(row.temp_path)
-        except OSError:
-            pass
-        await asyncio.to_thread(queries.delete_download, download_id)
-
-    async def clear(self) -> int:
-        """Delete all terminal downloads from history in one transaction.
-
-        Skips anything still live (queued/active/paused/verifying, or a running
-        job) so an in-flight download is never removed out from under a worker.
-        Finished model files on disk are never touched; only leftover ``.part``
-        temp files from failed/cancelled transfers are removed. Returns the
-        number of history rows deleted.
-        """
-
-        rows = await asyncio.to_thread(queries.list_downloads)
-        deletable = [
-            r
-            for r in rows
-            if r.status not in _LIVE_STATUSES
-            and self._scheduler.get_job(r.id) is None
-        ]
-        if not deletable:
-            return 0
-        for r in deletable:
-            try:
-                os.remove(r.temp_path)
-            except OSError:
-                pass
-        return await asyncio.to_thread(
-            queries.delete_downloads, [r.id for r in deletable]
-        )
-
-    # ----- read models -----
-
-    def _view(self, row) -> dict:
-        """Combine the persisted row with live in-memory progress, if running."""
-        job = self._scheduler.get_job(row.id)
-        bytes_done = row.bytes_done
-        total = row.total_bytes
-        speed = None
-        eta = None
-        segments = None
-        if job is not None:
-            st = job.state
-            bytes_done = st.bytes_done
-            total = st.total_bytes if st.total_bytes is not None else total
-            speed = st.speed_bps
-            eta = st.eta_seconds
-            segments = [
-                {"idx": s.idx, "bytes_done": s.bytes_done, "length": s.length}
-                for s in st.segments
-                if s.end >= s.start
-            ]
-        progress = (bytes_done / total) if total else None
-        return {
-            "download_id": row.id,
-            "model_id": row.model_id,
-            "url": redact_url(row.url),
-            "status": row.status,
-            "priority": row.priority,
-            "total_bytes": total,
-            "bytes_done": bytes_done,
-            "progress": progress,
-            "speed_bps": speed,
-            "eta_seconds": eta,
-            "segments": segments,
-            "error": row.error,
-            "created_at": row.created_at,
-            "updated_at": row.updated_at,
-        }
-
-    def _view_from_state(self, job) -> dict:
-        """Build a view purely from the live in-memory job state (no DB)."""
-        st = job.state
-        return {
-            "download_id": st.download_id,
-            "model_id": st.model_id,
-            "url": redact_url(st.url),
-            "status": st.status,
-            "priority": st.priority,
-            "total_bytes": st.total_bytes,
-            "bytes_done": st.bytes_done,
-            "progress": st.progress,
-            "speed_bps": st.speed_bps,
-            "eta_seconds": st.eta_seconds,
-            "segments": [
-                {"idx": s.idx, "bytes_done": s.bytes_done, "length": s.length}
-                for s in st.segments
-                if s.end >= s.start
-            ],
-            "error": st.error,
-        }
-
-    def status_sync(self, download_id: str) -> Optional[dict]:
-        """Synchronous status read for the websocket notify path.
-
-        Uses live in-memory state when the job is running (no DB round-trip on
-        the hot path); falls back to a quick DB read otherwise.
-        """
-        job = self._scheduler.get_job(download_id)
-        if job is not None:
-            return self._view_from_state(job)
-        row = queries.get_download(download_id)
-        return self._view(row) if row is not None else None
-
-    async def status(self, download_id: str) -> Optional[dict]:
-        row = await asyncio.to_thread(queries.get_download, download_id)
-        return self._view(row) if row is not None else None
-
-    async def list(self) -> list[dict]:
-        rows = await asyncio.to_thread(queries.list_downloads)
-        return [self._view(r) for r in rows]
-
-    async def availability(self, models: dict[str, str]) -> dict[str, dict]:
-        """Bulk per-id ``{state, progress, ...}`` for the frontend poll.
-
-        ``state`` is ``available`` (on disk), ``downloading`` (live row), or
-        ``missing``. Cheap: a path lookup plus an in-memory/DB status check.
-        """
-        rows = await asyncio.to_thread(queries.list_downloads)
-        by_model: dict[str, object] = {}
-        for r in rows:
-            if r.status in _LIVE_STATUSES or r.model_id not in by_model:
-                by_model[r.model_id] = r
-
-        # ``url_allowed`` mirrors the coarse enqueue gate (host/scheme + a
-        # non-disallowed extension); URLs whose extension is only known after a
-        # network resolve — e.g. Civitai download endpoints — report allowed.
-        out: dict[str, dict] = {}
-        for model_id, url in models.items():
-            try:
-                exists = await asyncio.to_thread(paths.resolve_existing, model_id)
-            except InvalidModelId:
-                out[model_id] = {"state": "missing", "url_allowed": is_url_downloadable(url)}
-                continue
-            if exists:
-                out[model_id] = {"state": "available", "url_allowed": is_url_downloadable(url)}
-                continue
-            row = by_model.get(model_id)
-            if row is not None and row.status in _LIVE_STATUSES:
-                view = self._view(row)
-                out[model_id] = {
-                    "state": "downloading",
-                    "url_allowed": is_url_downloadable(url),
-                    "download_id": view["download_id"],
-                    "progress": view["progress"],
-                    "bytes_done": view["bytes_done"],
-                    "total_bytes": view["total_bytes"],
-                    "speed_bps": view["speed_bps"],
-                }
-            else:
-                out[model_id] = {"state": "missing", "url_allowed": is_url_downloadable(url)}
-        return out
-
-
-DOWNLOAD_MANAGER = DownloadManager()

app/model_downloader/net/http.py

@@ -1,142 +0,0 @@
-"""Manual, validated redirect-following request opener.
-
-Automatic redirects are disabled. We follow hops ourselves
-so that on *every* hop we (a) re-validate scheme + reject credentials-in-URL,
-(b) recompute which auth — if any — applies to that hop's host, and (c) let the
-connector's resolver screen the IP. This is the single place that attaches a
-token, so it can never ride a redirect to a CDN host.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from contextlib import asynccontextmanager
-from typing import AsyncIterator, Optional
-from urllib.parse import unquote, urljoin, urlsplit, urlunsplit
-
-import aiohttp
-
-from app.model_downloader.auth.resolver import resolve_auth_for_hop
-from app.model_downloader.net.session import get_session
-from app.model_downloader.security.ssrf import (
-    MAX_REDIRECTS,
-    SSRFError,
-    check_redirect_hop,
-)
-
-_REDIRECT_CODES = {301, 302, 303, 307, 308}
-DEFAULT_TIMEOUT = aiohttp.ClientTimeout(total=None, sock_connect=30, sock_read=120)
-
-
-def redact_url(url: str) -> str:
-    """Drop the query string so a query-scheme secret is never logged/stored."""
-    try:
-        parts = urlsplit(url)
-    except ValueError:
-        return "<unparseable-url>"
-    return urlunsplit(parts._replace(query=""))
-
-
-_CD_FILENAME_STAR = re.compile(
-    r"filename\*\s*=\s*[^']*'[^']*'([^;]+)", re.IGNORECASE
-)
-_CD_FILENAME_QUOTED = re.compile(r'filename\s*=\s*"([^"]+)"', re.IGNORECASE)
-_CD_FILENAME_BARE = re.compile(r"filename\s*=\s*([^;]+)", re.IGNORECASE)
-
-
-def filename_from_content_disposition(value: Optional[str]) -> Optional[str]:
-    """Extract the download filename from a ``Content-Disposition`` header.
-
-    Prefers the RFC 5987 ``filename*=`` form (percent-decoded) over the plain
-    ``filename=`` form. Any directory components in the value are stripped so a
-    hostile header can only influence the *name*, never the target directory.
-    Returns ``None`` when no filename is present.
-    """
-    if not value:
-        return None
-    for pat, decode in (
-        (_CD_FILENAME_STAR, True),
-        (_CD_FILENAME_QUOTED, False),
-        (_CD_FILENAME_BARE, False),
-    ):
-        m = pat.search(value)
-        if not m:
-            continue
-        raw = m.group(1).strip().strip('"')
-        if decode:
-            try:
-                raw = unquote(raw)
-            except Exception:
-                pass
-        name = raw.replace("\\", "/").rsplit("/", 1)[-1].strip()
-        if name:
-            return name
-    return None
-
-
-async def _resolve_final_response(
-    method: str,
-    url: str,
-    base_headers: dict[str, str],
-    timeout: aiohttp.ClientTimeout,
-) -> tuple[aiohttp.ClientResponse, str]:
-    """Follow redirects manually until a non-redirect response.
-
-    Each intermediate redirect response is released before the next hop.
-    Returns the final ``(response, final_url)``; the caller owns releasing it.
-    """
-    session = await get_session()
-    current = url
-    hops = 0
-    while True:
-        check_redirect_hop(current, is_initial_url=(hops == 0))
-        parts = urlsplit(current)
-        auth = await resolve_auth_for_hop(parts.hostname or "", parts.scheme)
-        req_headers = dict(base_headers)
-        if auth is not None:
-            req_headers.update(auth.headers)
-
-        resp = await session.request(
-            method,
-            current,
-            allow_redirects=False,
-            headers=req_headers,
-            timeout=timeout,
-        )
-        if resp.status in _REDIRECT_CODES and resp.headers.get("Location"):
-            next_url = urljoin(str(resp.url), resp.headers["Location"])
-            await resp.release()
-            hops += 1
-            if hops > MAX_REDIRECTS:
-                raise SSRFError(
-                    f"too many redirects (> {MAX_REDIRECTS}) for {redact_url(url)}"
-                )
-            current = next_url
-            continue
-        return resp, redact_url(str(resp.url))
-
-
-@asynccontextmanager
-async def open_validated(
-    method: str,
-    url: str,
-    *,
-    headers: Optional[dict[str, str]] = None,
-    timeout: aiohttp.ClientTimeout = DEFAULT_TIMEOUT,
-) -> AsyncIterator[tuple[aiohttp.ClientResponse, str]]:
-    """Open ``method url`` following redirects manually and validated.
-
-    Yields ``(response, final_url)`` where ``final_url`` is redacted of any
-    query string. The response is released automatically on exit.
-    """
-    resp, final_url = await _resolve_final_response(
-        method, url, dict(headers or {}), timeout
-    )
-    try:
-        yield resp, final_url
-    finally:
-        try:
-            await resp.release()
-        except Exception:  # pragma: no cover - best-effort cleanup
-            logging.debug("[model_downloader] response release error", exc_info=True)

app/model_downloader/net/probe.py

@@ -1,192 +0,0 @@
-"""Pre-download probe.
-
-Issues a tiny ranged GET (``Range: bytes=0-0``) — which doubles as a
-range-support test — to discover ``Content-Length``, ``Accept-Ranges``,
-``ETag``/``Last-Modified``, and the final post-redirect URL. For HuggingFace
-LFS files the true size also appears in the non-standard ``X-Linked-Size``
-header, which we read as a fallback.
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from typing import Optional
-from urllib.parse import urlparse, urlsplit
-
-import aiohttp
-
-from app.model_downloader.net.http import (
-    filename_from_content_disposition,
-    open_validated,
-    redact_url,
-)
-from app.model_downloader.net.session import parse_int_header
-
-_PROBE_TIMEOUT = aiohttp.ClientTimeout(total=60, sock_connect=30, sock_read=30)
-
-
-@dataclass
-class ProbeResult:
-    ok: bool
-    status: int
-    final_url: Optional[str] = None
-    total_bytes: Optional[int] = None
-    accept_ranges: bool = False
-    etag: Optional[str] = None
-    last_modified: Optional[str] = None
-    gated: bool = False  # 401/403 — needs (or has wrong) credentials
-    error: Optional[str] = None
-    # HuggingFace's ``X-Error-Code`` header (e.g. ``GatedRepo``,
-    # ``RepoNotFound``) when the host reports one. Lets us tell "this repo is
-    # gated — request access" apart from "you just need a token".
-    error_code: Optional[str] = None
-    # Filename the server intends this response to be saved as: the
-    # ``Content-Disposition`` name if present, else the post-redirect URL's
-    # basename. Used to resolve the real extension for URLs (e.g. Civitai's
-    # ``/api/download`` endpoints) that carry no extension in their path.
-    filename: Optional[str] = None
-
-    @property
-    def is_gated_repo(self) -> bool:
-        """True when the host says the repo is gated (access must be granted).
-
-        Distinct from a plain missing/invalid token: even a valid credential
-        won't help until the user accepts the model's terms on its page.
-        """
-        return (self.error_code or "").lower() == "gatedrepo"
-
-
-def _error_detail(error_code: Optional[str], error_message: Optional[str]) -> str:
-    """Format the host's ``X-Error-Code``/``X-Error-Message`` for logs/messages."""
-    detail = ": ".join(p.strip() for p in (error_code, error_message) if p and p.strip())
-    return f" ({detail})" if detail else ""
-
-
-def _probe_failure_message(
-    status: int, error_code: Optional[str], error_message: Optional[str]
-) -> str:
-    msg = f"probe returned HTTP {status}{_error_detail(error_code, error_message)}"
-    if status == 404:
-        # HuggingFace returns 404 (not 403) for a private repo the current
-        # credentials cannot see, so it is indistinguishable from a missing
-        # file without the hint. Name both causes so the user can check the
-        # URL or their access/token scope.
-        msg += (
-            " — the file may not exist, or it is private/gated and the "
-            "credentials in use lack access to it"
-        )
-    return msg
-
-
-def _total_from_content_range(value: Optional[str]) -> Optional[int]:
-    # "bytes 0-0/12345" -> 12345 ; "bytes 0-0/*" -> None
-    if not value or "/" not in value:
-        return None
-    total = value.rsplit("/", 1)[1].strip()
-    return parse_int_header(total)
-
-
-def _filename_from_response(
-    content_disposition: Optional[str], final_url: Optional[str]
-) -> Optional[str]:
-    name = filename_from_content_disposition(content_disposition)
-    if name:
-        return name
-    if final_url:
-        base = urlsplit(final_url).path.rsplit("/", 1)[-1]
-        if base:
-            return base
-    return None
-
-
-async def probe(url: str) -> ProbeResult:
-    """Probe ``url`` and return discovered metadata, failing soft."""
-    try:
-        async with open_validated(
-            "GET",
-            url,
-            headers={"Range": "bytes=0-0", "Accept-Encoding": "identity"},
-            timeout=_PROBE_TIMEOUT,
-        ) as (resp, final_url):
-            # HuggingFace (and some others) report the real reason in these
-            # headers on any status, including 404 for a private/missing repo.
-            error_code = resp.headers.get("X-Error-Code")
-            error_message = resp.headers.get("X-Error-Message")
-            if resp.status in (401, 403):
-                logging.warning(
-                    "[model_downloader] probe %s -> HTTP %d%s",
-                    redact_url(final_url or url), resp.status,
-                    _error_detail(error_code, error_message),
-                )
-                return ProbeResult(
-                    ok=False, status=resp.status, final_url=final_url, gated=True,
-                    error_code=error_code,
-                    error=(
-                        error_message
-                        or f"host returned {resp.status} (authentication required)"
-                    ),
-                )
-            if resp.status not in (200, 206):
-                logging.warning(
-                    "[model_downloader] probe %s -> HTTP %d%s",
-                    redact_url(final_url or url), resp.status,
-                    _error_detail(error_code, error_message),
-                )
-                return ProbeResult(
-                    ok=False, status=resp.status, final_url=final_url,
-                    error_code=error_code,
-                    error=_probe_failure_message(resp.status, error_code, error_message),
-                )
-
-            headers = resp.headers
-            accept_ranges = False
-            total: Optional[int] = None
-            if resp.status == 206:
-                accept_ranges = True
-                total = _total_from_content_range(headers.get("Content-Range"))
-            else:  # 200: server ignored the range
-                accept_ranges = headers.get("Accept-Ranges", "").lower() == "bytes"
-                total = parse_int_header(headers.get("Content-Length"))
-
-            if total is None:
-                total = parse_int_header(headers.get("X-Linked-Size"))
-
-            return ProbeResult(
-                ok=True,
-                status=resp.status,
-                final_url=final_url,
-                total_bytes=total,
-                accept_ranges=accept_ranges,
-                etag=headers.get("ETag"),
-                last_modified=headers.get("Last-Modified"),
-                filename=_filename_from_response(
-                    headers.get("Content-Disposition"), final_url
-                ),
-            )
-    except Exception as e:  # network / SSRF / timeout
-        host = urlparse(url).netloc or "<unknown>"
-        logging.debug("[model_downloader] probe failed for %s: %s", host, type(e).__name__)
-        return ProbeResult(ok=False, status=0, error="probe failed: network error")
-
-
-def gated_error_message(url: str, pr: ProbeResult) -> str:
-    """Build a user-facing message for a gated/auth-required probe result.
-
-    Distinguishes a *gated* repo (access must be requested/granted on the model
-    page — a token alone is not enough) from a plain missing/invalid credential.
-    """
-    redacted = redact_url(url)
-    if pr.is_gated_repo:
-        detail = (pr.error or "access is restricted").rstrip()
-        if detail and not detail.endswith((".", "!", "?")):
-            detail += "."
-        return (
-            f"{redacted} is a gated model — {detail} Request access on the model's "
-            f"page, authenticate this host via /api/download/auth (or set its API "
-            f"key env var), and retry."
-        )
-    return (
-        f"{redacted} requires authentication. Authenticate this host via "
-        f"/api/download/auth or set its API key env var, and retry."
-    )

app/model_downloader/net/session.py

@@ -1,72 +0,0 @@
-"""Lazily-created shared :class:`aiohttp.ClientSession`.
-
-A single session reuses TLS handshakes and TCP connections across the probe
-and the many segment GETs to the same host (HuggingFace is the dominant
-case), which is a large speedup on cold connections and exactly the
-connection-reuse strategy that lets us match aria2c.
-
-The connector uses :class:`ValidatingResolver` so every connection — initial
-or post-redirect — is screened for private/special-use IPs at connect time.
-TLS is pinned to certifi's CA bundle because the OS trust store is not wired
-up on some Python installs (python.org macOS, slim containers).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import ssl
-from typing import Optional
-
-import aiohttp
-
-try:
-    import certifi
-    _CA_FILE = certifi.where()
-except Exception:  # pragma: no cover - certifi is a transitive dep of aiohttp
-    _CA_FILE = None
-
-from comfy.cli_args import args
-from app.model_downloader.security.ssrf import ValidatingResolver
-
-_session: Optional[aiohttp.ClientSession] = None
-_lock = asyncio.Lock()
-
-
-def ssl_context() -> ssl.SSLContext:
-    if _CA_FILE is not None:
-        return ssl.create_default_context(cafile=_CA_FILE)
-    return ssl.create_default_context()
-
-
-async def get_session() -> aiohttp.ClientSession:
-    """Return the shared session, creating it on first use."""
-    global _session
-    if _session is not None and not _session.closed:
-        return _session
-    async with _lock:
-        if _session is None or _session.closed:
-            connector = aiohttp.TCPConnector(
-                limit_per_host=max(1, getattr(args, "download_max_connections_per_host", 16)),
-                ssl=ssl_context(),
-                resolver=ValidatingResolver(),
-            )
-            _session = aiohttp.ClientSession(connector=connector)
-    return _session
-
-
-async def close_session() -> None:
-    global _session
-    if _session is not None and not _session.closed:
-        await _session.close()
-    _session = None
-
-
-def parse_int_header(value: Optional[str]) -> Optional[int]:
-    """Parse a non-negative integer header value, or None if bad/absent."""
-    if not value:
-        return None
-    try:
-        n = int(value)
-    except (TypeError, ValueError):
-        return None
-    return n if n >= 0 else None

app/model_downloader/scheduler.py

@@ -1,176 +0,0 @@
-"""Priority scheduler + lifecycle.
-
-Owns the set of running jobs and admits queued downloads up to a global
-concurrency limit (K), highest priority first, FIFO within a priority. Runs
-entirely on the existing ComfyUI asyncio loop; blocking work (disk, hashing,
-DB) is offloaded by the job/writer layers.
-
-On startup it reconciles DB vs. disk: ``active``/``verifying`` rows left by a
-previous run are reset to ``queued`` and resumed from persisted offsets, and
-orphaned ``.part`` files with no live download row are swept.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import random
-import time
-from typing import Callable, Optional
-
-from comfy.cli_args import args
-from app.model_downloader.constants import DownloadStatus
-from app.model_downloader.database import queries
-from app.model_downloader.engine.job import DownloadJob, JobSpec
-from app.model_downloader.security import paths
-
-# Backoff for retryable failures
-_BACKOFF_BASE = 2.0
-_BACKOFF_CAP = 300.0
-_MAX_ATTEMPTS = 6
-
-
-class Scheduler:
-    def __init__(self) -> None:
-        self._jobs: dict[str, DownloadJob] = {}
-        self._tasks: dict[str, asyncio.Task] = {}
-        self._backoff_until: dict[str, float] = {}
-        self._pump_lock = asyncio.Lock()
-        self._notify_cb: Optional[Callable[[str], None]] = None
-        self._started = False
-
-    @property
-    def max_active(self) -> int:
-        return max(1, getattr(args, "download_max_active", 3))
-
-    def set_notify(self, cb: Optional[Callable[[str], None]]) -> None:
-        self._notify_cb = cb
-
-    def get_job(self, download_id: str) -> Optional[DownloadJob]:
-        return self._jobs.get(download_id)
-
-    def is_active(self, download_id: str) -> bool:
-        return download_id in self._tasks
-
-    # ----- startup -----
-
-    async def start(self) -> None:
-        if self._started:
-            return
-        self._started = True
-        try:
-            await asyncio.to_thread(queries.reconcile_live_downloads)
-            await asyncio.to_thread(self._sweep_orphan_temp_files)
-        except Exception as e:
-            logging.warning("[model_downloader] startup reconcile failed: %s", e)
-        await self.pump()
-
-    @staticmethod
-    def _sweep_orphan_temp_files() -> None:
-        """Remove ``.part`` files not referenced by a resumable download row.
-
-        Resumable partials are preserved; only truly orphaned temp files from
-        crashed runs are deleted. ``FAILED`` is included because
-        :meth:`DownloadManager.resume` explicitly permits resuming a
-        retry-exhausted failed row: deleting its partial here while the
-        per-segment offsets survive in the DB would make the next resume
-        preallocate a fresh sparse file, skip every "complete" segment, and
-        leave zero-filled holes that pass the size-only verification gate.
-        """
-        live = {
-            row.temp_path
-            for row in queries.list_downloads()
-            if row.status
-            in (
-                DownloadStatus.QUEUED,
-                DownloadStatus.PAUSED,
-                DownloadStatus.FAILED,
-            )
-        }
-        for path in paths.iter_all_tmp_paths():
-            if path in live:
-                continue
-            try:
-                os.remove(path)
-                logging.info("[model_downloader] removed orphan temp file: %s", path)
-            except OSError as e:
-                logging.warning("[model_downloader] could not remove %s: %s", path, e)
-
-    # ----- admission -----
-
-    async def pump(self) -> None:
-        async with self._pump_lock:
-            slots = self.max_active - len(self._tasks)
-            if slots <= 0:
-                return
-            now = time.monotonic()
-            candidates = await asyncio.to_thread(queries.list_queued_downloads)
-            for row in candidates:
-                if slots <= 0:
-                    break
-                if row.id in self._tasks:
-                    continue
-                if self._backoff_until.get(row.id, 0.0) > now:
-                    continue
-                self._admit(row)
-                slots -= 1
-
-    def _admit(self, row) -> None:
-        spec = JobSpec(
-            download_id=row.id,
-            url=row.url,
-            model_id=row.model_id,
-            dest_path=row.dest_path,
-            temp_path=row.temp_path,
-            priority=row.priority,
-            expected_sha256=row.expected_sha256,
-            allow_any_extension=row.allow_any_extension,
-            etag=row.etag,
-            attempts=row.attempts,
-        )
-        job = DownloadJob(spec, notify_cb=self._notify_cb)
-        self._jobs[row.id] = job
-        self._tasks[row.id] = asyncio.ensure_future(self._run_job(job))
-
-    async def _run_job(self, job: DownloadJob) -> None:
-        download_id = job.spec.download_id
-        status = DownloadStatus.FAILED
-        try:
-            status = await job.run()
-        except Exception as e:  # run() is defensive, but never let a task die silently
-            logging.error("[model_downloader] job %s crashed: %s", download_id, e)
-            queries.update_download(
-                download_id,
-                status=DownloadStatus.FAILED,
-                error=f"internal error: {e}",
-            )
-            if self._notify_cb:
-                self._notify_cb(download_id)
-        finally:
-            self._tasks.pop(download_id, None)
-            self._jobs.pop(download_id, None)
-
-        if status == DownloadStatus.QUEUED:
-            if job.spec.attempts >= _MAX_ATTEMPTS:
-                queries.update_download(
-                    download_id,
-                    status=DownloadStatus.FAILED,
-                    error=f"giving up after {job.spec.attempts} attempts",
-                )
-                if self._notify_cb:
-                    self._notify_cb(download_id)
-            else:
-                delay = min(
-                    _BACKOFF_CAP, _BACKOFF_BASE ** job.spec.attempts
-                ) + random.uniform(0, 1.0)
-                self._backoff_until[download_id] = time.monotonic() + delay
-                asyncio.ensure_future(self._delayed_pump(delay))
-        await self.pump()
-
-    async def _delayed_pump(self, delay: float) -> None:
-        await asyncio.sleep(delay)
-        await self.pump()
-
-
-SCHEDULER = Scheduler()

app/model_downloader/security/allowlist.py

@@ -1,140 +0,0 @@
-"""URL allowlist for server-side model fetches.
-
-Default-deny. A URL is downloadable only when its parsed host + scheme are
-allowlisted AND (unless explicitly relaxed) its final filename ends in a
-known model extension.
-
-The built-in host defaults mirror the frontend's ``isModelDownloadable``
-allowlist so the two flows agree on what is eligible; ``--download-allowed-hosts``
-extends it for self-hosted mirrors. Matching is done on ``urlparse().hostname``
-(never a raw string prefix) so userinfo tricks like
-``http://127.0.0.1@169.254.169.254/x.safetensors`` — whose real host is the
-metadata IP — cannot slip past.
-"""
-
-from __future__ import annotations
-
-from urllib.parse import urlparse
-
-from comfy.cli_args import args
-
-# host -> set of allowed schemes. Frontend parity (HuggingFace / Civitai /
-# localhost). Extra hosts from --download-allowed-hosts are https-only.
-_DEFAULT_ALLOWED_HOSTS: dict[str, set[str]] = {
-    "huggingface.co": {"https"},
-    "civitai.com": {"https"},
-    "localhost": {"http", "https"},
-    "127.0.0.1": {"http", "https"},
-}
-
-# Hosts for which loopback addresses are intentionally permitted (the localhost
-# "download a local model" feature). Every other host's loopback resolution is
-# rejected by the SSRF resolver.
-LOOPBACK_HOSTS = frozenset({"localhost", "127.0.0.1", "::1"})
-
-# Known model file extensions (frontend parity). Checked on the final filename.
-ALLOWED_MODEL_EXTENSIONS = (
-    ".safetensors",
-    ".sft",
-    ".ckpt",
-    ".pth",
-    ".pt",
-    ".gguf",
-    ".bin",
-)
-
-
-def _allowed_hosts() -> dict[str, set[str]]:
-    hosts = {h: set(s) for h, s in _DEFAULT_ALLOWED_HOSTS.items()}
-    for extra in getattr(args, "download_allowed_hosts", []) or []:
-        host = extra.strip().lower()
-        if host:
-            hosts.setdefault(host, set()).add("https")
-    return hosts
-
-
-def is_host_allowed(host: str | None, scheme: str | None) -> bool:
-    """True iff ``host`` is allowlisted for ``scheme``.
-
-    Used both for the initial URL and re-checked on every redirect hop,
-    so a whitelisted URL cannot 30x into an off-list host.
-    """
-    if not host or not scheme:
-        return False
-    allowed = _allowed_hosts().get(host.lower())
-    return allowed is not None and scheme.lower() in allowed
-
-
-def has_allowed_extension(path: str, allow_any_extension: bool = False) -> bool:
-    if allow_any_extension:
-        return True
-    return path.lower().endswith(ALLOWED_MODEL_EXTENSIONS)
-
-
-def filename_extension(name: str) -> str:
-    """Lowercased extension (including the leading dot) of a bare filename.
-
-    Returns ``""`` when there is no extension. A leading-dot name
-    (``.safetensors``) is treated as having no extension (all stem), matching
-    ``os.path.splitext`` semantics so dotfiles aren't mistaken for typed files.
-    """
-    base = name.replace("\\", "/").rsplit("/", 1)[-1]
-    dot = base.rfind(".")
-    if dot <= 0:
-        return ""
-    return base[dot:].lower()
-
-
-def is_allowed_extension_name(name: str) -> bool:
-    """True iff ``name`` ends in one of the known model extensions."""
-    return name.lower().endswith(ALLOWED_MODEL_EXTENSIONS)
-
-
-def is_host_allowed_url(url: str) -> bool:
-    """True iff ``url`` parses and its host+scheme are allowlisted."""
-    if not isinstance(url, str) or not url:
-        return False
-    try:
-        parsed = urlparse(url)
-    except ValueError:
-        return False
-    return is_host_allowed(parsed.hostname, parsed.scheme)
-
-
-def url_path_extension(url: str) -> str:
-    """Extension of the URL *path* basename (query ignored), or ``""``."""
-    try:
-        parsed = urlparse(url)
-    except ValueError:
-        return ""
-    return filename_extension(parsed.path)
-
-
-def is_url_downloadable(url: str) -> bool:
-    """Coarse enqueue gate: host/scheme allowed and extension not disallowed.
-
-    Unlike :func:`is_url_allowed` (which demands a known extension *in the URL*),
-    this also admits URLs whose path carries no extension at all — e.g. a Civitai
-    ``/api/download/models/<id>`` endpoint whose real filename only shows up in
-    the redirect target / ``Content-Disposition``. The true extension is then
-    resolved from the network and re-validated before the download is admitted.
-    A path bearing an explicit *non-model* extension (``.zip``, ``.html``, ...)
-    is still rejected here.
-    """
-    if not is_host_allowed_url(url):
-        return False
-    ext = url_path_extension(url)
-    return ext == "" or ext in ALLOWED_MODEL_EXTENSIONS
-
-
-def is_url_allowed(url: str, allow_any_extension: bool = False) -> bool:
-    """Check whether ``url`` is permitted as a server-side download source."""
-    if not isinstance(url, str) or not url:
-        return False
-    try:
-        parsed = urlparse(url)
-    except ValueError:
-        return False
-    if not is_host_allowed(parsed.hostname, parsed.scheme):
-        return False
-    return has_allowed_extension(parsed.path, allow_any_extension)

app/model_downloader/security/paths.py

@@ -1,132 +0,0 @@
-"""Path resolution + traversal safety for downloads.
-
-A ``model_id`` is a *relative destination path* of the form
-``<directory>/<filename>`` (e.g. ``loras/my_lora.safetensors``). This module
-turns one into an absolute on-disk path under one of ComfyUI's registered
-model folders, rejecting unknown folders, path traversal, and symlink escape.
-This is the only thing that composes destination paths, so the engine never
-touches user-supplied path strings directly.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-from typing import Iterator, Optional
-
-import folder_paths
-
-from app.model_downloader.constants import TMP_SUFFIX
-from app.model_downloader.security.allowlist import ALLOWED_MODEL_EXTENSIONS
-
-# A model_id component is a single path segment of safe characters — no slashes,
-# no "..", no leading dots that could escape the target directory.
-_SEGMENT_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
-
-
-class InvalidModelId(ValueError):
-    """Raised when a model_id is malformed or names an unknown model folder."""
-
-
-def parse_model_id(model_id: str, allow_any_extension: bool = False) -> tuple[str, str]:
-    """Split ``<directory>/<filename>`` and validate both components.
-
-    Returns ``(directory, filename)``. Does not touch the filesystem.
-    """
-    if not isinstance(model_id, str) or "/" not in model_id:
-        raise InvalidModelId(
-            f"model_id must be '<directory>/<filename>', got {model_id!r}"
-        )
-    directory, _, filename = model_id.partition("/")
-    if "/" in filename or not directory or not filename:
-        raise InvalidModelId(
-            f"model_id must have exactly one '/' separator, got {model_id!r}"
-        )
-    if not _SEGMENT_RE.match(directory):
-        raise InvalidModelId(f"invalid directory segment {directory!r}")
-    if not _SEGMENT_RE.match(filename):
-        raise InvalidModelId(f"invalid filename segment {filename!r}")
-    if not allow_any_extension and not filename.lower().endswith(
-        ALLOWED_MODEL_EXTENSIONS
-    ):
-        raise InvalidModelId(
-            f"filename must end with a known model extension "
-            f"{ALLOWED_MODEL_EXTENSIONS}, got {filename!r}"
-        )
-    if directory not in folder_paths.folder_names_and_paths:
-        raise InvalidModelId(f"unknown model folder {directory!r}")
-    return directory, filename
-
-
-def apply_extension(model_id: str, ext: str) -> str:
-    """Return ``model_id`` with its filename forced to end in ``ext``.
-
-    ``ext`` includes the leading dot (e.g. ``".safetensors"``). If the filename
-    already ends in a *known model extension* it is replaced; otherwise ``ext``
-    is appended (so ``loras/mymodel`` -> ``loras/mymodel.safetensors`` and
-    ``loras/mymodel.ckpt`` -> ``loras/mymodel.safetensors``). A filename with a
-    non-model suffix (``my.model.v2``) is treated as an extensionless stem and
-    ``ext`` is appended. The directory part is left untouched; validation is
-    still the caller's job via :func:`parse_model_id`.
-    """
-    directory, sep, filename = model_id.partition("/")
-    if not sep:
-        return model_id  # malformed; parse_model_id will reject it
-    low = filename.lower()
-    for known in ALLOWED_MODEL_EXTENSIONS:
-        if low.endswith(known):
-            filename = filename[: -len(known)]
-            break
-    return f"{directory}{sep}{filename}{ext}"
-
-
-def resolve_existing(model_id: str, allow_any_extension: bool = False) -> Optional[str]:
-    """Return the absolute path of an installed model, or None if missing.
-
-    Honours ``extra_model_paths.yaml`` transparently via ``get_full_path``.
-    """
-    directory, filename = parse_model_id(model_id, allow_any_extension)
-    return folder_paths.get_full_path(directory, filename)
-
-
-def resolve_destination(
-    model_id: str, allow_any_extension: bool = False
-) -> tuple[str, str]:
-    """Return ``(final_path, temp_path)`` for a download.
-
-    Downloads land at the first registered path for the model's directory
-    (the "primary" location). ``temp_path`` is a sibling ``.part`` file that
-    is atomically renamed onto ``final_path`` on success. The result is
-    asserted to stay within the registered root (defence in depth on top of
-    the segment regex).
-    """
-    directory, filename = parse_model_id(model_id, allow_any_extension)
-    roots = folder_paths.get_folder_paths(directory)
-    if not roots:
-        raise InvalidModelId(f"no on-disk path registered for folder {directory!r}")
-    root = os.path.realpath(roots[0])
-    final_path = os.path.realpath(os.path.join(root, filename))
-    if final_path != root and not final_path.startswith(root + os.sep):
-        raise InvalidModelId(f"resolved path escapes model root: {model_id!r}")
-    temp_path = f"{final_path}{TMP_SUFFIX}"
-    return final_path, temp_path
-
-
-def iter_all_tmp_paths() -> Iterator[str]:
-    """Yield this subsystem's temp files under every registered model folder.
-
-    Matches only the distinctive ``TMP_SUFFIX`` so the startup orphan sweep
-    can never delete temp files created by other tools.
-    """
-    seen_roots: set[str] = set()
-    for directory in list(folder_paths.folder_names_and_paths.keys()):
-        for root in folder_paths.get_folder_paths(directory):
-            if root in seen_roots or not os.path.isdir(root):
-                continue
-            seen_roots.add(root)
-            try:
-                for entry in os.scandir(root):
-                    if entry.is_file() and entry.name.endswith(TMP_SUFFIX):
-                        yield entry.path
-            except OSError:
-                continue

app/model_downloader/security/ssrf.py

@@ -1,163 +0,0 @@
-"""SSRF / exfiltration defenses.
-
-Two cooperating layers:
-
-1. :class:`ValidatingResolver` is installed on the shared connector. Every
-   connection — the initial probe and every segment GET, including ones made
-   after a redirect — resolves its host through this resolver, which rejects
-   any address that lands on a private / special-use IP range. Because the
-   resolve and the connect happen together inside the connector, there is no
-   check-then-connect window for DNS rebinding to exploit.
-
-2. :func:`check_redirect_hop` re-validates every hop. The host allowlist gates
-   only the *initial* user-supplied URL (anti-SSRF for arbitrary input);
-   legitimate downloads from allowlisted origins redirect to presigned CDN
-   hosts that are deliberately NOT on the allowlist (HF ->
-   ``cdn-lfs*.huggingface.co``, Civitai -> signed Cloudflare/S3), so hops are
-   instead screened for scheme, embedded credentials, and — via the resolver
-   above — private IPs. Credentials are only ever attached when a hop's host
-   exactly matches a stored credential, so they are dropped on the CDN hop.
-   Loopback (the "download a local model" feature) is exempt from IP filtering
-   only for the initial URL: a *redirect* may never target a loopback host or
-   a blocked IP-literal, which the resolver alone can't enforce (it exempts
-   loopback literals and never sees IP literals through DNS).
-"""
-
-from __future__ import annotations
-
-import ipaddress
-import socket
-from urllib.parse import urlparse
-
-from aiohttp.abc import AbstractResolver
-from aiohttp.resolver import DefaultResolver
-
-from app.model_downloader.security.allowlist import LOOPBACK_HOSTS
-
-# Cap the redirect chain length a hop may use.
-MAX_REDIRECTS = 5
-
-
-class SSRFError(Exception):
-    """A hop failed an SSRF / allowlist check."""
-
-
-def is_scheme_allowed(scheme: str | None, host: str | None) -> bool:
-    """True iff ``scheme`` is permitted for ``host`` on a download hop.
-
-    https is always allowed; plain http only for loopback/approved dev hosts.
-    """
-    if not scheme:
-        return False
-    scheme = scheme.lower()
-    if scheme == "https":
-        return True
-    if scheme == "http":
-        return bool(host) and host.lower() in LOOPBACK_HOSTS
-    return False
-
-
-def is_blocked_ip(ip_str: str) -> bool:
-    """True for any address we refuse to connect to.
-
-    Covers loopback, link-local (incl. 169.254.169.254 cloud metadata),
-    RFC1918 private ranges, unique-local (ULA), unspecified (0.0.0.0/::),
-    multicast and other reserved ranges.
-    """
-    try:
-        ip = ipaddress.ip_address(ip_str)
-    except ValueError:
-        return True  # unparseable -> refuse
-    # On CPython before the gh-113171 fix (backported to 3.12.4/3.11.9/
-    # 3.10.14/3.9.19) the is_* properties don't see through IPv4-mapped IPv6
-    # (e.g. ::ffff:169.254.169.254), so resolve and re-check the embedded IPv4
-    # to keep mapped metadata/private addresses from slipping past the filter.
-    mapped = getattr(ip, "ipv4_mapped", None)
-    if mapped is not None:
-        ip = mapped
-    return (
-        ip.is_private
-        or ip.is_loopback
-        or ip.is_link_local
-        or ip.is_multicast
-        or ip.is_reserved
-        or ip.is_unspecified
-    )
-
-
-class ValidatingResolver(AbstractResolver):
-    """Delegating resolver that drops blocked IPs from every resolution.
-
-    If a hostname resolves only to blocked addresses, the connection fails
-    closed with an :class:`OSError`, which aiohttp surfaces as a connection
-    error to the caller.
-    """
-
-    def __init__(self) -> None:
-        self._inner = DefaultResolver()
-
-    async def resolve(self, host, port=0, family=socket.AF_INET):
-        infos = await self._inner.resolve(host, port, family)
-        # localhost/127.0.0.1 are an explicit, opt-in allowlist feature.
-        if isinstance(host, str) and host.lower() in LOOPBACK_HOSTS:
-            return infos
-        safe = [info for info in infos if not is_blocked_ip(info["host"])]
-        if not safe:
-            raise OSError(
-                f"refusing to connect to {host!r}: resolves only to "
-                f"private/special-use addresses"
-            )
-        return safe
-
-    async def close(self) -> None:
-        await self._inner.close()
-
-
-def check_redirect_hop(url: str, *, is_initial_url: bool = False) -> str:
-    """Validate one hop's URL.
-
-    Returns the URL unchanged on success; raises :class:`SSRFError` otherwise.
-    Requires https for external hosts (http only for loopback/approved dev
-    hosts) and forbids credentials-in-URL. The host is NOT re-checked against
-    the allowlist (CDN redirect targets are off-list by design); credential
-    leakage is prevented by exact host matching at attach time, and the landing
-    filename's extension is gated separately by the caller.
-
-    Loopback/blocked-IP screening: the connector's resolver filters resolvable
-    hostnames but exempts literal loopback hosts (``localhost``/``127.0.0.1``/
-    ``::1``) and never sees IP literals through DNS. That loopback exemption is
-    legitimate only for the *initial* user-supplied URL (``is_initial_url``);
-    on a redirect hop we reject loopback hosts and any blocked IP-literal here,
-    so a 30x can't steer a server-side GET at loopback/internal services.
-    """
-    try:
-        parsed = urlparse(url)
-    except ValueError as e:
-        raise SSRFError(f"unparseable redirect URL {url!r}: {e}") from e
-    host = parsed.hostname
-    if not host:
-        raise SSRFError(f"redirect URL has no host: {url!r}")
-    if not is_scheme_allowed(parsed.scheme, host):
-        raise SSRFError(
-            f"redirect to disallowed scheme {parsed.scheme!r} for host "
-            f"{host!r} (https required for external hosts)"
-        )
-    if parsed.username or parsed.password:
-        raise SSRFError("credentials-in-URL are not allowed")
-    host_is_loopback = host.lower() in LOOPBACK_HOSTS
-    if not is_initial_url and host_is_loopback:
-        raise SSRFError(f"redirect to loopback host {host!r} is not allowed")
-    # IP-literal targets never go through DNS, so the connector's resolver can't
-    # screen them — check them directly. The only blocked IP allowed through is
-    # a loopback literal on the initial URL (handled by the exemption above).
-    try:
-        ipaddress.ip_address(host)
-    except ValueError:
-        is_ip_literal = False
-    else:
-        is_ip_literal = True
-    if is_ip_literal and is_blocked_ip(host) and not (
-        is_initial_url and host_is_loopback
-    ):
-        raise SSRFError(f"redirect to blocked internal address {host!r}")
-    return url

app/model_downloader/verify/checksum.py

@@ -1,49 +0,0 @@
-"""Hub-checksum verification = SHA256.
-
-Only used to confirm a download matches a *provided* ``expected_sha256``. It
-is NOT the dedup key (that is blake3, owned by the assets system). The full
-sequential read happens at most once, here, only when a checksum was supplied.
-"""
-
-from __future__ import annotations
-
-import hashlib
-from typing import Callable, Optional
-
-_CHUNK = 8 * 1024 * 1024
-
-InterruptCheck = Callable[[], bool]
-
-
-class ChecksumError(Exception):
-    """The computed SHA256 did not match the expected value."""
-
-
-def sha256_file(path: str, interrupt_check: Optional[InterruptCheck] = None) -> Optional[str]:
-    """Stream the file and return its lowercase hex SHA256.
-
-    Returns ``None`` if interrupted via ``interrupt_check``.
-    """
-    h = hashlib.sha256()
-    with open(path, "rb") as f:
-        while True:
-            if interrupt_check is not None and interrupt_check():
-                return None
-            chunk = f.read(_CHUNK)
-            if not chunk:
-                break
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def verify_sha256(
-    path: str, expected: str, interrupt_check: Optional[InterruptCheck] = None
-) -> None:
-    """Raise :class:`ChecksumError` unless the file's SHA256 matches ``expected``."""
-    actual = sha256_file(path, interrupt_check)
-    if actual is None:
-        return  # interrupted; caller will re-verify on resume
-    if actual.lower() != expected.lower():
-        raise ChecksumError(
-            f"sha256 mismatch: expected {expected.lower()}, got {actual.lower()}"
-        )

app/model_downloader/verify/dedup.py

@@ -1,53 +0,0 @@
-"""Dedup + catalog handoff — reuse the assets system.
-
-We do NOT build a parallel indexer. "Do I already have it?" is answered by
-``resolve_existing`` (path) at enqueue time and, where a hash is known, by the
-assets blake3 catalog. After a completed download we register the file
-through the assets ingest path so it is cataloged and (eventually) hashed by
-the existing enrichment worker.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-from typing import Optional
-
-
-def _register_sync(abs_path: str) -> Optional[str]:
-    """Register a finished file into the assets catalog. Returns asset hash."""
-    try:
-        from app.assets.services.ingest import register_file_in_place
-    except Exception as e:  # assets package import failure — non-fatal
-        logging.debug("[model_downloader] assets ingest unavailable: %s", e)
-        return None
-    try:
-        result = register_file_in_place(abs_path, name=os.path.basename(abs_path), tags=[])
-        return result.asset.hash if result and result.asset else None
-    except Exception as e:
-        # The file is already safely on disk; cataloging is best-effort.
-        logging.warning(
-            "[model_downloader] could not register %s into assets catalog: %s",
-            abs_path, e,
-        )
-        return None
-
-
-async def register_completed(abs_path: str) -> Optional[str]:
-    """Catalog a completed download via the assets system (off the event loop)."""
-    return await asyncio.to_thread(_register_sync, abs_path)
-
-
-def _find_by_hash_sync(blake3_hex: str) -> Optional[str]:
-    try:
-        from app.assets.services.asset_management import get_asset_by_hash
-    except Exception:
-        return None
-    asset = get_asset_by_hash("blake3:" + blake3_hex)
-    return asset.hash if asset is not None else None
-
-
-async def find_existing_by_hash(blake3_hex: str) -> Optional[str]:
-    """Pure DB lookup — never triggers hashing on the hot path."""
-    return await asyncio.to_thread(_find_by_hash_sync, blake3_hex)

app/model_downloader/verify/structural.py

@@ -1,86 +0,0 @@
-"""Cheap structural validation, no full read.
-
-For ``.safetensors``/``.sft`` we parse the header (first few KB): it carries
-the tensor table and the byte length of the data region. We assert
-``file_size == 8 + header_len + data_region_len``. This detects truncation
-and most corruption for free, before any crypto hashing. Other extensions
-have no cheap structural check and pass through.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import struct
-from typing import Optional
-
-_SAFETENSORS_EXTS = (".safetensors", ".sft")
-# A sane upper bound so a corrupt header length can't make us read gigabytes.
-_MAX_HEADER_BYTES = 100 * 1024 * 1024
-
-
-class StructuralError(Exception):
-    """The file failed its structural integrity check."""
-
-
-def validate(path: str, name_hint: Optional[str] = None) -> None:
-    """Validate the file at ``path``. Raises :class:`StructuralError` on failure.
-
-    The file format is detected from ``name_hint`` when provided, otherwise from
-    ``path``. Callers that download into a temp file with an opaque suffix (e.g.
-    ``*.comfy-download.part``) must pass the final destination name as
-    ``name_hint`` so the format check is not silently skipped.
-    """
-    lower = (name_hint or path).lower()
-    if lower.endswith(_SAFETENSORS_EXTS):
-        _validate_safetensors(path)
-    # No structural check for other formats; the size + (optional) checksum
-    # gates in the engine cover those.
-
-
-def _validate_safetensors(path: str) -> None:
-    file_size = os.path.getsize(path)
-    if file_size < 8:
-        raise StructuralError(f"file too small to be safetensors ({file_size} bytes)")
-    with open(path, "rb") as f:
-        header_len = struct.unpack("<Q", f.read(8))[0]
-        if header_len <= 0 or header_len > _MAX_HEADER_BYTES:
-            raise StructuralError(f"implausible safetensors header length {header_len}")
-        if 8 + header_len > file_size:
-            raise StructuralError("safetensors header extends past end of file")
-        try:
-            header = json.loads(f.read(header_len).decode("utf-8"))
-        except (UnicodeDecodeError, json.JSONDecodeError) as e:
-            raise StructuralError(f"safetensors header is not valid JSON: {e}") from e
-
-    if not isinstance(header, dict):
-        raise StructuralError("safetensors header is not a JSON object")
-
-    data_len = 0
-    for name, entry in header.items():
-        if name == "__metadata__":
-            continue
-        if not isinstance(entry, dict) or "data_offsets" not in entry:
-            raise StructuralError(f"tensor {name!r} missing data_offsets")
-        offsets = entry["data_offsets"]
-        if not (isinstance(offsets, list) and len(offsets) == 2):
-            raise StructuralError(f"tensor {name!r} has malformed data_offsets")
-        begin, end = offsets
-        # bool is an int subclass; reject it explicitly to avoid True/False offsets.
-        if (
-            not isinstance(begin, int)
-            or not isinstance(end, int)
-            or isinstance(begin, bool)
-            or isinstance(end, bool)
-            or begin < 0
-            or end < begin
-        ):
-            raise StructuralError(f"tensor {name!r} has malformed data_offsets")
-        data_len = max(data_len, end)
-
-    expected = 8 + header_len + data_len
-    if file_size != expected:
-        raise StructuralError(
-            f"size mismatch: file is {file_size} bytes, header implies {expected} "
-            f"(8 + {header_len} header + {data_len} data)"
-        )

app/model_manager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import base64
 import json
@@ -35,11 +37,7 @@ class ModelFileManager:
             for folder in model_types:
                 if folder in folder_black_list:
                     continue
-                output_folders.append({
-                    "name": folder,
-                    "folders": folder_paths.get_folder_paths(folder),
-                    "extensions": sorted(folder_paths.folder_names_and_paths[folder][1]),
-                })
+                output_folders.append({"name": folder, "folders": folder_paths.get_folder_paths(folder)})
             return web.json_response(output_folders)
 
         # NOTE: This is an experiment to replace `/models/{folder}`
@@ -54,45 +52,21 @@ class ModelFileManager:
         @routes.get("/experiment/models/preview/{folder}/{path_index}/{filename:.*}")
         async def get_model_preview(request):
             folder_name = request.match_info.get("folder", None)
+            path_index = int(request.match_info.get("path_index", None))
             filename = request.match_info.get("filename", None)
 
             if folder_name not in folder_paths.folder_names_and_paths:
                 return web.Response(status=404)
 
-            # The "{filename:.*}" capture also matches the empty string, which
-            # would resolve to the folder itself; reject it explicitly.
-            if not filename:
-                return web.Response(status=400)
-
-            try:
-                path_index = int(request.match_info.get("path_index", None))
-            except (TypeError, ValueError):
-                return web.Response(status=400)
-
             folders = folder_paths.folder_names_and_paths[folder_name]
-            if path_index < 0 or path_index >= len(folders[0]):
-                return web.Response(status=404)
             folder = folders[0][path_index]
-            full_filename = os.path.normpath(os.path.join(folder, filename))
-
-            # Prevent path traversal: the requested file must stay within the
-            # configured model folder. `filename` is an unrestricted ".*" capture,
-            # so values like "../../../../etc/passwd" would otherwise escape it.
-            if not folder_paths.is_within_directory(folder, full_filename):
-                return web.Response(status=403)
+            full_filename = os.path.join(folder, filename)
 
             previews = self.get_model_previews(full_filename)
             default_preview = previews[0] if len(previews) > 0 else None
             if default_preview is None or (isinstance(default_preview, str) and not os.path.isfile(default_preview)):
                 return web.Response(status=404)
 
-            # The preview is selected by a glob inside get_model_previews, so a
-            # companion file (e.g. "model.preview.png") could itself be a symlink
-            # resolving outside the model folder. Re-validate the file actually
-            # opened: is_within_directory realpaths it, catching symlink escape.
-            if isinstance(default_preview, str) and not folder_paths.is_within_directory(folder, default_preview):
-                return web.Response(status=403)
-
             try:
                 with Image.open(default_preview) as img:
                     img_bytes = BytesIO()

app/node_replace_manager.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import logging
-
 from aiohttp import web
 
 from typing import TYPE_CHECKING, TypedDict
@@ -33,22 +31,8 @@ class NodeReplaceManager:
         self._replacements: dict[str, list[NodeReplace]] = {}
 
     def register(self, node_replace: NodeReplace):
-        """Register a node replacement mapping.
-
-        Idempotent: if a replacement with the same (old_node_id, new_node_id)
-        is already registered, the duplicate is ignored. This prevents stale
-        entries from accumulating when custom nodes are reloaded in the same
-        process (e.g. via ComfyUI-Manager).
-        """
-        existing = self._replacements.setdefault(node_replace.old_node_id, [])
-        for entry in existing:
-            if entry.new_node_id == node_replace.new_node_id:
-                logging.debug(
-                    "Node replacement %s -> %s already registered, ignoring duplicate.",
-                    node_replace.old_node_id, node_replace.new_node_id,
-                )
-                return
-        existing.append(node_replace)
+        """Register a node replacement mapping."""
+        self._replacements.setdefault(node_replace.old_node_id, []).append(node_replace)
 
     def get_replacement(self, old_node_id: str) -> list[NodeReplace] | None:
         """Get replacements for an old node ID."""

app/user_manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 import os
 import re
@@ -6,7 +7,6 @@ import glob
 import shutil
 import logging
 import tempfile
-import mimetypes
 from aiohttp import web
 from urllib import parse
 from comfy.cli_args import args
@@ -28,8 +28,8 @@ def get_file_info(path: str, relative_to: str) -> FileInfo:
     return {
         "path": os.path.relpath(path, relative_to).replace(os.sep, '/'),
         "size": os.path.getsize(path),
-        "modified": int(os.path.getmtime(path) * 1000),
-        "created": int(os.path.getctime(path) * 1000),
+        "modified": os.path.getmtime(path),
+        "created": os.path.getctime(path)
     }
 
 
@@ -337,20 +337,7 @@ class UserManager():
             if not isinstance(path, str):
                 return path
 
-            # User data files are arbitrary user-supplied content and are never
-            # meant to render inline. Disable MIME sniffing and force a download
-            # so uploaded markup/scripts can't execute in the app origin (stored
-            # XSS). Content-Disposition: attachment is the load-bearing guard;
-            # the content-type override and nosniff are defence in depth.
-            content_type = mimetypes.guess_type(path)[0] or 'application/octet-stream'
-            if folder_paths.is_dangerous_content_type(content_type):
-                content_type = 'application/octet-stream'
-
-            return web.FileResponse(path, headers={
-                "Content-Type": content_type,
-                "X-Content-Type-Options": "nosniff",
-                "Content-Disposition": "attachment",
-            })
+            return web.FileResponse(path)
 
         @routes.post("/userdata/{file}")
         async def post_userdata(request):

blueprints/Brightness and Contrast.json

@@ -431,10 +431,9 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adjusts image brightness and contrast using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   },
   "extra": {}
-}
+}

blueprints/Canny to Image (Z-Image-Turbo).json

@@ -162,7 +162,7 @@
         },
         "revision": 0,
         "config": {},
-        "name": "Canny to Image (Z-Image-Turbo)",
+        "name": "local-Canny to Image (Z-Image-Turbo)",
         "inputNode": {
           "id": -10,
           "bounding": [
@@ -1553,8 +1553,7 @@
           "VHS_MetadataImage": true,
           "VHS_KeepIntermediate": true
         },
-        "category": "Image generation and editing/Conditioned",
-        "description": "Generates an image from a Canny edge map using Z-Image-Turbo, with text conditioning."
+        "category": "Image generation and editing/Canny to image"
       }
     ]
   },
@@ -1575,4 +1574,4 @@
     }
   },
   "version": 0.4
-}
+}

blueprints/Canny to Video (LTX 2.0).json

@@ -192,7 +192,7 @@
         },
         "revision": 0,
         "config": {},
-        "name": "Canny to Video (LTX 2.0)",
+        "name": "local-Canny to Video (LTX 2.0)",
         "inputNode": {
           "id": -10,
           "bounding": [
@@ -3600,8 +3600,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Video generation and editing/Conditioned",
-        "description": "Generates video from Canny edge maps using LTX-2, with optional synchronized audio."
+        "category": "Video generation and editing/Canny to video"
       }
     ]
   },
@@ -3617,4 +3616,4 @@
     }
   },
   "version": 0.4
-}
+}

blueprints/Chromatic Aberration.json

@@ -377,9 +377,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adds lens-style chromatic aberration (color fringing) using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }
-}
+}

blueprints/Color Adjustment.json

@@ -596,8 +596,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adjusts saturation, temperature, tint, and vibrance using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }

blueprints/Color Balance.json

@@ -1129,8 +1129,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Balances colors across shadows, midtones, and highlights using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }

blueprints/Color Curves.json

@@ -608,8 +608,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Fine-tunes tone and color with per-channel curve adjustments using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }

blueprints/Depth to Image (Z-Image-Turbo).json

@@ -160,7 +160,7 @@
         },
         "revision": 0,
         "config": {},
-        "name": "Depth to Image (Z-Image-Turbo)",
+        "name": "local-Depth to Image (Z-Image-Turbo)",
         "inputNode": {
           "id": -10,
           "bounding": [
@@ -1579,8 +1579,7 @@
           "VHS_MetadataImage": true,
           "VHS_KeepIntermediate": true
         },
-        "category": "Image generation and editing/Conditioned",
-        "description": "Generates an image from a depth map using Z-Image-Turbo with text conditioning."
+        "category": "Image generation and editing/Depth to image"
       },
       {
         "id": "458bdf3c-4b58-421c-af50-c9c663a4d74c",
@@ -2462,8 +2461,7 @@
             ]
           },
           "workflowRendererVersion": "LG"
-        },
-        "description": "Estimates a monocular depth map from an input image using the Lotus depth estimation model."
+        }
       }
     ]
   },
@@ -2484,4 +2482,4 @@
     "VHS_KeepIntermediate": true
   },
   "version": 0.4
-}
+}

blueprints/Depth to Video (ltx 2.0).json

@@ -261,7 +261,7 @@
         },
         "revision": 0,
         "config": {},
-        "name": "Depth to Video (LTX 2.0)",
+        "name": "local-Depth to Video (LTX 2.0)",
         "inputNode": {
           "id": -10,
           "bounding": [
@@ -4233,8 +4233,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Video generation and editing/Conditioned",
-        "description": "Generates depth-controlled video with LTX-2: motion and structure follow a depth-reference video alongside text prompting, optional first-frame image conditioning, with optional synchronized audio."
+        "category": "Video generation and editing/Depth to video"
       },
       {
         "id": "38b60539-50a7-42f9-a5fe-bdeca26272e2",
@@ -5193,8 +5192,7 @@
         ],
         "extra": {
           "workflowRendererVersion": "LG"
-        },
-        "description": "Estimates a monocular depth map from an input image using the Lotus depth estimation model."
+        }
       }
     ]
   },
@@ -5210,4 +5208,4 @@
     "workflowRendererVersion": "LG"
   },
   "version": 0.4
-}
+}

blueprints/Edge-Preserving Blur.json

@@ -450,10 +450,9 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Blur",
-        "description": "Applies bilateral (edge-preserving) blur to soften images while retaining detail."
+        "category": "Image Tools/Blur"
       }
     ]
   },
   "extra": {}
-}
+}

blueprints/Film Grain.json

@@ -580,9 +580,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adds procedural film grain texture for a cinematic look via GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }
-}
+}

blueprints/Frame Interpolation.json

@@ -1,858 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 16,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 16,
-      "type": "022693be-2baa-4009-870a-28921508a7ef",
-      "pos": [
-        -2990,
-        -3240
-      ],
-      "size": [
-        410,
-        200
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "video",
-          "name": "video",
-          "type": "VIDEO",
-          "link": null
-        },
-        {
-          "label": "multiplier",
-          "name": "value",
-          "type": "INT",
-          "widget": {
-            "name": "value"
-          },
-          "link": null
-        },
-        {
-          "label": "enable_fps_multiplier",
-          "name": "value_1",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "value_1"
-          },
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "label": "VIDEO",
-          "name": "VIDEO_1",
-          "type": "VIDEO",
-          "links": []
-        },
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": null
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "9",
-            "value"
-          ],
-          [
-            "13",
-            "value"
-          ],
-          [
-            "1",
-            "model_name"
-          ]
-        ],
-        "enableTabs": false,
-        "tabWidth": 65,
-        "tabXOffset": 10,
-        "hasSecondTab": false,
-        "secondTabText": "Send Back",
-        "secondTabOffset": 80,
-        "secondTabWidth": 65,
-        "cnr_id": "comfy-core",
-        "ver": "0.19.3"
-      },
-      "widgets_values": [],
-      "title": "Frame Interpolation"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "022693be-2baa-4009-870a-28921508a7ef",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 17,
-          "lastLinkId": 28,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Frame Interpolation",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -2810,
-            -3070,
-            159.7421875,
-            120
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            -1270,
-            -3075,
-            120,
-            80
-          ]
-        },
-        "inputs": [
-          {
-            "id": "05e31c51-dcb6-4a1e-9651-1b9ad4f7a287",
-            "name": "video",
-            "type": "VIDEO",
-            "linkIds": [
-              2
-            ],
-            "localized_name": "video",
-            "pos": [
-              -2670.2578125,
-              -3050
-            ]
-          },
-          {
-            "id": "feecb409-7d1c-4a99-9c63-50c5fecdd3c9",
-            "name": "value",
-            "type": "INT",
-            "linkIds": [
-              22
-            ],
-            "label": "multiplier",
-            "pos": [
-              -2670.2578125,
-              -3030
-            ]
-          },
-          {
-            "id": "0b8a861b-b581-4068-9e8c-f8d15daf1ca6",
-            "name": "value_1",
-            "type": "BOOLEAN",
-            "linkIds": [
-              23
-            ],
-            "label": "enable_fps_multiplier",
-            "pos": [
-              -2670.2578125,
-              -3010
-            ]
-          },
-          {
-            "id": "a22b101e-8773-4e17-a297-7ee3aae09162",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              24
-            ],
-            "pos": [
-              -2670.2578125,
-              -2990
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "ef2ada05-d5aa-492a-9394-6c3e71e39ebb",
-            "name": "VIDEO_1",
-            "type": "VIDEO",
-            "linkIds": [
-              26
-            ],
-            "label": "VIDEO",
-            "pos": [
-              -1250,
-              -3055
-            ]
-          },
-          {
-            "id": "5aacc622-2a07-4983-b31c-e04461f7f953",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              28
-            ],
-            "pos": [
-              -1250,
-              -3035
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 1,
-            "type": "FrameInterpolationModelLoader",
-            "pos": [
-              -2510,
-              -3370
-            ],
-            "size": [
-              370,
-              90
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 24
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INTERP_MODEL",
-                "name": "INTERP_MODEL",
-                "type": "INTERP_MODEL",
-                "links": [
-                  1
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "FrameInterpolationModelLoader",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3",
-              "models": [
-                {
-                  "name": "film_net_fp16.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/frame_interpolation/resolve/main/frame_interpolation/film_net_fp16.safetensors",
-                  "directory": "frame_interpolation"
-                }
-              ]
-            },
-            "widgets_values": [
-              "film_net_fp16.safetensors"
-            ]
-          },
-          {
-            "id": 2,
-            "type": "FrameInterpolate",
-            "pos": [
-              -2040,
-              -3370
-            ],
-            "size": [
-              270,
-              110
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "interp_model",
-                "name": "interp_model",
-                "type": "INTERP_MODEL",
-                "link": 1
-              },
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "link": 3
-              },
-              {
-                "localized_name": "multiplier",
-                "name": "multiplier",
-                "type": "INT",
-                "widget": {
-                  "name": "multiplier"
-                },
-                "link": 8
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "links": [
-                  4,
-                  28
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "FrameInterpolate",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              2
-            ]
-          },
-          {
-            "id": 5,
-            "type": "CreateVideo",
-            "pos": [
-              -1600,
-              -3370
-            ],
-            "size": [
-              270,
-              110
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "link": 4
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "shape": 7,
-                "type": "AUDIO",
-                "link": 5
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "fps"
-                },
-                "link": 12
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "VIDEO",
-                "name": "VIDEO",
-                "type": "VIDEO",
-                "links": [
-                  26
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "CreateVideo",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              30
-            ]
-          },
-          {
-            "id": 9,
-            "type": "PrimitiveInt",
-            "pos": [
-              -2500,
-              -2970
-            ],
-            "size": [
-              270,
-              90
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "INT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 22
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  8,
-                  19
-                ]
-              }
-            ],
-            "title": "Int (Multiplier)",
-            "properties": {
-              "Node name for S&R": "PrimitiveInt",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              2,
-              "fixed"
-            ]
-          },
-          {
-            "id": 10,
-            "type": "ComfySwitchNode",
-            "pos": [
-              -1610,
-              -3120
-            ],
-            "size": [
-              270,
-              130
-            ],
-            "flags": {},
-            "order": 5,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "on_false",
-                "name": "on_false",
-                "type": "*",
-                "link": 11
-              },
-              {
-                "localized_name": "on_true",
-                "name": "on_true",
-                "type": "*",
-                "link": 13
-              },
-              {
-                "localized_name": "switch",
-                "name": "switch",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "switch"
-                },
-                "link": 15
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "output",
-                "name": "output",
-                "type": "*",
-                "links": [
-                  12
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ComfySwitchNode",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              true
-            ]
-          },
-          {
-            "id": 13,
-            "type": "PrimitiveBoolean",
-            "pos": [
-              -2500,
-              -2770
-            ],
-            "size": [
-              310,
-              90
-            ],
-            "flags": {},
-            "order": 7,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 23
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "BOOLEAN",
-                "name": "BOOLEAN",
-                "type": "BOOLEAN",
-                "links": [
-                  15
-                ]
-              }
-            ],
-            "title": "Boolean (Apply multiplier to FPS?)",
-            "properties": {
-              "Node name for S&R": "PrimitiveBoolean",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              true
-            ]
-          },
-          {
-            "id": 3,
-            "type": "GetVideoComponents",
-            "pos": [
-              -2500,
-              -3170
-            ],
-            "size": [
-              230,
-              100
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "video",
-                "name": "video",
-                "type": "VIDEO",
-                "link": 2
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "links": [
-                  3
-                ]
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "type": "AUDIO",
-                "links": [
-                  5
-                ]
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "links": [
-                  11,
-                  18
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GetVideoComponents",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            }
-          },
-          {
-            "id": 11,
-            "type": "ComfyMathExpression",
-            "pos": [
-              -2090,
-              -3070
-            ],
-            "size": [
-              400,
-              210
-            ],
-            "flags": {
-              "collapsed": false
-            },
-            "order": 6,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "a",
-                "localized_name": "values.a",
-                "name": "values.a",
-                "type": "FLOAT,INT",
-                "link": 18
-              },
-              {
-                "label": "b",
-                "localized_name": "values.b",
-                "name": "values.b",
-                "shape": 7,
-                "type": "FLOAT,INT",
-                "link": 19
-              },
-              {
-                "label": "c",
-                "localized_name": "values.c",
-                "name": "values.c",
-                "shape": 7,
-                "type": "FLOAT,INT",
-                "link": null
-              },
-              {
-                "localized_name": "expression",
-                "name": "expression",
-                "type": "STRING",
-                "widget": {
-                  "name": "expression"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FLOAT",
-                "name": "FLOAT",
-                "type": "FLOAT",
-                "links": [
-                  13
-                ]
-              },
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ComfyMathExpression",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "cnr_id": "comfy-core",
-              "ver": "0.19.3"
-            },
-            "widgets_values": [
-              "min(abs(b), 16) * a"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 1,
-            "origin_id": 1,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 0,
-            "type": "INTERP_MODEL"
-          },
-          {
-            "id": 3,
-            "origin_id": 3,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 8,
-            "origin_id": 9,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 4,
-            "origin_id": 2,
-            "origin_slot": 0,
-            "target_id": 5,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 5,
-            "origin_id": 3,
-            "origin_slot": 1,
-            "target_id": 5,
-            "target_slot": 1,
-            "type": "AUDIO"
-          },
-          {
-            "id": 12,
-            "origin_id": 10,
-            "origin_slot": 0,
-            "target_id": 5,
-            "target_slot": 2,
-            "type": "FLOAT"
-          },
-          {
-            "id": 11,
-            "origin_id": 3,
-            "origin_slot": 2,
-            "target_id": 10,
-            "target_slot": 0,
-            "type": "FLOAT"
-          },
-          {
-            "id": 13,
-            "origin_id": 11,
-            "origin_slot": 0,
-            "target_id": 10,
-            "target_slot": 1,
-            "type": "FLOAT"
-          },
-          {
-            "id": 15,
-            "origin_id": 13,
-            "origin_slot": 0,
-            "target_id": 10,
-            "target_slot": 2,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 18,
-            "origin_id": 3,
-            "origin_slot": 2,
-            "target_id": 11,
-            "target_slot": 0,
-            "type": "FLOAT"
-          },
-          {
-            "id": 19,
-            "origin_id": 9,
-            "origin_slot": 0,
-            "target_id": 11,
-            "target_slot": 1,
-            "type": "INT"
-          },
-          {
-            "id": 2,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 3,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 22,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 9,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 23,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 13,
-            "target_slot": 0,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 24,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 1,
-            "target_slot": 0,
-            "type": "COMBO"
-          },
-          {
-            "id": 26,
-            "origin_id": 5,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 28,
-            "origin_id": 2,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 1,
-            "type": "IMAGE"
-          }
-        ],
-        "extra": {},
-        "category": "Video Tools",
-        "description": "Increases video frame rate by synthesizing intermediate frames with a frame interpolation model."
-      }
-    ]
-  },
-  "extra": {}
-}

blueprints/Get Any Video Frame.json

@@ -1,485 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 98,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 98,
-      "type": "dca6e78d-fb06-421e-97f7-6ce17a665260",
-      "pos": [
-        -410,
-        -2230
-      ],
-      "size": [
-        270,
-        104
-      ],
-      "flags": {},
-      "order": 7,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "video",
-          "type": "VIDEO",
-          "link": null
-        },
-        {
-          "label": "frame_index",
-          "name": "value",
-          "type": "INT",
-          "widget": {
-            "name": "value"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "title": "Get Any Video Frame",
-      "properties": {
-        "proxyWidgets": [
-          [
-            "100",
-            "value"
-          ]
-        ]
-      },
-      "widgets_values": []
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "dca6e78d-fb06-421e-97f7-6ce17a665260",
-        "version": 1,
-        "state": {
-          "lastGroupId": 1,
-          "lastNodeId": 136,
-          "lastLinkId": 302,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Get Any Video Frame",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            380,
-            -57,
-            120,
-            80
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            1460,
-            -57,
-            120,
-            60
-          ]
-        },
-        "inputs": [
-          {
-            "id": "2ceec378-8dcf-4340-8570-155967f59a93",
-            "name": "video",
-            "type": "VIDEO",
-            "linkIds": [
-              4
-            ],
-            "pos": [
-              480,
-              -37
-            ]
-          },
-          {
-            "id": "819955f6-c686-4896-8032-ff2d0059109a",
-            "name": "value",
-            "type": "INT",
-            "linkIds": [
-              283
-            ],
-            "label": "frame_index",
-            "pos": [
-              480,
-              -17
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "1ab0684d-6a44-45b6-8aa4-a0b971a1d41e",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              5
-            ],
-            "pos": [
-              1480,
-              -37
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 1,
-            "type": "GetVideoComponents",
-            "pos": [
-              560,
-              -150
-            ],
-            "size": [
-              230,
-              120
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "video",
-                "name": "video",
-                "type": "VIDEO",
-                "link": 4
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "links": [
-                  1,
-                  2
-                ]
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "type": "AUDIO",
-                "links": null
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GetVideoComponents"
-            }
-          },
-          {
-            "id": 2,
-            "type": "GetImageSize",
-            "pos": [
-              560,
-              50
-            ],
-            "size": [
-              230,
-              120
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 1
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "width",
-                "name": "width",
-                "type": "INT",
-                "links": null
-              },
-              {
-                "localized_name": "height",
-                "name": "height",
-                "type": "INT",
-                "links": null
-              },
-              {
-                "localized_name": "batch_size",
-                "name": "batch_size",
-                "type": "INT",
-                "links": [
-                  285
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GetImageSize"
-            }
-          },
-          {
-            "id": 3,
-            "type": "ImageFromBatch",
-            "pos": [
-              1130,
-              -150
-            ],
-            "size": [
-              270,
-              140
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 2
-              },
-              {
-                "localized_name": "batch_index",
-                "name": "batch_index",
-                "type": "INT",
-                "widget": {
-                  "name": "batch_index"
-                },
-                "link": 286
-              },
-              {
-                "localized_name": "length",
-                "name": "length",
-                "type": "INT",
-                "widget": {
-                  "name": "length"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "links": [
-                  5
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ImageFromBatch"
-            },
-            "widgets_values": [
-              0,
-              1
-            ]
-          },
-          {
-            "id": 99,
-            "type": "ComfyMathExpression",
-            "pos": [
-              910,
-              100
-            ],
-            "size": [
-              400,
-              200
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "a",
-                "localized_name": "values.a",
-                "name": "values.a",
-                "type": "FLOAT,INT",
-                "link": 284
-              },
-              {
-                "label": "b",
-                "localized_name": "values.b",
-                "name": "values.b",
-                "shape": 7,
-                "type": "FLOAT,INT",
-                "link": 285
-              },
-              {
-                "label": "c",
-                "localized_name": "values.c",
-                "name": "values.c",
-                "shape": 7,
-                "type": "FLOAT,INT",
-                "link": null
-              },
-              {
-                "localized_name": "expression",
-                "name": "expression",
-                "type": "STRING",
-                "widget": {
-                  "name": "expression"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FLOAT",
-                "name": "FLOAT",
-                "type": "FLOAT",
-                "links": null
-              },
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  286
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ComfyMathExpression"
-            },
-            "widgets_values": [
-              "min(max(int(a if a >= 0 else b + a), 0), b - 1)"
-            ]
-          },
-          {
-            "id": 100,
-            "type": "PrimitiveInt",
-            "pos": [
-              560,
-              250
-            ],
-            "size": [
-              270,
-              110
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "INT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 283
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  284
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "PrimitiveInt"
-            },
-            "widgets_values": [
-              0,
-              "fixed"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 1,
-            "origin_id": 1,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 2,
-            "origin_id": 1,
-            "origin_slot": 0,
-            "target_id": 3,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 4,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 1,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 5,
-            "origin_id": 3,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 283,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 100,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 284,
-            "origin_id": 100,
-            "origin_slot": 0,
-            "target_id": 99,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 285,
-            "origin_id": 2,
-            "origin_slot": 2,
-            "target_id": 99,
-            "target_slot": 1,
-            "type": "INT"
-          },
-          {
-            "id": 286,
-            "origin_id": 99,
-            "origin_slot": 1,
-            "target_id": 3,
-            "target_slot": 1,
-            "type": "INT"
-          }
-        ],
-        "extra": {},
-        "category": "Video Tools",
-        "description": "Extracts one image frame from a video at a chosen index, with optional trim and FPS control."
-      }
-    ]
-  },
-  "extra": {
-    "ds": {
-      "scale": 1.197015527856339,
-      "offset": [
-        -168.76833554248222,
-        540.6638955283997
-      ]
-    },
-    "frontendVersion": "1.42.8"
-  }
-}

blueprints/Glow.json

@@ -575,9 +575,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adds a glow/bloom effect around bright image areas via GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }
-}
+}

blueprints/Hue and Saturation.json

@@ -752,9 +752,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Adjusts hue, saturation, and lightness of an image using a real-time GPU fragment shader."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }
-}
+}

blueprints/Image Blur.json

@@ -374,8 +374,7 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Blur",
-        "description": "Applies Gaussian, Box, or Radial blur to soften images and create stylized depth or motion effects."
+        "category": "Image Tools/Blur"
       }
     ]
   }

blueprints/Image Captioning (gemini).json

@@ -310,9 +310,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools",
-        "description": "Generates descriptive captions for images using Google's Gemini multimodal LLM."
+        "category": "Text generation/Image Captioning"
       }
     ]
   }
-}
+}

blueprints/Image Channels.json

@@ -315,9 +315,8 @@
         "extra": {
           "workflowRendererVersion": "LG"
         },
-        "category": "Image Tools/Color adjust",
-        "description": "Manipulates individual RGBA channels for masking, compositing, and channel effects."
+        "category": "Image Tools/Color adjust"
       }
     ]
   }
-}
+}

blueprints/Image Depth Estimation (Depth Anything 3).json

@@ -1,569 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 89,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 89,
-      "type": "85e595bd-af9e-40ee-85c5-b98bb15da47a",
-      "pos": [
-        320,
-        520
-      ],
-      "size": [
-        400,
-        360
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "image",
-          "name": "image",
-          "type": "IMAGE",
-          "link": null
-        },
-        {
-          "name": "resolution",
-          "type": "INT",
-          "widget": {
-            "name": "resolution"
-          },
-          "link": null
-        },
-        {
-          "name": "resize_method",
-          "type": "COMBO",
-          "widget": {
-            "name": "resize_method"
-          },
-          "link": null
-        },
-        {
-          "label": "output_type",
-          "name": "output",
-          "type": "COMFY_DYNAMICCOMBO_V3",
-          "widget": {
-            "name": "output"
-          },
-          "link": null
-        },
-        {
-          "label": "output_normalization",
-          "name": "output.normalization",
-          "type": "COMBO",
-          "widget": {
-            "name": "output.normalization"
-          },
-          "link": null
-        },
-        {
-          "label": "apply_sky_clip",
-          "name": "output.apply_sky_clip",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "output.apply_sky_clip"
-          },
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "IMAGE",
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "87",
-            "resolution"
-          ],
-          [
-            "87",
-            "resize_method"
-          ],
-          [
-            "86",
-            "output"
-          ],
-          [
-            "86",
-            "output.normalization"
-          ],
-          [
-            "86",
-            "output.apply_sky_clip"
-          ],
-          [
-            "88",
-            "model_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.24.0"
-      },
-      "widgets_values": [],
-      "title": "Image Depth Estimation (Depth Anything 3)"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "85e595bd-af9e-40ee-85c5-b98bb15da47a",
-        "version": 1,
-        "state": {
-          "lastGroupId": 4,
-          "lastNodeId": 89,
-          "lastLinkId": 109,
-          "lastRerouteId": 0
-        },
-        "revision": 2,
-        "config": {},
-        "name": "Image Depth Estimation (Depth Anything 3)",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            400,
-            90,
-            166.998046875,
-            188
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            1250,
-            146,
-            128,
-            68
-          ]
-        },
-        "inputs": [
-          {
-            "id": "43cf3118-495a-487d-8eb3-a17c7e92f64f",
-            "name": "image",
-            "type": "IMAGE",
-            "linkIds": [
-              19
-            ],
-            "localized_name": "image",
-            "pos": [
-              542.998046875,
-              114
-            ]
-          },
-          {
-            "id": "1089a0a1-6db1-45a8-84b0-0bfdc2ed920a",
-            "name": "resolution",
-            "type": "INT",
-            "linkIds": [
-              22
-            ],
-            "pos": [
-              542.998046875,
-              134
-            ]
-          },
-          {
-            "id": "25fb64ac-26d5-466d-995b-6d51b9afa2c4",
-            "name": "resize_method",
-            "type": "COMBO",
-            "linkIds": [
-              23
-            ],
-            "pos": [
-              542.998046875,
-              154
-            ]
-          },
-          {
-            "id": "8acafb7c-6c8b-46b3-9d74-c563498a3af1",
-            "name": "output",
-            "type": "COMFY_DYNAMICCOMBO_V3",
-            "linkIds": [
-              24
-            ],
-            "label": "output_type",
-            "pos": [
-              542.998046875,
-              174
-            ]
-          },
-          {
-            "id": "1da5009b-4648-43e8-a257-16426630cf22",
-            "name": "output.normalization",
-            "type": "COMBO",
-            "linkIds": [
-              25
-            ],
-            "label": "output_normalization",
-            "pos": [
-              542.998046875,
-              194
-            ]
-          },
-          {
-            "id": "fd7edb33-5fb1-4538-a411-26e5039a9321",
-            "name": "output.apply_sky_clip",
-            "type": "BOOLEAN",
-            "linkIds": [
-              26
-            ],
-            "label": "apply_sky_clip",
-            "pos": [
-              542.998046875,
-              214
-            ]
-          },
-          {
-            "id": "b5be4c8a-b833-4f1e-8c94-3ed1dd722190",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              106
-            ],
-            "pos": [
-              542.998046875,
-              234
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "478ab537-63bc-4d74-a9f0-c975f550880f",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              7
-            ],
-            "localized_name": "IMAGE",
-            "pos": [
-              1274,
-              170
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 86,
-            "type": "DA3Render",
-            "pos": [
-              800,
-              310
-            ],
-            "size": [
-              380,
-              130
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "link": 12
-              },
-              {
-                "localized_name": "output",
-                "name": "output",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "output"
-                },
-                "link": 24
-              },
-              {
-                "localized_name": "output.normalization",
-                "name": "output.normalization",
-                "type": "COMBO",
-                "widget": {
-                  "name": "output.normalization"
-                },
-                "link": 25
-              },
-              {
-                "localized_name": "output.apply_sky_clip",
-                "name": "output.apply_sky_clip",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "output.apply_sky_clip"
-                },
-                "link": 26
-              },
-              {
-                "name": "geometry",
-                "type": "DA3_GEOMETRY",
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "slot_index": 0,
-                "links": [
-                  7
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Render",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              "depth",
-              "v2_style",
-              false
-            ]
-          },
-          {
-            "id": 87,
-            "type": "DA3Inference",
-            "pos": [
-              800,
-              50
-            ],
-            "size": [
-              390,
-              130
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_model",
-                "name": "da3_model",
-                "type": "DA3_MODEL",
-                "link": 107
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 19
-              },
-              {
-                "localized_name": "resolution",
-                "name": "resolution",
-                "type": "INT",
-                "widget": {
-                  "name": "resolution"
-                },
-                "link": 22
-              },
-              {
-                "localized_name": "resize_method",
-                "name": "resize_method",
-                "type": "COMBO",
-                "widget": {
-                  "name": "resize_method"
-                },
-                "link": 23
-              },
-              {
-                "localized_name": "mode",
-                "name": "mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "mode"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "slot_index": 0,
-                "links": [
-                  12
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Inference",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              504,
-              "upper_bound_resize",
-              "mono"
-            ]
-          },
-          {
-            "id": 88,
-            "type": "LoadDA3Model",
-            "pos": [
-              810,
-              -160
-            ],
-            "size": [
-              400,
-              140
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 106
-              },
-              {
-                "localized_name": "weight_dtype",
-                "name": "weight_dtype",
-                "type": "COMBO",
-                "widget": {
-                  "name": "weight_dtype"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "DA3_MODEL",
-                "name": "DA3_MODEL",
-                "type": "DA3_MODEL",
-                "links": [
-                  107
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "LoadDA3Model",
-              "cnr_id": "comfy-core",
-              "ver": "0.24.0",
-              "models": [
-                {
-                  "name": "depth_anything_3_mono_large.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/Depth-Anything-3/resolve/main/geometry_estimation/depth_anything_3_mono_large.safetensors",
-                  "directory": "geometry_estimation"
-                }
-              ]
-            },
-            "widgets_values": [
-              "depth_anything_3_mono_large.safetensors",
-              "default"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 12,
-            "origin_id": 87,
-            "origin_slot": 0,
-            "target_id": 86,
-            "target_slot": 0,
-            "type": "DA3_GEOMETRY"
-          },
-          {
-            "id": 19,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 87,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 7,
-            "origin_id": 86,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 22,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 87,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 23,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 87,
-            "target_slot": 3,
-            "type": "COMBO"
-          },
-          {
-            "id": 24,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 86,
-            "target_slot": 1,
-            "type": "COMFY_DYNAMICCOMBO_V3"
-          },
-          {
-            "id": 25,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 86,
-            "target_slot": 2,
-            "type": "COMBO"
-          },
-          {
-            "id": 26,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 86,
-            "target_slot": 3,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 106,
-            "origin_id": -10,
-            "origin_slot": 6,
-            "target_id": 88,
-            "target_slot": 0,
-            "type": "COMBO"
-          },
-          {
-            "id": 107,
-            "origin_id": 88,
-            "origin_slot": 0,
-            "target_id": 87,
-            "target_slot": 0,
-            "type": "DA3_MODEL"
-          }
-        ],
-        "extra": {},
-        "category": "Conditioning & Preprocessors/Depth",
-        "description": "This subgraph takes an input image and produces a depth map using the Depth Anything 3 model, which recovers spatially consistent geometry from any number of views. It is ideal for single or multi-view images, videos, and 3D scenes where accurate depth estimation is needed for tasks like SLAM, novel view synthesis, or spatial perception. The model uses a plain transformer backbone and supports both monocular and multi-view inputs without."
-      }
-    ]
-  },
-  "extra": {
-    "BlueprintDescription": "This subgraph takes an input image and produces a depth map using the Depth Anything 3 model, which recovers spatially consistent geometry from any number of views. It is ideal for single or multi-view images, videos, and 3D scenes where accurate depth estimation is needed for tasks like SLAM, novel view synthesis, or spatial perception. The model uses a plain transformer backbone and supports both monocular and multi-view inputs without."
-  }
-}