comfyui-skill-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/PKG-INFO

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

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/comfyui_skill_cli.egg-info/PKG-INFO

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

comfyui_skill_cli-0.2.3/comfyui_skills_cli/__init__.py

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

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/comfyui_skills_cli/commands/run.py

@@ -4,11 +4,15 @@ from __future__ import annotations
 
 import copy
 import json
+import logging
 import os
 import time
 import uuid
+from pathlib import Path
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 import typer
 
 from ..client import ComfyUIClient
@@ -28,7 +32,7 @@ def run_cmd(
 ):
     """Execute a skill (blocking — waits for completion)."""
     base_dir, server_id, workflow_id = _resolve_skill(ctx, skill_id)
-    client, schema_data, workflow_data = _prepare(ctx, base_dir, server_id, workflow_id)
+    client, schema_data, workflow_data, server_config = _prepare(ctx, base_dir, server_id, workflow_id)
 
     input_args = _parse_args(ctx, args)
     parameters = _get_parameters(schema_data)
@@ -65,8 +69,9 @@ def run_cmd(
             status_info = history.get("status", {})
 
             if status_info.get("completed", False) or outputs:
-                images = _collect_outputs(outputs)
-                output_event(ctx, "completed", prompt_id=prompt_id, outputs=images)
+                collected = _collect_outputs(outputs)
+                collected = _download_outputs(client, collected, base_dir, server_config)
+                output_event(ctx, "completed", prompt_id=prompt_id, outputs=collected)
 
                 # Final result — json and stream-json both get this
                 if fmt == OutputFormat.STREAM_JSON:
@@ -74,7 +79,7 @@ def run_cmd(
                 output_result(ctx, {
                     "status": "success",
                     "prompt_id": prompt_id,
-                    "outputs": images,
+                    "outputs": collected,
                 })
                 return
 
@@ -118,7 +123,7 @@ def submit_cmd(
 ):
     """Submit a skill for execution (non-blocking — returns immediately)."""
     base_dir, server_id, workflow_id = _resolve_skill(ctx, skill_id)
-    client, schema_data, workflow_data = _prepare(ctx, base_dir, server_id, workflow_id)
+    client, schema_data, workflow_data, _server_config = _prepare(ctx, base_dir, server_id, workflow_id)
 
     input_args = _parse_args(ctx, args)
     parameters = _get_parameters(schema_data)
@@ -157,8 +162,8 @@ def status_cmd(
         status_info = history.get("status", {})
         outputs = history.get("outputs", {})
         if status_info.get("completed", False) or outputs:
-            images = _collect_outputs(outputs)
-            output_result(ctx, {"status": "success", "prompt_id": prompt_id, "outputs": images})
+            collected = _collect_outputs(outputs)
+            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)})
@@ -203,7 +208,7 @@ def _prepare(ctx: typer.Context, base_dir: Any, server_id: str, workflow_id: str
         output_error(ctx, "SKILL_NOT_FOUND", f'Skill "{server_id}/{workflow_id}" not found.')
 
     client = _build_client(server_config)
-    return client, schema_data or {}, workflow_data
+    return client, schema_data or {}, workflow_data, server_config
 
 
 def _build_client(server_config: dict[str, Any]) -> ComfyUIClient:
@@ -249,18 +254,55 @@ def _inject_params(
     return workflow
 
 
+_MEDIA_KEYS: dict[str, str] = {
+    "images": "image",
+    "audio": "audio",
+    "gifs": "image",
+    "video": "video",
+}
+
+
 def _collect_outputs(outputs: dict[str, Any]) -> list[dict[str, str]]:
-    images = []
+    collected: list[dict[str, str]] = []
     for node_output in outputs.values():
         if not isinstance(node_output, dict):
             continue
-        for img in node_output.get("images", []):
-            images.append({
-                "filename": img.get("filename", ""),
-                "subfolder": img.get("subfolder", ""),
-                "type": img.get("type", "output"),
-            })
-    return images
+        for key, media_type in _MEDIA_KEYS.items():
+            for item in node_output.get(key, []):
+                collected.append({
+                    "filename": item.get("filename", ""),
+                    "subfolder": item.get("subfolder", ""),
+                    "type": item.get("type", "output"),
+                    "media_type": media_type,
+                })
+    return collected
+
+
+def _download_outputs(
+    client: ComfyUIClient,
+    outputs: list[dict[str, str]],
+    base_dir: Path,
+    server_config: dict[str, Any],
+) -> list[dict[str, str]]:
+    raw_dir = str(server_config.get("output_dir", "./outputs")).strip() or "./outputs"
+    output_dir = Path(raw_dir) if Path(raw_dir).is_absolute() else base_dir / raw_dir
+    for item in outputs:
+        try:
+            data = client.download_output(
+                item["filename"],
+                item.get("subfolder", ""),
+                item.get("type", "output"),
+            )
+            subfolder = item.get("subfolder", "")
+            local_dir = output_dir / subfolder if subfolder else output_dir
+            local_dir.mkdir(parents=True, exist_ok=True)
+            local_path = local_dir / item["filename"]
+            local_path.write_bytes(data)
+            item["local_path"] = str(local_path)
+        except Exception as exc:
+            logger.warning("Failed to download %s: %s", item["filename"], exc)
+            item["local_path"] = ""
+    return outputs
 
 
 def _format_errors(history: dict[str, Any]) -> str:

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/comfyui_skills_cli/commands/workflow.py

@@ -57,6 +57,20 @@ _AUTO_EXPOSE_FIELDS: dict[str, dict[str, Any]] = {
     "filename_prefix": {"exposed": True, "required": False, "description": "Output file prefix"},
 }
 
+_MEDIA_TYPE_FIELDS: dict[str, dict[str, dict[str, Any]]] = {
+    "audio": {
+        "tags": {"exposed": True, "required": True, "description": "Music style/genre tags"},
+        "lyrics": {"exposed": True, "required": False, "description": "Song lyrics"},
+        "bpm": {"exposed": True, "required": False, "description": "Beats per minute"},
+        "duration": {"exposed": True, "required": False, "description": "Audio duration"},
+        "seconds": {"exposed": True, "required": False, "description": "Duration in seconds"},
+        "language": {"exposed": True, "required": False, "description": "Language code"},
+        "keyscale": {"exposed": True, "required": False, "description": "Musical key and scale"},
+        "cfg_scale": {"exposed": True, "required": False, "description": "Classifier-free guidance scale"},
+        "temperature": {"exposed": True, "required": False, "description": "Sampling temperature"},
+    },
+}
+
 _LOAD_IMAGE_CLASSES = {"LoadImage", "LoadImageMask"}
 
 
@@ -70,8 +84,17 @@ def _get_type_guess(value: Any) -> str:
     return "string"
 
 
-def _extract_schema(workflow_data: dict[str, Any]) -> dict[str, dict[str, Any]]:
-    """Extract parameters from API-format workflow and build schema."""
+def _extract_schema(workflow_data: dict[str, Any], media_type: str = "image") -> dict[str, dict[str, Any]]:
+    """Extract parameters from API-format workflow and build schema.
+
+    *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.
+    """
+    expose_fields = dict(_AUTO_EXPOSE_FIELDS)
+    if media_type in _MEDIA_TYPE_FIELDS:
+        expose_fields.update(_MEDIA_TYPE_FIELDS[media_type])
+
     raw_params: list[dict[str, Any]] = []
 
     for node_id, node in workflow_data.items():
@@ -92,8 +115,8 @@ def _extract_schema(workflow_data: dict[str, Any]) -> dict[str, dict[str, Any]]:
                 exposed, required = True, True
                 description = "Upload an image"
                 field_type = "image"
-            elif field in _AUTO_EXPOSE_FIELDS:
-                info = _AUTO_EXPOSE_FIELDS[field]
+            elif field in expose_fields:
+                info = expose_fields[field]
                 exposed = info["exposed"]
                 required = info["required"]
                 description = info["description"]
@@ -360,11 +383,18 @@ 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"),
     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"),
 ):
-    """Import a workflow from local JSON or ComfyUI server."""
+    """Import a workflow from local JSON or ComfyUI server.
+
+    Use --type to select a parameter detection preset. The default (image)
+    detects generic fields like seed, steps, and prompt. Use --type audio
+    to also detect audio-specific fields like tags, lyrics, bpm, duration,
+    keyscale, language, cfg_scale, and temperature.
+    """
     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)
@@ -375,9 +405,9 @@ def workflow_import(
         return
 
     if from_server:
-        _import_from_server(ctx, base_dir, server_id, server_config, name, preview, check_deps)
+        _import_from_server(ctx, base_dir, server_id, server_config, name, preview, check_deps, media_type)
     elif json_path:
-        _import_from_file(ctx, base_dir, server_id, server_config, json_path, name, preview, check_deps)
+        _import_from_file(ctx, base_dir, server_id, server_config, json_path, name, preview, check_deps, media_type)
     else:
         output_error(ctx, "INVALID_ARGS", "Provide a JSON file path or use --from-server.")
 
@@ -385,7 +415,7 @@ def workflow_import(
 def _import_from_file(
     ctx: typer.Context, base_dir: Path, server_id: str,
     server_config: dict[str, Any], json_path: str, name: str,
-    preview: bool, check_deps: bool,
+    preview: bool, check_deps: bool, media_type: str = "image",
 ) -> None:
     if not os.path.isfile(json_path):
         output_error(ctx, "FILE_NOT_FOUND", f'File not found: "{json_path}"')
@@ -425,7 +455,7 @@ def _import_from_file(
         return
 
     # Generate schema
-    parameters = _extract_schema(api_data)
+    parameters = _extract_schema(api_data, media_type)
 
     if preview:
         output_result(ctx, {
@@ -496,7 +526,7 @@ def _import_from_file(
 def _import_from_server(
     ctx: typer.Context, base_dir: Path, server_id: str,
     server_config: dict[str, Any], name_filter: str,
-    preview: bool, check_deps: bool,
+    preview: bool, check_deps: bool, media_type: str = "image",
 ) -> None:
     client = ComfyUIClient(
         server_url=server_config.get("url", "http://127.0.0.1:8188"),
@@ -553,7 +583,7 @@ def _import_from_server(
 
         filename = os.path.basename(wf_path)
         workflow_id = _suggest_workflow_id(api_data, filename)
-        parameters = _extract_schema(api_data)
+        parameters = _extract_schema(api_data, media_type)
 
         workflow_dir = base_dir / "data" / server_id / workflow_id
         workflow_dir.mkdir(parents=True, exist_ok=True)

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/comfyui_skills_cli/main.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import typer
 
+from . import __version__
 from .commands import config, deps, history, run, server, skill, upload, workflow
 
 app = typer.Typer(
@@ -15,9 +16,16 @@ app = typer.Typer(
 )
 
 
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"comfyui-skill {__version__}")
+        raise typer.Exit()
+
+
 @app.callback()
 def main(
     ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-V", callback=_version_callback, is_eager=True, help="Show version and exit"),
     json_output: bool = typer.Option(False, "--json", "-j", help="JSON output (shortcut for --output-format json)"),
     output_format: str = typer.Option("", "--output-format", help="Output format: text, json, stream-json"),
     server_id: str = typer.Option("", "--server", "-s", help="Server ID"),

{comfyui_skill_cli-0.2.2 → comfyui_skill_cli-0.2.3}/pyproject.toml

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