Merge branch 'Comfy-Org:main' into patch-3

Author: qiacheng

.gitignore

@@ -61,3 +61,4 @@ requirements.compiled
 override.txt
 .coverage
 coverage.xml
+

DEV_README.md

@@ -58,6 +58,32 @@ either run `pip install -e .` again (which will reinstall), or manually
 uninstall `pip uninstall comfy-cli` and reinstall, or even cleaning your conda
 env and reinstalling the package (`pip install -e .`)
 
+## Packaging custom nodes with `.comfyignore`
+
+`comfy node pack` and `comfy node publish` now read an optional `.comfyignore`
+file in the project root. The syntax matches `.gitignore` (implemented with
+`PathSpec`'s `gitwildmatch` rules), so you can reuse familiar patterns to keep
+development-only artifacts out of your published archive.
+
+- Patterns are evaluated against paths relative to the directory you run the
+  command from (usually the repo root).
+- Files required by the pack command itself (e.g. `__init__.py`, `web/*`) are
+  still forced into the archive even if they match an ignore pattern.
+- If no `.comfyignore` is present the command falls back to the original
+  behavior and zips every git-tracked file.
+
+Example `.comfyignore`:
+
+```gitignore
+docs/
+frontend/
+tests/
+*.psd
+```
+
+Commit the file alongside your node so teammates and CI pipelines produce the
+same trimmed package.
+
 ## Adding a new command
 
 - Register it under `comfy_cli/cmdline.py`

comfy_cli/command/custom_nodes/command.py

@@ -942,7 +942,7 @@ def registry_install(
 
 @app.command(
     "pack",
-    help="Pack the current node into a zip file. Ignorining .gitignore files.",
+    help="Pack the current node into a zip file using git-tracked files and honoring .comfyignore patterns.",
 )
 @tracking.track_command("pack")
 def pack():

comfy_cli/command/models/models.py

@@ -1,8 +1,9 @@
+import contextlib
 import os
 import pathlib
 import sys
 from typing import Annotated, Optional
-from urllib.parse import unquote, urlparse
+from urllib.parse import parse_qs, unquote, urlparse
 
 import requests
 import typer
@@ -74,39 +75,65 @@ def check_huggingface_url(url: str) -> tuple[bool, Optional[str], Optional[str],
     return True, repo_id, filename, folder_name, branch_name
 
 
-def check_civitai_url(url: str) -> tuple[bool, bool, int, int]:
+def check_civitai_url(url: str) -> tuple[bool, bool, Optional[int], Optional[int]]:
     """
     Returns:
-        is_civitai_model_url: True if the url is a civitai model url
-        is_civitai_api_url: True if the url is a civitai api url
-        model_id: The model id or None if it's api url
-        version_id: The version id or None if it doesn't have version id info
+        is_civitai_model_url: True if the url is a civitai *web* model url (e.g. /models/12345)
+        is_civitai_api_url: True if the url is a civitai *api* url useful for resolving downloads
+        model_id: The model id (for /models/*), else None
+        version_id: The version id (for /api/download/models/* or ?modelVersionId=), else None
     """
-    prefix = "civitai.com"
     try:
-        if prefix in url:
-            # URL is civitai api download url: https://civitai.com/api/download/models/12345
-            if "civitai.com/api/download" in url:
-                # This is a direct download link
-                version_id = url.strip("/").split("/")[-1]
-                return False, True, None, int(version_id)
-
-            # URL is civitai web url (e.g.
-            #   - https://civitai.com/models/43331
-            #   - https://civitai.com/models/43331/majicmix-realistic
-            subpath = url[url.find(prefix) + len(prefix) :].strip("/")
-            url_parts = subpath.split("?")
-            if len(url_parts) > 1:
-                model_id = url_parts[0].split("/")[1]
-                version_id = url_parts[1].split("=")[1]
-                return True, False, int(model_id), int(version_id)
-            else:
-                model_id = subpath.split("/")[1]
-                return True, False, int(model_id), None
-    except (ValueError, IndexError):
+        parsed = urlparse(url)
+        host = (parsed.hostname or "").lower()
+        if host != "civitai.com" and not host.endswith(".civitai.com"):
+            return False, False, None, None
+        p_parts = [p for p in parsed.path.split("/") if p]
+        query = parse_qs(parsed.query)
+
+        if len(p_parts) >= 4 and p_parts[0] == "api":
+            # Case 1: /api/download/models/<version_id>
+            # e.g. https://civitai.com/api/download/models/1617665?type=Model&format=SafeTensor
+            if p_parts[1] == "download" and p_parts[2] == "models":
+                try:
+                    version_id = int(p_parts[3])
+                    return False, True, None, version_id
+                except ValueError:
+                    return False, True, None, None
+
+            # Case 2: /api/v1/model-versions/<version_id>
+            if p_parts[1] == "v1" and p_parts[2] in ("model-versions", "modelVersions"):
+                try:
+                    version_id = int(p_parts[3])
+                    return False, True, None, version_id
+                except ValueError:
+                    return False, True, None, None
+
+        # Case 3: /models/<model_id>[/*] with optional ?modelVersionId=<id>
+        # e.g. https://civitai.com/models/43331
+        #      https://civitai.com/models/43331/majicmix-realistic?modelVersionId=485088
+        if len(p_parts) >= 2 and p_parts[0] == "models":
+            try:
+                model_id = int(p_parts[1])
+            except ValueError:
+                return False, False, None, None
+            version_id = None
+            mv = query.get("modelVersionId")
+            if mv and len(mv) > 0:
+                with contextlib.suppress(ValueError):
+                    version_id = int(mv[0])
+            if version_id is None:
+                mv = query.get("version")
+                if mv and len(mv) > 0:
+                    with contextlib.suppress(ValueError):
+                        version_id = int(mv[0])
+            return True, False, model_id, version_id
+
+        return False, False, None, None
+
+    except Exception:
         print("Error parsing CivitAI model URL")
-
-    return False, False, None, None
+        return False, False, None, None
 
 
 def request_civitai_model_version_api(version_id: int, headers: Optional[dict] = None):

comfy_cli/file_utils.py

@@ -1,11 +1,13 @@
 import json
 import os
 import pathlib
+import subprocess
 import zipfile
-from typing import Optional
+from typing import Optional, Union
 
 import httpx
 import requests
+from pathspec import PathSpec
 
 from comfy_cli import constants, ui
 
@@ -55,7 +57,7 @@ def check_unauthorized(url: str, headers: Optional[dict] = None) -> bool:
         bool: True if the response status code is 401, False otherwise.
     """
     try:
-        response = requests.get(url, headers=headers, allow_redirects=True)
+        response = requests.get(url, headers=headers, allow_redirects=True, stream=True)
         return response.status_code == 401
     except requests.RequestException:
         # If there's an error making the request, we can't determine if it's unauthorized
@@ -86,61 +88,139 @@ def download_file(url: str, local_filepath: pathlib.Path, headers: Optional[dict
             raise DownloadException(f"Failed to download file.\n{status_reason}")
 
 
+def _load_comfyignore_spec(ignore_filename: str = ".comfyignore") -> Optional[PathSpec]:
+    if not os.path.exists(ignore_filename):
+        return None
+    try:
+        with open(ignore_filename, encoding="utf-8") as ignore_file:
+            patterns = [line.strip() for line in ignore_file if line.strip() and not line.lstrip().startswith("#")]
+    except OSError:
+        return None
+
+    if not patterns:
+        return None
+
+    return PathSpec.from_lines("gitwildmatch", patterns)
+
+
+def list_git_tracked_files(base_path: Union[str, os.PathLike] = ".") -> list[str]:
+    try:
+        result = subprocess.check_output(
+            ["git", "-C", os.fspath(base_path), "ls-files"],
+            text=True,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return []
+
+    return [line for line in result.splitlines() if line.strip()]
+
+
+def _normalize_path(path: str) -> str:
+    rel_path = os.path.relpath(path, start=".")
+    if rel_path == ".":
+        return ""
+    return rel_path.replace("\\", "/")
+
+
+def _is_force_included(rel_path: str, include_prefixes: list[str]) -> bool:
+    return any(rel_path == prefix or rel_path.startswith(prefix + "/") for prefix in include_prefixes if prefix)
+
+
 def zip_files(zip_filename, includes=None):
-    """
-    Zip all files in the current directory that are tracked by git,
-    plus any additional directories specified in includes.
-    """
+    """Zip git-tracked files respecting optional .comfyignore patterns."""
     includes = includes or []
-    included_paths = set()
-    git_files = []
+    include_prefixes: list[str] = [_normalize_path(os.path.normpath(include.lstrip("/"))) for include in includes]
 
-    try:
-        import subprocess
+    included_paths: set[str] = set()
+    git_files: list[str] = []
 
-        git_files = subprocess.check_output(["git", "ls-files"], text=True).splitlines()
-    except (subprocess.SubprocessError, FileNotFoundError):
+    ignore_spec = _load_comfyignore_spec()
+
+    def should_ignore(rel_path: str) -> bool:
+        if not ignore_spec:
+            return False
+        if _is_force_included(rel_path, include_prefixes):
+            return False
+        return ignore_spec.match_file(rel_path)
+
+    zip_target = os.fspath(zip_filename)
+    zip_abs_path = os.path.abspath(zip_target)
+    zip_basename = os.path.basename(zip_abs_path)
+
+    git_files = list_git_tracked_files(".")
+    if not git_files:
         print("Warning: Not in a git repository or git not installed. Zipping all files.")
 
-    # Zip only git-tracked files
-    with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_DEFLATED) as zipf:
+    with zipfile.ZipFile(zip_target, "w", zipfile.ZIP_DEFLATED) as zipf:
         if git_files:
             for file_path in git_files:
-                if zip_filename in file_path:
+                if file_path == zip_basename:
+                    continue
+
+                rel_path = _normalize_path(file_path)
+                if should_ignore(rel_path):
+                    continue
+
+                actual_path = os.path.normpath(file_path)
+                if os.path.abspath(actual_path) == zip_abs_path:
                     continue
-                if os.path.exists(file_path):
-                    zipf.write(file_path)
-                    included_paths.add(file_path)
+                if os.path.exists(actual_path):
+                    arcname = rel_path or os.path.basename(actual_path)
+                    zipf.write(actual_path, arcname)
+                    included_paths.add(rel_path)
                 else:
                     print(f"File not found. Not including in zip: {file_path}")
         else:
             for root, dirs, files in os.walk("."):
                 if ".git" in dirs:
                     dirs.remove(".git")
+                dirs[:] = [d for d in dirs if not should_ignore(_normalize_path(os.path.join(root, d)))]
                 for file in files:
                     file_path = os.path.join(root, file)
-                    # Skip zipping the zip file itself
-                    if zip_filename in file_path:
+                    rel_path = _normalize_path(file_path)
+                    if (
+                        os.path.abspath(file_path) == zip_abs_path
+                        or rel_path in included_paths
+                        or should_ignore(rel_path)
+                    ):
                         continue
-                    relative_path = os.path.relpath(file_path, start=".")
-                    zipf.write(file_path, relative_path)
-                    included_paths.add(file_path)
+                    arcname = rel_path or file_path
+                    zipf.write(file_path, arcname)
+                    included_paths.add(rel_path)
 
         for include_dir in includes:
-            include_dir = include_dir.lstrip("/")
+            include_dir = os.path.normpath(include_dir.lstrip("/"))
+            rel_include = _normalize_path(include_dir)
+
+            if os.path.isfile(include_dir):
+                if not should_ignore(rel_include) and rel_include not in included_paths:
+                    arcname = rel_include or include_dir
+                    zipf.write(include_dir, arcname)
+                    included_paths.add(rel_include)
+                continue
+
             if not os.path.exists(include_dir):
                 print(f"Warning: Included directory '{include_dir}' does not exist, creating empty directory")
-                zipf.writestr(f"{include_dir}/", "")
+                arcname = rel_include or include_dir
+                if not arcname.endswith("/"):
+                    arcname = arcname + "/"
+                zipf.writestr(arcname, "")
                 continue
 
             for root, dirs, files in os.walk(include_dir):
+                dirs[:] = [d for d in dirs if not should_ignore(_normalize_path(os.path.join(root, d)))]
                 for file in files:
                     file_path = os.path.join(root, file)
-                    if zip_filename in file_path or file_path in included_paths:
+                    rel_path = _normalize_path(file_path)
+                    if (
+                        os.path.abspath(file_path) == zip_abs_path
+                        or rel_path in included_paths
+                        or should_ignore(rel_path)
+                    ):
                         continue
-                    relative_path = os.path.relpath(file_path, start=".")
-                    zipf.write(file_path, relative_path)
-                    included_paths.add(file_path)
+                    arcname = rel_path or file_path
+                    zipf.write(file_path, arcname)
+                    included_paths.add(rel_path)
 
 
 def upload_file_to_signed_url(signed_url: str, file_path: str):