comfyui-skill-cli 0.2.4__tar.gz → 0.2.5__tar.gz

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfyui-skill-cli
-Version: 0.2.4
+Version: 0.2.5
 Summary: ComfyUI Skill CLI — Agent-friendly workflow management
 Author: HuangYuChuh
 License-Expression: MIT

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfyui-skill-cli
-Version: 0.2.4
+Version: 0.2.5
 Summary: ComfyUI Skill CLI — Agent-friendly workflow management
 Author: HuangYuChuh
 License-Expression: MIT

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skill_cli.egg-info/SOURCES.txt

@@ -11,17 +11,22 @@ comfyui_skills_cli/__init__.py
 comfyui_skills_cli/__main__.py
 comfyui_skills_cli/client.py
 comfyui_skills_cli/config.py
+comfyui_skills_cli/error_hints.py
 comfyui_skills_cli/main.py
 comfyui_skills_cli/output.py
 comfyui_skills_cli/storage.py
 comfyui_skills_cli/update_check.py
 comfyui_skills_cli/commands/__init__.py
+comfyui_skills_cli/commands/cancel.py
 comfyui_skills_cli/commands/config.py
 comfyui_skills_cli/commands/deps.py
+comfyui_skills_cli/commands/free.py
 comfyui_skills_cli/commands/history.py
+comfyui_skills_cli/commands/queue.py
 comfyui_skills_cli/commands/run.py
 comfyui_skills_cli/commands/server.py
 comfyui_skills_cli/commands/skill.py
 comfyui_skills_cli/commands/upload.py
 comfyui_skills_cli/commands/workflow.py
+tests/test_client_new_apis.py
 tests/test_update_check.py

comfyui_skill_cli-0.2.5/comfyui_skills_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.5"

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skills_cli/client.py

@@ -126,13 +126,43 @@ class ComfyUIClient:
         except (requests.RequestException, ValueError):
             return None
 
-    # -- Image upload --
+    # -- Queue management --
 
-    def upload_image(self, filepath: str) -> dict[str, Any]:
+    def interrupt(self, prompt_id: str = "") -> dict[str, Any]:
+        payload = {"prompt_id": prompt_id} if prompt_id else {}
+        resp = self._post("/interrupt", json_data=payload)
+        resp.raise_for_status()
+        return {"success": True}
+
+    def queue_delete(self, prompt_ids: list[str]) -> dict[str, Any]:
+        resp = self._post("/queue", json_data={"delete": prompt_ids})
+        resp.raise_for_status()
+        return {"success": True}
+
+    def queue_clear(self) -> dict[str, Any]:
+        resp = self._post("/queue", json_data={"clear": True})
+        resp.raise_for_status()
+        return {"success": True}
+
+    # -- Memory management --
+
+    def free_memory(self, unload_models: bool = False, free_memory: bool = False) -> dict[str, Any]:
+        payload: dict[str, Any] = {}
+        if unload_models:
+            payload["unload_models"] = True
+        if free_memory:
+            payload["free_memory"] = True
+        resp = self._post("/free", json_data=payload)
+        resp.raise_for_status()
+        return {"success": True}
+
+    # -- File upload --
+
+    def upload_file(self, filepath: str) -> dict[str, Any]:
         import mimetypes
         import os
         filename = os.path.basename(filepath)
-        content_type = mimetypes.guess_type(filepath)[0] or "image/png"
+        content_type = mimetypes.guess_type(filepath)[0] or "application/octet-stream"
         with open(filepath, "rb") as f:
             content = f.read()
 
@@ -154,6 +184,9 @@ class ComfyUIClient:
         resp.raise_for_status()
         return resp.json()
 
+    def upload_image(self, filepath: str) -> dict[str, Any]:
+        return self.upload_file(filepath)
+
     # -- ComfyUI Userdata API --
 
     def list_userdata_workflows(self) -> list[str]:

comfyui_skill_cli-0.2.5/comfyui_skills_cli/commands/cancel.py

@@ -0,0 +1,51 @@
+"""comfyui-skill cancel — cancel a running or queued job."""
+
+from __future__ import annotations
+
+import typer
+
+from ..client import ComfyUIClient
+from ..config import get_base_dir, get_default_server_id, get_server, load_config
+from ..output import output_error, output_result
+
+
+def cancel_cmd(
+    ctx: typer.Context,
+    prompt_id: str = typer.Argument(help="Prompt ID to cancel"),
+):
+    """Cancel a running or queued job. Interrupts if running, removes from queue if pending."""
+    base_dir = get_base_dir(ctx.obj.get("base_dir", ""))
+    config = load_config(base_dir)
+    server_id = ctx.obj.get("server") or get_default_server_id(config)
+    server_config = get_server(config, server_id)
+
+    if not server_config:
+        output_error(ctx, "SERVER_NOT_FOUND", f'Server "{server_id}" not found.')
+        return
+
+    client = ComfyUIClient(
+        server_url=server_config.get("url", "http://127.0.0.1:8188"),
+        auth=server_config.get("auth", ""),
+    )
+
+    try:
+        queue = client.get_queue()
+
+        # Check if running
+        for item in queue.get("queue_running", []):
+            if len(item) > 1 and item[1] == prompt_id:
+                client.interrupt(prompt_id)
+                output_result(ctx, {"status": "interrupted", "prompt_id": prompt_id})
+                return
+
+        # Check if pending
+        for item in queue.get("queue_pending", []):
+            if len(item) > 1 and item[1] == prompt_id:
+                client.queue_delete([prompt_id])
+                output_result(ctx, {"status": "removed", "prompt_id": prompt_id})
+                return
+
+        output_result(ctx, {"status": "not_found", "prompt_id": prompt_id})
+
+    except Exception as exc:
+        output_error(ctx, "CANCEL_FAILED", f"Failed to cancel job: {exc}")

comfyui_skill_cli-0.2.5/comfyui_skills_cli/commands/free.py

@@ -0,0 +1,46 @@
+"""comfyui-skill free — release GPU memory and unload models."""
+
+from __future__ import annotations
+
+import typer
+
+from ..client import ComfyUIClient
+from ..config import get_base_dir, get_default_server_id, get_server, load_config
+from ..output import output_error, output_result
+
+
+def free_cmd(
+    ctx: typer.Context,
+    models: bool = typer.Option(False, "--models", "-m", help="Unload all models from VRAM"),
+    memory: bool = typer.Option(False, "--memory", help="Free all cached memory"),
+):
+    """Release GPU memory. With no flags, unloads models and frees memory."""
+    base_dir = get_base_dir(ctx.obj.get("base_dir", ""))
+    config = load_config(base_dir)
+    server_id = ctx.obj.get("server") or get_default_server_id(config)
+    server_config = get_server(config, server_id)
+
+    if not server_config:
+        output_error(ctx, "SERVER_NOT_FOUND", f'Server "{server_id}" not found.')
+        return
+
+    client = ComfyUIClient(
+        server_url=server_config.get("url", "http://127.0.0.1:8188"),
+        auth=server_config.get("auth", ""),
+    )
+
+    # Default: both if no flag specified
+    if not models and not memory:
+        models = True
+        memory = True
+
+    try:
+        client.free_memory(unload_models=models, free_memory=memory)
+        actions = []
+        if models:
+            actions.append("models_unloaded")
+        if memory:
+            actions.append("memory_freed")
+        output_result(ctx, {"status": "ok", "actions": actions, "server_id": server_id})
+    except Exception as exc:
+        output_error(ctx, "FREE_FAILED", f"Failed to free memory: {exc}")

comfyui_skill_cli-0.2.5/comfyui_skills_cli/commands/queue.py

@@ -0,0 +1,82 @@
+"""comfyui-skill queue — view and manage the ComfyUI execution queue."""
+
+from __future__ import annotations
+
+from typing import List
+
+import typer
+
+from ..client import ComfyUIClient
+from ..config import get_base_dir, get_default_server_id, get_server, load_config
+from ..output import output_error, output_result
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _build_client(ctx: typer.Context) -> tuple[ComfyUIClient, str]:
+    base_dir = get_base_dir(ctx.obj.get("base_dir", ""))
+    config = load_config(base_dir)
+    server_id = ctx.obj.get("server") or get_default_server_id(config)
+    server_config = get_server(config, server_id)
+
+    if not server_config:
+        output_error(ctx, "SERVER_NOT_FOUND", f'Server "{server_id}" not found.')
+
+    client = ComfyUIClient(
+        server_url=server_config.get("url", "http://127.0.0.1:8188"),
+        auth=server_config.get("auth", ""),
+    )
+    return client, server_id
+
+
+@app.command("list")
+def queue_list(ctx: typer.Context):
+    """Show running and pending jobs in the queue."""
+    client, server_id = _build_client(ctx)
+
+    try:
+        queue = client.get_queue()
+        running = [
+            {"prompt_id": item[1], "status": "running"}
+            for item in queue.get("queue_running", [])
+            if len(item) > 1
+        ]
+        pending = [
+            {"prompt_id": item[1], "status": "pending", "position": i}
+            for i, item in enumerate(queue.get("queue_pending", []))
+            if len(item) > 1
+        ]
+        output_result(ctx, {
+            "server_id": server_id,
+            "running": running,
+            "pending": pending,
+        })
+    except Exception as exc:
+        output_error(ctx, "QUEUE_FAILED", f"Failed to get queue: {exc}")
+
+
+@app.command("clear")
+def queue_clear(ctx: typer.Context):
+    """Clear all pending jobs from the queue (does not stop running jobs)."""
+    client, server_id = _build_client(ctx)
+
+    try:
+        client.queue_clear()
+        output_result(ctx, {"status": "cleared", "server_id": server_id})
+    except Exception as exc:
+        output_error(ctx, "QUEUE_FAILED", f"Failed to clear queue: {exc}")
+
+
+@app.command("delete")
+def queue_delete(
+    ctx: typer.Context,
+    prompt_ids: List[str] = typer.Argument(help="Prompt IDs to remove from queue"),
+):
+    """Remove specific jobs from the pending queue."""
+    client, server_id = _build_client(ctx)
+
+    try:
+        client.queue_delete(prompt_ids)
+        output_result(ctx, {"status": "deleted", "prompt_ids": prompt_ids, "server_id": server_id})
+    except Exception as exc:
+        output_error(ctx, "QUEUE_FAILED", f"Failed to delete from queue: {exc}")

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skills_cli/commands/run.py

@@ -18,6 +18,7 @@ import typer
 from ..client import ComfyUIClient
 from ..config import get_base_dir, get_default_server_id, get_server, load_config
 from ..output import OutputFormat, get_output_format, is_machine_mode, output_error, output_event, output_result
+from ..error_hints import match_error_hint
 from ..storage import get_schema, get_workflow_data
 
 _POLL_INITIAL = 1.0
@@ -85,8 +86,9 @@ def run_cmd(
 
             if status_info.get("status_str") == "error":
                 error_msg = _format_errors(history)
+                hint = match_error_hint(error_msg)
                 output_event(ctx, "error", prompt_id=prompt_id, message=error_msg)
-                output_error(ctx, "EXECUTION_FAILED", error_msg)
+                output_error(ctx, "EXECUTION_FAILED", error_msg, hint=hint)
                 return
 
         # Check queue position
@@ -166,7 +168,12 @@ def status_cmd(
             output_result(ctx, {"status": "success", "prompt_id": prompt_id, "outputs": collected})
             return
         if status_info.get("status_str") == "error":
-            output_result(ctx, {"status": "error", "prompt_id": prompt_id, "error": _format_errors(history)})
+            error_msg = _format_errors(history)
+            hint = match_error_hint(error_msg)
+            result: dict[str, Any] = {"status": "error", "prompt_id": prompt_id, "error": error_msg}
+            if hint:
+                result["hint"] = hint
+            output_result(ctx, result)
             return
 
     # Check queue

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skills_cli/commands/upload.py

@@ -1,4 +1,4 @@
-"""comfyui-skill upload — upload images to ComfyUI server."""
+"""comfyui-skill upload — upload files to ComfyUI server."""
 
 from __future__ import annotations
 
@@ -13,11 +13,11 @@ from ..output import output_error, output_result
 
 def upload_cmd(
     ctx: typer.Context,
-    image_path: str = typer.Argument(help="Path to image file"),
+    file_path: str = typer.Argument(help="Path to file (image, mask, audio, etc.)"),
 ):
-    """Upload an image to ComfyUI for use in workflows."""
-    if not os.path.isfile(image_path):
-        output_error(ctx, "FILE_NOT_FOUND", f'Image file not found: "{image_path}"')
+    """Upload a file to ComfyUI for use in workflows (e.g., images, masks, audio)."""
+    if not os.path.isfile(file_path):
+        output_error(ctx, "FILE_NOT_FOUND", f'File not found: "{file_path}"')
         return
 
     base_dir = get_base_dir(ctx.obj.get("base_dir", ""))
@@ -35,7 +35,7 @@ def upload_cmd(
     )
 
     try:
-        result = client.upload_image(image_path)
+        result = client.upload_file(file_path)
         output_result(ctx, {
             "name": result.get("name", ""),
             "subfolder": result.get("subfolder", ""),

comfyui_skill_cli-0.2.5/comfyui_skills_cli/error_hints.py

@@ -0,0 +1,43 @@
+"""Common error pattern matching — maps ComfyUI errors to actionable hints."""
+
+from __future__ import annotations
+
+# Common error patterns → actionable hints
+_ERROR_HINTS: list[tuple[str, str]] = [
+    (
+        "Unauthorized: Please login first",
+        "This workflow uses ComfyUI cloud API nodes. "
+        "Configure a ComfyUI API Key: (1) Go to https://platform.comfy.org to generate a key, "
+        '(2) Add it to server settings via Web UI or config.json "comfy_api_key" field.',
+    ),
+    (
+        "ckpt",
+        "A required model file is missing. "
+        "Run `comfyui-skill deps check <workflow_id>` to identify missing models.",
+    ),
+    (
+        "safetensors",
+        "A required model file is missing. "
+        "Run `comfyui-skill deps check <workflow_id>` to identify missing models.",
+    ),
+    (
+        "Connection refused",
+        "ComfyUI server is not running. Start ComfyUI and try again.",
+    ),
+    (
+        "CUDA out of memory",
+        "GPU memory exhausted. Run `comfyui-skill free` to release VRAM, then retry.",
+    ),
+    (
+        "MPS out of memory",
+        "GPU memory exhausted. Run `comfyui-skill free` to release VRAM, then retry.",
+    ),
+]
+
+
+def match_error_hint(error_msg: str) -> str:
+    lower = error_msg.lower()
+    for pattern, hint in _ERROR_HINTS:
+        if pattern.lower() in lower:
+            return hint
+    return ""

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/comfyui_skills_cli/main.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import typer
 
 from . import __version__
-from .commands import config, deps, history, run, server, skill, upload, workflow
+from .commands import cancel, config, deps, free, history, queue, run, server, skill, upload, workflow
 from .update_check import is_machine_output, maybe_notify_update
 
 app = typer.Typer(
@@ -49,7 +49,7 @@ def main(
 
 
 # Subcommand groups — each needs a callback to inherit parent context
-for sub_app in [config.app, deps.app, history.app, server.app, workflow.app]:
+for sub_app in [config.app, deps.app, history.app, queue.app, server.app, workflow.app]:
     @sub_app.callback()
     def _pass_context(ctx: typer.Context):
         if ctx.parent and ctx.parent.obj:
@@ -59,6 +59,7 @@ for sub_app in [config.app, deps.app, history.app, server.app, workflow.app]:
 app.add_typer(config.app, name="config", help="Import/export configuration")
 app.add_typer(deps.app, name="deps", help="Manage dependencies")
 app.add_typer(history.app, name="history", help="Execution history")
+app.add_typer(queue.app, name="queue", help="View and manage execution queue")
 app.add_typer(server.app, name="server", help="Manage servers")
 app.add_typer(workflow.app, name="workflow", help="Manage workflows")
 
@@ -69,3 +70,5 @@ app.command("run")(run.run_cmd)
 app.command("submit")(run.submit_cmd)
 app.command("status")(run.status_cmd)
 app.command("upload")(upload.upload_cmd)
+app.command("cancel")(cancel.cancel_cmd)
+app.command("free")(free.free_cmd)

{comfyui_skill_cli-0.2.4 → comfyui_skill_cli-0.2.5}/pyproject.toml

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

comfyui_skill_cli-0.2.5/tests/test_client_new_apis.py

@@ -0,0 +1,150 @@
+"""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_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.4/comfyui_skills_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.4"