comfyui-skill-cli 0.2.7__tar.gz → 0.2.8__tar.gz

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfyui-skill-cli
-Version: 0.2.7
+Version: 0.2.8
 Summary: ComfyUI Skill CLI — Agent-friendly workflow management
 Author: HuangYuChuh
 License-Expression: MIT
@@ -57,7 +57,9 @@ Dynamic: license-file
     <strong>English</strong> ·
     <a href="./README.zh.md">简体中文</a> ·
     <a href="./README.zh-TW.md">繁體中文</a> ·
-    <a href="./README.ja.md">日本語</a>
+    <a href="./README.ja.md">日本語</a> ·
+    <a href="./README.ko.md">한국어</a> ·
+    <a href="./README.es.md">Español</a>
   </p>
 
 </div>

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/README.md

@@ -26,7 +26,9 @@
     <strong>English</strong> ·
     <a href="./README.zh.md">简体中文</a> ·
     <a href="./README.zh-TW.md">繁體中文</a> ·
-    <a href="./README.ja.md">日本語</a>
+    <a href="./README.ja.md">日本語</a> ·
+    <a href="./README.ko.md">한국어</a> ·
+    <a href="./README.es.md">Español</a>
   </p>
 
 </div>

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/comfyui_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfyui-skill-cli
-Version: 0.2.7
+Version: 0.2.8
 Summary: ComfyUI Skill CLI — Agent-friendly workflow management
 Author: HuangYuChuh
 License-Expression: MIT
@@ -57,7 +57,9 @@ Dynamic: license-file
     <strong>English</strong> ·
     <a href="./README.zh.md">简体中文</a> ·
     <a href="./README.zh-TW.md">繁體中文</a> ·
-    <a href="./README.ja.md">日本語</a>
+    <a href="./README.ja.md">日本語</a> ·
+    <a href="./README.ko.md">한국어</a> ·
+    <a href="./README.es.md">Español</a>
   </p>
 
 </div>

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/comfyui_skill_cli.egg-info/SOURCES.txt

@@ -33,8 +33,7 @@ comfyui_skills_cli/commands/skill.py
 comfyui_skills_cli/commands/templates.py
 comfyui_skills_cli/commands/upload.py
 comfyui_skills_cli/commands/workflow.py
-tests/test_client_new_apis.py
-tests/test_nodes_and_ws.py
-tests/test_partial_execution.py
-tests/test_server_stats.py
+tests/test_client.py
+tests/test_error_hints.py
+tests/test_nodes.py
 tests/test_update_check.py

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/comfyui_skills_cli/commands/run.py

@@ -399,12 +399,25 @@ def _inject_params(
     return workflow
 
 
-_MEDIA_KEYS: dict[str, str] = {
-    "images": "image",
-    "audio": "audio",
-    "gifs": "image",
-    "video": "video",
-}
+_MEDIA_KEYS = ("images", "audio")
+
+_VIDEO_EXTENSIONS = {".mp4", ".webm", ".mkv", ".avi", ".mov", ".gif"}
+_AUDIO_EXTENSIONS = {".mp3", ".wav", ".flac", ".ogg", ".aac", ".m4a"}
+
+
+def _infer_media_type(filename: str, fallback: str) -> str:
+    """Infer media type from file extension.
+
+    ComfyUI's SaveVideo/PreviewVideo nodes report video output under
+    the ``"images"`` history key, so relying on the key alone would
+    misclassify video files as images.
+    """
+    ext = Path(filename).suffix.lower()
+    if ext in _VIDEO_EXTENSIONS:
+        return "video"
+    if ext in _AUDIO_EXTENSIONS:
+        return "audio"
+    return fallback
 
 
 def _collect_outputs(outputs: dict[str, Any]) -> list[dict[str, str]]:
@@ -412,13 +425,15 @@ def _collect_outputs(outputs: dict[str, Any]) -> list[dict[str, str]]:
     for node_output in outputs.values():
         if not isinstance(node_output, dict):
             continue
-        for key, media_type in _MEDIA_KEYS.items():
+        for key in _MEDIA_KEYS:
+            fallback = "audio" if key == "audio" else "image"
             for item in node_output.get(key, []):
+                filename = item.get("filename", "")
                 collected.append({
-                    "filename": item.get("filename", ""),
+                    "filename": filename,
                     "subfolder": item.get("subfolder", ""),
                     "type": item.get("type", "output"),
-                    "media_type": media_type,
+                    "media_type": _infer_media_type(filename, fallback),
                 })
     return collected
 

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/comfyui_skills_cli/commands/workflow.py

@@ -70,6 +70,14 @@ _MEDIA_TYPE_FIELDS: dict[str, dict[str, dict[str, Any]]] = {
         "cfg_scale": {"exposed": True, "required": False, "description": "Classifier-free guidance scale"},
         "temperature": {"exposed": True, "required": False, "description": "Sampling temperature"},
     },
+    "video": {
+        "format": {"exposed": True, "required": False, "description": "Output video format"},
+        "codec": {"exposed": True, "required": False, "description": "Video codec"},
+        "frame_rate": {"exposed": True, "required": False, "description": "Video frame rate"},
+        "fps": {"exposed": True, "required": False, "description": "Frames per second"},
+        "noise_seed": {"exposed": True, "required": False, "description": "Noise seed for video generation"},
+        "cfg": {"exposed": True, "required": False, "description": "Classifier-free guidance scale"},
+    },
 }
 
 _LOAD_IMAGE_CLASSES = {"LoadImage", "LoadImageMask"}
@@ -91,6 +99,7 @@ def _extract_schema(workflow_data: dict[str, Any], media_type: str = "image") ->
     *media_type* selects additional field-exposure rules beyond the base
     set.  ``"image"`` (default) uses only the generic rules.
     ``"audio"`` adds audio-specific fields like tags, lyrics, bpm, etc.
+    ``"video"`` adds video-specific fields like format, codec, fps, etc.
     """
     expose_fields = dict(_AUTO_EXPOSE_FIELDS)
     if media_type in _MEDIA_TYPE_FIELDS:
@@ -384,7 +393,7 @@ def workflow_import(
     ctx: typer.Context,
     json_path: str = typer.Argument(None, help="Path to workflow JSON file (omit when using --from-server)"),
     name: str = typer.Option("", "--name", "-n", help="Workflow ID (default: derived from filename)"),
-    media_type: str = typer.Option("image", "--type", "-t", help="Media type preset for parameter detection: image (default), audio"),
+    media_type: str = typer.Option("image", "--type", "-t", help="Media type preset for parameter detection: image (default), audio, video"),
     from_server: bool = typer.Option(False, "--from-server", help="Import from ComfyUI server userdata"),
     preview: bool = typer.Option(False, "--preview", help="Preview only, don't import"),
     check_deps: bool = typer.Option(False, "--check-deps", help="Check dependencies after import"),

{comfyui_skill_cli-0.2.7 → comfyui_skill_cli-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=61"]
 
 [project]
 name = "comfyui-skill-cli"
-version = "0.2.7"
+version = "0.2.8"
 description = "ComfyUI Skill CLI — Agent-friendly workflow management"
 readme = "README.md"
 requires-python = ">=3.10"

comfyui_skill_cli-0.2.8/tests/test_client.py

@@ -0,0 +1,279 @@
+"""Tests for comfyui_skills_cli.client — all ComfyUIClient methods."""
+
+from __future__ import annotations
+
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+
+from comfyui_skills_cli.client import ComfyUIClient
+
+
+# -- queue_prompt --
+
+class QueuePromptTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_with_client_id(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200, json=lambda: {"prompt_id": "p-123"})
+        mock_post.return_value.raise_for_status = MagicMock()
+        result = self.client.queue_prompt({"1": {}}, client_id="my-client-id")
+        self.assertEqual(result["client_id"], "my-client-id")
+        self.assertEqual(result["prompt_id"], "p-123")
+        self.assertEqual(mock_post.call_args.kwargs["json"]["client_id"], "my-client-id")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_generates_client_id(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200, json=lambda: {"prompt_id": "p-456"})
+        mock_post.return_value.raise_for_status = MagicMock()
+        result = self.client.queue_prompt({"1": {}})
+        self.assertIn("client_id", result)
+        self.assertTrue(len(result["client_id"]) > 0)
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_with_targets(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200, json=lambda: {"prompt_id": "p-100"})
+        mock_post.return_value.raise_for_status = MagicMock()
+        self.client.queue_prompt({"1": {}}, targets=["5", "8"])
+        payload = mock_post.call_args.kwargs["json"]
+        self.assertEqual(payload["partial_execution_targets"], [["5"], ["8"]])
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_without_targets(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200, json=lambda: {"prompt_id": "p-101"})
+        mock_post.return_value.raise_for_status = MagicMock()
+        self.client.queue_prompt({"1": {}}, targets=None)
+        payload = mock_post.call_args.kwargs["json"]
+        self.assertNotIn("partial_execution_targets", payload)
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_with_empty_targets(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200, json=lambda: {"prompt_id": "p-102"})
+        mock_post.return_value.raise_for_status = MagicMock()
+        self.client.queue_prompt({"1": {}}, targets=[])
+        payload = mock_post.call_args.kwargs["json"]
+        self.assertNotIn("partial_execution_targets", payload)
+
+
+# -- interrupt / queue management / free --
+
+class InterruptTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_with_prompt_id(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        result = self.client.interrupt("abc-123")
+        self.assertTrue(result["success"])
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"prompt_id": "abc-123"})
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_without_prompt_id(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        result = self.client.interrupt()
+        self.assertTrue(result["success"])
+        self.assertEqual(mock_post.call_args.kwargs["json"], {})
+
+
+class QueueManagementTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_queue_clear(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        result = self.client.queue_clear()
+        self.assertTrue(result["success"])
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"clear": True})
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_queue_delete(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        result = self.client.queue_delete(["id-1", "id-2"])
+        self.assertTrue(result["success"])
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"delete": ["id-1", "id-2"]})
+
+
+class FreeMemoryTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_free_both(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        result = self.client.free_memory(unload_models=True, free_memory=True)
+        self.assertTrue(result["success"])
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"unload_models": True, "free_memory": True})
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_free_models_only(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        self.client.free_memory(unload_models=True, free_memory=False)
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"unload_models": True})
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_free_memory_only(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        self.client.free_memory(unload_models=False, free_memory=True)
+        self.assertEqual(mock_post.call_args.kwargs["json"], {"free_memory": True})
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_free_no_flags_sends_empty(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        self.client.free_memory(unload_models=False, free_memory=False)
+        self.assertEqual(mock_post.call_args.kwargs["json"], {})
+
+
+# -- upload --
+
+class UploadFileTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.post")
+    def test_upload_file_calls_upload_image_endpoint(self, mock_post: MagicMock) -> None:
+        mock_post.return_value = MagicMock(status_code=200)
+        mock_post.return_value.json.return_value = {"name": "test.png", "subfolder": "", "type": "input"}
+
+        import tempfile, os
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+            f.write(b"fake png data")
+            tmp_path = f.name
+
+        try:
+            result = self.client.upload_file(tmp_path)
+            self.assertEqual(result["name"], "test.png")
+            self.assertIn("/upload/image", mock_post.call_args.args[0])
+        finally:
+            os.unlink(tmp_path)
+
+    def test_upload_image_delegates_to_upload_file(self) -> None:
+        with patch.object(self.client, "upload_file", return_value={"name": "x.png"}) as mock:
+            result = self.client.upload_image("/fake/path.png")
+            mock.assert_called_once_with("/fake/path.png")
+            self.assertEqual(result["name"], "x.png")
+
+
+# -- object_info --
+
+class ObjectInfoNodeTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.get")
+    def test_found(self, mock_get: MagicMock) -> None:
+        mock_get.return_value = MagicMock(
+            status_code=200,
+            json=lambda: {"KSampler": {"display_name": "KSampler", "category": "sampling"}},
+        )
+        result = self.client.get_object_info_node("KSampler")
+        self.assertIsNotNone(result)
+        self.assertEqual(result["display_name"], "KSampler")
+
+    @patch("comfyui_skills_cli.client.requests.get")
+    def test_not_found(self, mock_get: MagicMock) -> None:
+        mock_get.return_value = MagicMock(status_code=404)
+        result = self.client.get_object_info_node("NonExistentNode")
+        self.assertIsNone(result)
+
+
+# -- system_stats --
+
+SAMPLE_STATS = {
+    "system": {
+        "os": "posix", "ram_total": 68719476736, "ram_free": 32000000000,
+        "comfyui_version": "v0.3.10", "python_version": "3.11.5",
+        "pytorch_version": "2.1.0", "embedded_python": False,
+    },
+    "devices": [{
+        "name": "cuda:0", "type": "cuda", "index": 0,
+        "vram_total": 25769803776, "vram_free": 20000000000,
+        "torch_vram_total": 25769803776, "torch_vram_free": 22000000000,
+    }],
+}
+
+
+class SystemStatsTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("comfyui_skills_cli.client.requests.get")
+    def test_success(self, mock_get: MagicMock) -> None:
+        mock_get.return_value = MagicMock(status_code=200, json=lambda: SAMPLE_STATS)
+        result = self.client.get_system_stats()
+        self.assertEqual(result, SAMPLE_STATS)
+
+    @patch("comfyui_skills_cli.client.requests.get")
+    def test_raises_on_error(self, mock_get: MagicMock) -> None:
+        mock_resp = MagicMock(status_code=500)
+        mock_resp.raise_for_status.side_effect = Exception("Server error")
+        mock_get.return_value = mock_resp
+        with self.assertRaises(Exception):
+            self.client.get_system_stats()
+
+    @patch("comfyui_skills_cli.client.requests.get")
+    def test_multi_server(self, mock_get: MagicMock) -> None:
+        mock_get.return_value = MagicMock(status_code=200, json=lambda: SAMPLE_STATS)
+        clients = [ComfyUIClient("http://s1:8188"), ComfyUIClient("http://s2:8188")]
+        results = [c.get_system_stats() for c in clients]
+        self.assertEqual(len(results), 2)
+        self.assertEqual(mock_get.call_count, 2)
+
+
+# -- ws_events --
+
+class WsEventsTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.client = ComfyUIClient("http://localhost:8188")
+
+    @patch("websocket.create_connection")
+    def test_yields_matching_events(self, mock_ws_create: MagicMock) -> None:
+        import websocket
+        mock_ws = MagicMock()
+        mock_ws_create.return_value = mock_ws
+        events = [
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "execution_start", "data": {"prompt_id": "p-1"}}).encode()),
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "executing", "data": {"node": "5", "prompt_id": "p-1"}}).encode()),
+            (websocket.ABNF.OPCODE_BINARY, b"\x01\x00\x00\x00fake-preview"),
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "executing", "data": {"node": None, "prompt_id": "p-1"}}).encode()),
+        ]
+        mock_ws.recv_data = MagicMock(side_effect=events)
+        collected = list(self.client.ws_events("cid-1", "p-1"))
+        self.assertEqual(len(collected), 3)
+        self.assertEqual(collected[0]["type"], "execution_start")
+        self.assertEqual(collected[1]["data"]["node"], "5")
+        self.assertIsNone(collected[2]["data"]["node"])
+        mock_ws.close.assert_called_once()
+
+    @patch("websocket.create_connection")
+    def test_filters_other_prompts(self, mock_ws_create: MagicMock) -> None:
+        import websocket
+        mock_ws = MagicMock()
+        mock_ws_create.return_value = mock_ws
+        events = [
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "executing", "data": {"node": "1", "prompt_id": "other"}}).encode()),
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "executing", "data": {"node": None, "prompt_id": "p-1"}}).encode()),
+        ]
+        mock_ws.recv_data = MagicMock(side_effect=events)
+        collected = list(self.client.ws_events("cid-1", "p-1"))
+        self.assertEqual(len(collected), 1)
+
+    @patch("websocket.create_connection")
+    def test_stops_on_error(self, mock_ws_create: MagicMock) -> None:
+        import websocket
+        mock_ws = MagicMock()
+        mock_ws_create.return_value = mock_ws
+        events = [
+            (websocket.ABNF.OPCODE_TEXT, json.dumps({"type": "execution_error", "data": {"prompt_id": "p-1", "exception_message": "boom"}}).encode()),
+        ]
+        mock_ws.recv_data = MagicMock(side_effect=events)
+        collected = list(self.client.ws_events("cid-1", "p-1"))
+        self.assertEqual(len(collected), 1)
+        self.assertEqual(collected[0]["type"], "execution_error")
+
+
+if __name__ == "__main__":
+    unittest.main()

comfyui_skill_cli-0.2.8/tests/test_error_hints.py

@@ -0,0 +1,95 @@
+"""Tests for comfyui_skills_cli.error_hints — all error pattern matching."""
+
+from __future__ import annotations
+
+import unittest
+
+from comfyui_skills_cli.error_hints import match_error_hint
+
+
+class ErrorHintTests(unittest.TestCase):
+    # -- Cloud API --
+    def test_unauthorized(self) -> None:
+        hint = match_error_hint("Unauthorized: Please login first to use this node.")
+        self.assertIn("ComfyUI API Key", hint)
+
+    # -- Missing models (specific) --
+    def test_vae_not_found(self) -> None:
+        hint = match_error_hint("Error: vae model not found in models/vae/")
+        self.assertIn("VAE", hint)
+        self.assertIn("deps check", hint)
+
+    def test_clip_not_found(self) -> None:
+        hint = match_error_hint("clip_vision.safetensors: No such file or directory")
+        self.assertIn("CLIP", hint)
+
+    def test_lora_not_found(self) -> None:
+        hint = match_error_hint("LoRA model detail_tweaker.safetensors not found")
+        self.assertIn("LoRA", hint)
+
+    # -- Missing models (generic) --
+    def test_ckpt(self) -> None:
+        hint = match_error_hint("FileNotFoundError: model_v1.ckpt not found")
+        self.assertIn("deps check", hint)
+
+    def test_safetensors(self) -> None:
+        hint = match_error_hint("Could not load sdxl_base.safetensors")
+        self.assertIn("deps check", hint)
+
+    # -- Custom nodes --
+    def test_class_type_not_found(self) -> None:
+        hint = match_error_hint("class_type not found: IPAdapterApply")
+        self.assertIn("custom node", hint)
+
+    def test_cannot_find_class(self) -> None:
+        hint = match_error_hint("Cannot find class for node type 'ControlNetApply'")
+        self.assertIn("custom node", hint)
+
+    # -- Validation --
+    def test_invalid_prompt(self) -> None:
+        hint = match_error_hint("Error: prompt is not valid")
+        self.assertIn("--validate", hint)
+
+    # -- Connection --
+    def test_connection_refused(self) -> None:
+        hint = match_error_hint("ConnectionError: Connection refused")
+        self.assertIn("not running", hint)
+
+    def test_connection_timeout(self) -> None:
+        hint = match_error_hint("ConnectionError: Connection timed out")
+        self.assertIn("timed out", hint)
+
+    def test_read_timeout(self) -> None:
+        hint = match_error_hint("requests.exceptions.ReadTimeout: timeout")
+        self.assertIn("timed out", hint)
+
+    # -- GPU / memory --
+    def test_cuda_oom(self) -> None:
+        hint = match_error_hint("RuntimeError: CUDA out of memory. Tried to allocate 2.00 GiB")
+        self.assertIn("comfyui-skill free", hint)
+
+    def test_mps_oom(self) -> None:
+        hint = match_error_hint("RuntimeError: MPS out of memory")
+        self.assertIn("comfyui-skill free", hint)
+
+    def test_cuda_driver_error(self) -> None:
+        hint = match_error_hint("RuntimeError: CUDA error: no kernel image is available")
+        self.assertIn("GPU driver", hint)
+
+    def test_no_cuda_gpus(self) -> None:
+        hint = match_error_hint("AssertionError: no CUDA GPUs are available")
+        self.assertIn("GPU driver", hint)
+
+    # -- General file --
+    def test_file_not_found(self) -> None:
+        hint = match_error_hint("FileNotFoundError: [Errno 2] No such file or directory: 'input.png'")
+        self.assertIn("required file is missing", hint)
+
+    # -- No match --
+    def test_unknown_error(self) -> None:
+        hint = match_error_hint("Some random error message")
+        self.assertEqual(hint, "")
+
+
+if __name__ == "__main__":
+    unittest.main()

comfyui_skill_cli-0.2.8/tests/test_nodes.py

@@ -0,0 +1,47 @@
+"""Tests for comfyui_skills_cli.commands.nodes — helper functions."""
+
+from __future__ import annotations
+
+import unittest
+
+from comfyui_skills_cli.commands.nodes import _flatten_nodes
+
+SAMPLE_OBJECT_INFO = {
+    "KSampler": {
+        "display_name": "KSampler",
+        "description": "Samples latents",
+        "category": "sampling",
+    },
+    "CLIPTextEncode": {
+        "display_name": "CLIP Text Encode",
+        "description": "",
+        "category": "conditioning",
+    },
+}
+
+
+class FlattenNodesTests(unittest.TestCase):
+    def test_all(self) -> None:
+        rows = _flatten_nodes(SAMPLE_OBJECT_INFO)
+        self.assertEqual(len(rows), 2)
+        self.assertEqual(rows[0]["category"], "conditioning")
+        self.assertEqual(rows[1]["category"], "sampling")
+
+    def test_with_category_filter(self) -> None:
+        rows = _flatten_nodes(SAMPLE_OBJECT_INFO, "sampling")
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["class_type"], "KSampler")
+
+    def test_nonexistent_category(self) -> None:
+        rows = _flatten_nodes(SAMPLE_OBJECT_INFO, "nonexistent")
+        self.assertEqual(len(rows), 0)
+
+
+class WsAvailableTests(unittest.TestCase):
+    def test_returns_bool(self) -> None:
+        from comfyui_skills_cli.commands.run import _ws_available
+        self.assertIsInstance(_ws_available(), bool)
+
+
+if __name__ == "__main__":
+    unittest.main()

comfyui_skill_cli-0.2.7/tests/test_client_new_apis.py

@@ -1,199 +0,0 @@
-"""Tests for new client methods and error hint matching."""
-
-from __future__ import annotations
-
-import unittest
-from unittest.mock import MagicMock, patch
-
-from comfyui_skills_cli.client import ComfyUIClient
-from comfyui_skills_cli.error_hints import match_error_hint
-
-
-class InterruptTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_interrupt_with_prompt_id(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        result = self.client.interrupt("abc-123")
-        self.assertTrue(result["success"])
-        call_kwargs = mock_post.call_args
-        self.assertIn("/interrupt", call_kwargs.args[0])
-        self.assertEqual(call_kwargs.kwargs["json"], {"prompt_id": "abc-123"})
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_interrupt_without_prompt_id(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        result = self.client.interrupt()
-        self.assertTrue(result["success"])
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {})
-
-
-class QueueManagementTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_clear(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        result = self.client.queue_clear()
-        self.assertTrue(result["success"])
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {"clear": True})
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_delete(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        result = self.client.queue_delete(["id-1", "id-2"])
-        self.assertTrue(result["success"])
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {"delete": ["id-1", "id-2"]})
-
-
-class FreeMemoryTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_free_both(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        result = self.client.free_memory(unload_models=True, free_memory=True)
-        self.assertTrue(result["success"])
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {"unload_models": True, "free_memory": True})
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_free_models_only(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        self.client.free_memory(unload_models=True, free_memory=False)
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {"unload_models": True})
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_free_memory_only(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        self.client.free_memory(unload_models=False, free_memory=True)
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {"free_memory": True})
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_free_no_flags_sends_empty(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        self.client.free_memory(unload_models=False, free_memory=False)
-        call_kwargs = mock_post.call_args
-        self.assertEqual(call_kwargs.kwargs["json"], {})
-
-
-class UploadFileTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_upload_file_calls_upload_image_endpoint(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(status_code=200)
-        mock_post.return_value.json.return_value = {"name": "test.png", "subfolder": "", "type": "input"}
-
-        import tempfile, os
-        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
-            f.write(b"fake png data")
-            tmp_path = f.name
-
-        try:
-            result = self.client.upload_file(tmp_path)
-            self.assertEqual(result["name"], "test.png")
-            call_args = mock_post.call_args
-            self.assertIn("/upload/image", call_args.args[0])
-        finally:
-            os.unlink(tmp_path)
-
-    def test_upload_image_delegates_to_upload_file(self) -> None:
-        with patch.object(self.client, "upload_file", return_value={"name": "x.png"}) as mock:
-            result = self.client.upload_image("/fake/path.png")
-            mock.assert_called_once_with("/fake/path.png")
-            self.assertEqual(result["name"], "x.png")
-
-
-class ErrorHintTests(unittest.TestCase):
-    def test_unauthorized_hint(self) -> None:
-        hint = match_error_hint("Unauthorized: Please login first to use this node.")
-        self.assertIn("ComfyUI API Key", hint)
-        self.assertIn("platform.comfy.org", hint)
-
-    def test_cuda_oom_hint(self) -> None:
-        hint = match_error_hint("RuntimeError: CUDA out of memory. Tried to allocate 2.00 GiB")
-        self.assertIn("comfyui-skill free", hint)
-
-    def test_mps_oom_hint(self) -> None:
-        hint = match_error_hint("RuntimeError: MPS out of memory")
-        self.assertIn("comfyui-skill free", hint)
-
-    def test_connection_refused_hint(self) -> None:
-        hint = match_error_hint("ConnectionError: Connection refused")
-        self.assertIn("not running", hint)
-
-    def test_missing_model_ckpt_hint(self) -> None:
-        hint = match_error_hint("FileNotFoundError: model_v1.ckpt not found")
-        self.assertIn("deps check", hint)
-
-    def test_missing_model_safetensors_hint(self) -> None:
-        hint = match_error_hint("Could not load sdxl_base.safetensors")
-        self.assertIn("deps check", hint)
-
-    def test_vae_not_found_hint(self) -> None:
-        hint = match_error_hint("Error: vae model not found in models/vae/")
-        self.assertIn("VAE", hint)
-        self.assertIn("deps check", hint)
-
-    def test_clip_not_found_hint(self) -> None:
-        hint = match_error_hint("clip_vision.safetensors: No such file or directory")
-        self.assertIn("CLIP", hint)
-        self.assertIn("deps check", hint)
-
-    def test_lora_not_found_hint(self) -> None:
-        hint = match_error_hint("LoRA model detail_tweaker.safetensors not found")
-        self.assertIn("LoRA", hint)
-        self.assertIn("deps check", hint)
-
-    def test_custom_node_not_installed_hint(self) -> None:
-        hint = match_error_hint("class_type not found: IPAdapterApply")
-        self.assertIn("custom node", hint)
-        self.assertIn("deps check", hint)
-
-    def test_custom_node_cannot_find_class_hint(self) -> None:
-        hint = match_error_hint("Cannot find class for node type 'ControlNetApply'")
-        self.assertIn("custom node", hint)
-
-    def test_connection_timeout_hint(self) -> None:
-        hint = match_error_hint("ConnectionError: Connection timed out")
-        self.assertIn("timed out", hint)
-
-    def test_timeout_hint(self) -> None:
-        hint = match_error_hint("requests.exceptions.ReadTimeout: timeout")
-        self.assertIn("timed out", hint)
-
-    def test_invalid_prompt_hint(self) -> None:
-        hint = match_error_hint("Error: prompt is not valid")
-        self.assertIn("validation errors", hint)
-        self.assertIn("--validate", hint)
-
-    def test_file_not_found_error_hint(self) -> None:
-        hint = match_error_hint("FileNotFoundError: [Errno 2] No such file or directory: 'input.png'")
-        self.assertIn("required file is missing", hint)
-
-    def test_cuda_error_hint(self) -> None:
-        hint = match_error_hint("RuntimeError: CUDA error: no kernel image is available")
-        self.assertIn("GPU driver", hint)
-
-    def test_no_cuda_gpus_hint(self) -> None:
-        hint = match_error_hint("AssertionError: no CUDA GPUs are available")
-        self.assertIn("GPU driver", hint)
-
-    def test_no_hint_for_unknown_error(self) -> None:
-        hint = match_error_hint("Some random error message")
-        self.assertEqual(hint, "")
-
-
-if __name__ == "__main__":
-    unittest.main()

comfyui_skill_cli-0.2.7/tests/test_nodes_and_ws.py

@@ -1,203 +0,0 @@
-"""Tests for nodes command helpers and WebSocket client methods."""
-
-from __future__ import annotations
-
-import json
-import unittest
-from unittest.mock import MagicMock, patch
-
-from comfyui_skills_cli.client import ComfyUIClient
-
-
-SAMPLE_OBJECT_INFO = {
-    "KSampler": {
-        "input": {
-            "required": {
-                "model": ["MODEL"],
-                "seed": ["INT", {"default": 0, "min": 0, "max": 2**64 - 1}],
-                "sampler_name": [["euler", "euler_ancestral", "heun"]],
-            },
-            "optional": {},
-        },
-        "input_order": {"required": ["model", "seed", "sampler_name"], "optional": []},
-        "output": ["LATENT"],
-        "output_is_list": [False],
-        "output_name": ["LATENT"],
-        "name": "KSampler",
-        "display_name": "KSampler",
-        "description": "Samples latents",
-        "category": "sampling",
-    },
-    "CLIPTextEncode": {
-        "input": {"required": {"text": ["STRING"], "clip": ["CLIP"]}, "optional": {}},
-        "input_order": {"required": ["text", "clip"], "optional": []},
-        "output": ["CONDITIONING"],
-        "output_is_list": [False],
-        "output_name": ["CONDITIONING"],
-        "name": "CLIPTextEncode",
-        "display_name": "CLIP Text Encode",
-        "description": "",
-        "category": "conditioning",
-    },
-}
-
-
-class ObjectInfoNodeTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.get")
-    def test_get_object_info_node_found(self, mock_get: MagicMock) -> None:
-        mock_get.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"KSampler": SAMPLE_OBJECT_INFO["KSampler"]},
-        )
-        result = self.client.get_object_info_node("KSampler")
-        self.assertIsNotNone(result)
-        self.assertEqual(result["display_name"], "KSampler")
-
-    @patch("comfyui_skills_cli.client.requests.get")
-    def test_get_object_info_node_not_found(self, mock_get: MagicMock) -> None:
-        mock_get.return_value = MagicMock(status_code=404)
-        result = self.client.get_object_info_node("NonExistentNode")
-        self.assertIsNone(result)
-
-
-class QueuePromptClientIdTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_prompt_with_client_id(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"prompt_id": "p-123"},
-        )
-        mock_post.return_value.raise_for_status = MagicMock()
-        result = self.client.queue_prompt({"1": {}}, client_id="my-client-id")
-        self.assertEqual(result["client_id"], "my-client-id")
-        self.assertEqual(result["prompt_id"], "p-123")
-        payload = mock_post.call_args.kwargs["json"]
-        self.assertEqual(payload["client_id"], "my-client-id")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_prompt_generates_client_id(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"prompt_id": "p-456"},
-        )
-        mock_post.return_value.raise_for_status = MagicMock()
-        result = self.client.queue_prompt({"1": {}})
-        self.assertIn("client_id", result)
-        self.assertTrue(len(result["client_id"]) > 0)
-
-
-class WsEventsTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("websocket.create_connection")
-    def test_ws_events_yields_matching_events(self, mock_ws_create: MagicMock) -> None:
-        import websocket
-
-        mock_ws = MagicMock()
-        mock_ws_create.return_value = mock_ws
-
-        events = [
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "execution_start",
-                "data": {"prompt_id": "p-1"},
-            }).encode()),
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "executing",
-                "data": {"node": "5", "prompt_id": "p-1"},
-            }).encode()),
-            (websocket.ABNF.OPCODE_BINARY, b"\x01\x00\x00\x00fake-preview"),
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "executing",
-                "data": {"node": None, "prompt_id": "p-1"},
-            }).encode()),
-        ]
-        mock_ws.recv_data = MagicMock(side_effect=events)
-
-        collected = list(self.client.ws_events("cid-1", "p-1"))
-        self.assertEqual(len(collected), 3)
-        self.assertEqual(collected[0]["type"], "execution_start")
-        self.assertEqual(collected[1]["type"], "executing")
-        self.assertEqual(collected[1]["data"]["node"], "5")
-        self.assertEqual(collected[2]["type"], "executing")
-        self.assertIsNone(collected[2]["data"]["node"])
-        mock_ws.close.assert_called_once()
-
-    @patch("websocket.create_connection")
-    def test_ws_events_filters_other_prompts(self, mock_ws_create: MagicMock) -> None:
-        import websocket
-
-        mock_ws = MagicMock()
-        mock_ws_create.return_value = mock_ws
-
-        events = [
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "executing",
-                "data": {"node": "1", "prompt_id": "other-prompt"},
-            }).encode()),
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "executing",
-                "data": {"node": None, "prompt_id": "p-1"},
-            }).encode()),
-        ]
-        mock_ws.recv_data = MagicMock(side_effect=events)
-
-        collected = list(self.client.ws_events("cid-1", "p-1"))
-        self.assertEqual(len(collected), 1)
-        self.assertIsNone(collected[0]["data"]["node"])
-
-    @patch("websocket.create_connection")
-    def test_ws_events_stops_on_error(self, mock_ws_create: MagicMock) -> None:
-        import websocket
-
-        mock_ws = MagicMock()
-        mock_ws_create.return_value = mock_ws
-
-        events = [
-            (websocket.ABNF.OPCODE_TEXT, json.dumps({
-                "type": "execution_error",
-                "data": {"prompt_id": "p-1", "exception_message": "boom"},
-            }).encode()),
-        ]
-        mock_ws.recv_data = MagicMock(side_effect=events)
-
-        collected = list(self.client.ws_events("cid-1", "p-1"))
-        self.assertEqual(len(collected), 1)
-        self.assertEqual(collected[0]["type"], "execution_error")
-
-
-class NodesFlattenTests(unittest.TestCase):
-    def test_flatten_all(self) -> None:
-        from comfyui_skills_cli.commands.nodes import _flatten_nodes
-        rows = _flatten_nodes(SAMPLE_OBJECT_INFO)
-        self.assertEqual(len(rows), 2)
-        self.assertEqual(rows[0]["category"], "conditioning")
-        self.assertEqual(rows[1]["category"], "sampling")
-
-    def test_flatten_with_category_filter(self) -> None:
-        from comfyui_skills_cli.commands.nodes import _flatten_nodes
-        rows = _flatten_nodes(SAMPLE_OBJECT_INFO, "sampling")
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["class_type"], "KSampler")
-
-    def test_flatten_with_nonexistent_category(self) -> None:
-        from comfyui_skills_cli.commands.nodes import _flatten_nodes
-        rows = _flatten_nodes(SAMPLE_OBJECT_INFO, "nonexistent")
-        self.assertEqual(len(rows), 0)
-
-
-class WsAvailableTests(unittest.TestCase):
-    def test_ws_available_true(self) -> None:
-        from comfyui_skills_cli.commands.run import _ws_available
-        result = _ws_available()
-        self.assertIsInstance(result, bool)
-
-
-if __name__ == "__main__":
-    unittest.main()

comfyui_skill_cli-0.2.7/tests/test_partial_execution.py

@@ -1,56 +0,0 @@
-"""Tests for partial execution targets in queue_prompt."""
-
-from __future__ import annotations
-
-import unittest
-from unittest.mock import MagicMock, patch
-
-from comfyui_skills_cli.client import ComfyUIClient
-
-
-class PartialExecutionTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_prompt_with_targets(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"prompt_id": "p-100"},
-        )
-        mock_post.return_value.raise_for_status = MagicMock()
-
-        self.client.queue_prompt({"1": {}}, targets=["5", "8"])
-
-        payload = mock_post.call_args.kwargs["json"]
-        self.assertEqual(payload["partial_execution_targets"], [["5"], ["8"]])
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_prompt_without_targets(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"prompt_id": "p-101"},
-        )
-        mock_post.return_value.raise_for_status = MagicMock()
-
-        self.client.queue_prompt({"1": {}}, targets=None)
-
-        payload = mock_post.call_args.kwargs["json"]
-        self.assertNotIn("partial_execution_targets", payload)
-
-    @patch("comfyui_skills_cli.client.requests.post")
-    def test_queue_prompt_with_empty_targets(self, mock_post: MagicMock) -> None:
-        mock_post.return_value = MagicMock(
-            status_code=200,
-            json=lambda: {"prompt_id": "p-102"},
-        )
-        mock_post.return_value.raise_for_status = MagicMock()
-
-        self.client.queue_prompt({"1": {}}, targets=[])
-
-        payload = mock_post.call_args.kwargs["json"]
-        self.assertNotIn("partial_execution_targets", payload)
-
-
-if __name__ == "__main__":
-    unittest.main()

comfyui_skill_cli-0.2.7/tests/test_server_stats.py

@@ -1,90 +0,0 @@
-"""Tests for the server stats command and client method."""
-
-from __future__ import annotations
-
-import unittest
-from unittest.mock import MagicMock, patch
-
-from comfyui_skills_cli.client import ComfyUIClient
-
-
-SAMPLE_STATS = {
-    "system": {
-        "os": "posix",
-        "ram_total": 68719476736,
-        "ram_free": 32000000000,
-        "comfyui_version": "v0.3.10",
-        "python_version": "3.11.5",
-        "pytorch_version": "2.1.0",
-        "embedded_python": False,
-    },
-    "devices": [
-        {
-            "name": "cuda:0",
-            "type": "cuda",
-            "index": 0,
-            "vram_total": 25769803776,
-            "vram_free": 20000000000,
-            "torch_vram_total": 25769803776,
-            "torch_vram_free": 22000000000,
-        }
-    ],
-}
-
-
-class GetSystemStatsTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.client = ComfyUIClient("http://localhost:8188")
-
-    @patch("comfyui_skills_cli.client.requests.get")
-    def test_get_system_stats_success(self, mock_get: MagicMock) -> None:
-        mock_resp = MagicMock(status_code=200)
-        mock_resp.json.return_value = SAMPLE_STATS
-        mock_get.return_value = mock_resp
-
-        result = self.client.get_system_stats()
-
-        self.assertEqual(result, SAMPLE_STATS)
-        self.assertIn("/system_stats", mock_get.call_args.args[0])
-
-    @patch("comfyui_skills_cli.client.requests.get")
-    def test_get_system_stats_raises_on_error(self, mock_get: MagicMock) -> None:
-        mock_resp = MagicMock(status_code=500)
-        mock_resp.raise_for_status.side_effect = Exception("Server error")
-        mock_get.return_value = mock_resp
-
-        with self.assertRaises(Exception):
-            self.client.get_system_stats()
-
-
-class ServerStatsAllTests(unittest.TestCase):
-    """Test that --all queries multiple servers."""
-
-    @patch("comfyui_skills_cli.client.requests.get")
-    def test_all_queries_multiple_servers(self, mock_get: MagicMock) -> None:
-        mock_resp = MagicMock(status_code=200)
-        mock_resp.json.return_value = SAMPLE_STATS
-        mock_get.return_value = mock_resp
-
-        # Create two clients (simulating what the command does)
-        clients = [
-            ComfyUIClient("http://server1:8188"),
-            ComfyUIClient("http://server2:8188"),
-        ]
-
-        results = []
-        for c in clients:
-            results.append(c.get_system_stats())
-
-        self.assertEqual(len(results), 2)
-        self.assertEqual(results[0]["system"]["comfyui_version"], "v0.3.10")
-        self.assertEqual(results[1]["system"]["comfyui_version"], "v0.3.10")
-        # Verify both servers were called
-        self.assertEqual(mock_get.call_count, 2)
-        urls_called = [call.args[0] for call in mock_get.call_args_list]
-        self.assertIn("http://server1:8188/system_stats", urls_called)
-        self.assertIn("http://server2:8188/system_stats", urls_called)
-
-
-if __name__ == "__main__":
-    unittest.main()