@baimingtao/lbs-agent 1.0.0

package/extensions/skills/builtin/creative/comfyui/scripts/comfyui_setup.sh

@@ -0,0 +1,286 @@
+#!/usr/bin/env bash
+# ComfyUI Setup — Install, launch, and verify using the official comfy-cli.
+#
+# Improvements over v1:
+#   - Prefers `pipx` / `uvx` over global `pip install` (avoids polluting system Python)
+#   - Idempotent: detects already-running server and skips re-launch
+#   - Configurable port via --port=N (default 8188)
+#   - Configurable workspace via --workspace=PATH
+#   - Persistent log file in /tmp/comfyui_setup.<pid>.log for debugging
+#   - SIGINT trap cleans up partial state
+#   - Refuses local install when hardware_check.py verdict is "cloud"
+#   - Forwards extra flags to comfy-cli (e.g. --cuda-version=12.4)
+#
+# Usage:
+#   bash scripts/comfyui_setup.sh
+#       (auto-detects GPU; uses recommendation from hardware_check.py)
+#   bash scripts/comfyui_setup.sh --nvidia
+#   bash scripts/comfyui_setup.sh --m-series --port=8190
+#   bash scripts/comfyui_setup.sh --amd --workspace=/data/comfy
+#
+# Flags:
+#   --nvidia | --amd | --m-series | --cpu     GPU selection (skips hw check)
+#   --port=N                                  HTTP port (default 8188)
+#   --workspace=PATH                          ComfyUI install location
+#   --skip-launch                             Install only, don't start server
+#   --force-cloud-override                    Install locally even if hw says cloud
+#   --                                        Pass remaining args to `comfy install`
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HARDWARE_CHECK="$SCRIPT_DIR/hardware_check.py"
+LOG_FILE="/tmp/comfyui_setup.$$.log"
+PORT=8188
+WORKSPACE=""
+GPU_FLAG=""
+SKIP_LAUNCH=0
+FORCE_CLOUD_OVERRIDE=0
+EXTRA_INSTALL_ARGS=()
+
+cleanup() {
+    local exit_code=$?
+    if [ $exit_code -ne 0 ]; then
+        echo "==> Setup exited with status $exit_code. Log: $LOG_FILE" >&2
+    fi
+    exit $exit_code
+}
+trap cleanup EXIT INT TERM
+
+log() { echo "==> $*" | tee -a "$LOG_FILE" >&2; }
+err() { echo "ERROR: $*" | tee -a "$LOG_FILE" >&2; }
+
+# --- Argument parsing ---
+PASSTHROUGH=0
+for arg in "$@"; do
+    if [ "$PASSTHROUGH" -eq 1 ]; then
+        EXTRA_INSTALL_ARGS+=("$arg")
+        continue
+    fi
+    case "$arg" in
+        --nvidia|--amd|--m-series|--cpu)
+            GPU_FLAG="$arg"
+            ;;
+        --port=*)
+            PORT="${arg#*=}"
+            ;;
+        --workspace=*)
+            WORKSPACE="${arg#*=}"
+            ;;
+        --skip-launch)
+            SKIP_LAUNCH=1
+            ;;
+        --force-cloud-override)
+            FORCE_CLOUD_OVERRIDE=1
+            ;;
+        --)
+            PASSTHROUGH=1
+            ;;
+        --help|-h)
+            # Print the leading comment block, stripping the `# ` prefix.
+            # Stops at the first blank line which separates docs from code.
+            awk '
+                NR == 1 { next }                      # skip shebang
+                /^[^#]/ { exit }                      # stop at first non-comment line
+                /^$/    { exit }                      # ...or first blank line
+                { sub(/^# ?/, ""); print }
+            ' "$0"
+            exit 0
+            ;;
+        *)
+            err "Unknown argument: $arg"
+            exit 64
+            ;;
+    esac
+done
+
+log "Logging to $LOG_FILE"
+
+# --- Step 0: Hardware check (skipped if user gave an explicit GPU flag) ---
+if [ -z "$GPU_FLAG" ]; then
+    if [ ! -f "$HARDWARE_CHECK" ]; then
+        log "hardware_check.py not found — defaulting to --nvidia"
+        GPU_FLAG="--nvidia"
+    else
+        log "Running hardware check…"
+        set +e
+        HW_JSON="$(python3 "$HARDWARE_CHECK" --json 2>>"$LOG_FILE")"
+        HW_EXIT=$?
+        set -e
+
+        if [ -z "$HW_JSON" ]; then
+            err "hardware_check.py produced no output (exit $HW_EXIT). Pass an explicit flag."
+            exit 1
+        fi
+        echo "$HW_JSON" | tee -a "$LOG_FILE" >&2
+
+        VERDICT="$(echo "$HW_JSON" | python3 -c 'import sys,json; print(json.load(sys.stdin).get("verdict",""))')"
+        FLAG="$(echo "$HW_JSON"   | python3 -c 'import sys,json; print(json.load(sys.stdin).get("comfy_cli_flag") or "")')"
+
+        if [ "$VERDICT" = "cloud" ] && [ "$FORCE_CLOUD_OVERRIDE" -ne 1 ]; then
+            log ""
+            log "Hardware check: this machine is not suitable for local ComfyUI."
+            log "Recommended: Comfy Cloud — https://platform.comfy.org"
+            log ""
+            log "To override and force a local install, re-run with --force-cloud-override"
+            log "or pass an explicit GPU flag (--nvidia|--amd|--m-series|--cpu)."
+            exit 2
+        fi
+
+        if [ "$VERDICT" = "marginal" ]; then
+            log "Hardware check: verdict is MARGINAL."
+            log "  SD1.5 should work; SDXL/Flux may be slow or OOM."
+            log "  Consider Comfy Cloud for heavier workflows: https://platform.comfy.org"
+        fi
+
+        if [ -z "$FLAG" ]; then
+            log "hardware_check could not pick a comfy-cli flag. Defaulting to --nvidia."
+            log "(For Intel Arc or unsupported hardware, use the manual install path.)"
+            GPU_FLAG="--nvidia"
+        else
+            GPU_FLAG="$FLAG"
+        fi
+    fi
+fi
+
+log "GPU flag: $GPU_FLAG"
+log "Port: $PORT"
+[ -n "$WORKSPACE" ] && log "Workspace: $WORKSPACE"
+[ "${#EXTRA_INSTALL_ARGS[@]}" -gt 0 ] && log "Extra install args: ${EXTRA_INSTALL_ARGS[*]}"
+
+# --- Step 1: Install comfy-cli (prefer pipx / uvx over global pip) ---
+COMFY_BIN=""
+if command -v comfy >/dev/null 2>&1; then
+    COMFY_BIN="comfy"
+    log "comfy-cli already on PATH: $(comfy -v 2>/dev/null || echo 'unknown version')"
+elif command -v uvx >/dev/null 2>&1; then
+    log "Using uvx (no install needed)"
+    COMFY_BIN="uvx --from comfy-cli comfy"
+elif command -v pipx >/dev/null 2>&1; then
+    log "Installing comfy-cli via pipx…"
+    pipx install comfy-cli >>"$LOG_FILE" 2>&1
+    COMFY_BIN="comfy"
+    # pipx adds shims to ~/.local/bin which may need to be on PATH
+    if ! command -v comfy >/dev/null 2>&1; then
+        if [ -x "$HOME/.local/bin/comfy" ]; then
+            export PATH="$HOME/.local/bin:$PATH"
+            COMFY_BIN="$HOME/.local/bin/comfy"
+        fi
+    fi
+else
+    log "Neither pipx nor uvx found. Falling back to pip install --user…"
+    log "  (Recommend installing pipx: https://pipx.pypa.io)"
+    if ! pip install --user comfy-cli >>"$LOG_FILE" 2>&1; then
+        # macOS: PEP 668 externally-managed-environment may block --user
+        log "pip install --user failed. Retrying with --break-system-packages…"
+        pip install --user --break-system-packages comfy-cli >>"$LOG_FILE" 2>&1 || {
+            err "Could not install comfy-cli. Install pipx or uv first."
+            exit 1
+        }
+    fi
+    # Resolve the actual `comfy` script — pip --user puts it in:
+    #   Linux: ~/.local/bin/comfy
+    #   macOS: ~/Library/Python/<ver>/bin/comfy  OR  ~/.local/bin/comfy
+    COMFY_BIN=""
+    for candidate in "$HOME/.local/bin/comfy" \
+                     "$HOME/Library/Python/3.13/bin/comfy" \
+                     "$HOME/Library/Python/3.12/bin/comfy" \
+                     "$HOME/Library/Python/3.11/bin/comfy" \
+                     "$HOME/Library/Python/3.10/bin/comfy"; do
+        if [ -x "$candidate" ]; then
+            COMFY_BIN="$candidate"
+            export PATH="$(dirname "$candidate"):$PATH"
+            break
+        fi
+    done
+    if [ -z "$COMFY_BIN" ]; then
+        if command -v comfy >/dev/null 2>&1; then
+            COMFY_BIN="comfy"
+        else
+            err "Installed comfy-cli but couldn't find the 'comfy' script."
+            err "Add the right Python user-bin directory to PATH and retry."
+            exit 1
+        fi
+    fi
+fi
+
+# --- Step 2: Disable analytics tracking (avoid interactive prompt) ---
+log "Disabling analytics tracking…"
+$COMFY_BIN --skip-prompt tracking disable >>"$LOG_FILE" 2>&1 || true
+
+# --- Step 3: Install ComfyUI ---
+WORKSPACE_ARG=()
+if [ -n "$WORKSPACE" ]; then
+    WORKSPACE_ARG=(--workspace "$WORKSPACE")
+fi
+
+if $COMFY_BIN "${WORKSPACE_ARG[@]}" which 2>/dev/null | grep -q "ComfyUI"; then
+    EXISTING_WS="$($COMFY_BIN "${WORKSPACE_ARG[@]}" which 2>/dev/null || true)"
+    log "ComfyUI already installed at: $EXISTING_WS"
+else
+    log "Installing ComfyUI ($GPU_FLAG)…"
+    if ! $COMFY_BIN "${WORKSPACE_ARG[@]}" --skip-prompt install "$GPU_FLAG" "${EXTRA_INSTALL_ARGS[@]}" >>"$LOG_FILE" 2>&1; then
+        err "Install failed. Tail of log:"
+        tail -20 "$LOG_FILE" >&2
+        exit 1
+    fi
+fi
+
+if [ "$SKIP_LAUNCH" -eq 1 ]; then
+    log "Setup complete (--skip-launch). Run \`$COMFY_BIN launch --background -- --port $PORT\` when ready."
+    exit 0
+fi
+
+# --- Step 4: Detect already-running server ---
+if curl -fsS "http://127.0.0.1:$PORT/system_stats" >/dev/null 2>&1; then
+    log "Server already running on port $PORT — skipping launch."
+    log "Stop with \`$COMFY_BIN stop\` if you want a fresh start."
+    curl -fsS "http://127.0.0.1:$PORT/system_stats" | python3 -m json.tool 2>/dev/null || true
+    log "Done."
+    exit 0
+fi
+
+# --- Step 5: Launch ---
+log "Launching ComfyUI in background on port $PORT…"
+LAUNCH_EXTRAS=("--" "--port" "$PORT")
+if ! $COMFY_BIN "${WORKSPACE_ARG[@]}" launch --background "${LAUNCH_EXTRAS[@]}" >>"$LOG_FILE" 2>&1; then
+    err "Background launch failed. Tail of log:"
+    tail -20 "$LOG_FILE" >&2
+    err "Try foreground launch to see real-time errors: $COMFY_BIN launch -- --port $PORT"
+    exit 1
+fi
+
+# --- Step 6: Wait for server ---
+log "Waiting for server…"
+MAX_WAIT=60
+ELAPSED=0
+while [ $ELAPSED -lt $MAX_WAIT ]; do
+    if curl -fsS "http://127.0.0.1:$PORT/system_stats" >/dev/null 2>&1; then
+        log "Server is running!"
+        curl -fsS "http://127.0.0.1:$PORT/system_stats" | python3 -m json.tool 2>/dev/null || true
+        break
+    fi
+    sleep 2
+    ELAPSED=$((ELAPSED + 2))
+done
+
+if [ $ELAPSED -ge $MAX_WAIT ]; then
+    err "Server did not start within ${MAX_WAIT}s."
+    err "Inspect log: $LOG_FILE"
+    err "Or run foreground: $COMFY_BIN launch -- --port $PORT"
+    exit 1
+fi
+
+log ""
+log "Setup complete!"
+log "  Server: http://127.0.0.1:$PORT"
+log "  Web UI: http://127.0.0.1:$PORT (open in browser)"
+log "  Stop:   $COMFY_BIN stop"
+log "  Log:    $LOG_FILE (kept until shell closes)"
+log ""
+log "Next steps:"
+log "  - Download a model: $COMFY_BIN model download --url <URL> --relative-path models/checkpoints"
+log "  - Run a workflow:   python3 $SCRIPT_DIR/run_workflow.py --workflow <file.json> --args '{...}'"
+
+# Disable trap on success path
+trap - EXIT

package/extensions/skills/builtin/creative/comfyui/scripts/extract_schema.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+extract_schema.py — Analyze a ComfyUI API-format workflow and extract
+controllable parameters.
+
+Improvements over v1:
+  - Catalogs live in `_common.py`, shared with `check_deps.py`
+  - Coverage expanded for Flux / SD3 / Wan / Hunyuan / LTX / IPAdapter / rgthree
+  - Symmetric duplicate-name resolution: ALL duplicates get a node-id suffix
+    (instead of "first wins, second renamed"), so callers see consistent names
+  - Negative prompt detected by tracing `KSampler.negative` connections back to
+    the source CLIPTextEncode (more reliable than meta-title heuristic)
+  - Embedding references in prompt text are extracted as model dependencies
+  - Detects Primitive nodes that drive other nodes' inputs (and surfaces them
+    as the user-facing parameter)
+  - Reroutes are followed when tracing connections
+
+Usage:
+    python3 extract_schema.py workflow_api.json
+    python3 extract_schema.py workflow_api.json --output schema.json
+
+Stdlib-only. Python 3.10+.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _common import (  # noqa: E402
+    OUTPUT_NODES, PARAM_PATTERNS, PROMPT_FIELDS,
+    is_link, iter_embedding_refs, iter_model_deps, iter_nodes, unwrap_workflow,
+)
+
+
+# 我们追踪其 `positive` / `negative` 连接的采样器节点
+SAMPLER_NODE_FAMILY = {
+    "KSampler", "KSamplerAdvanced",
+    "SamplerCustom", "SamplerCustomAdvanced",
+    "BasicGuider", "CFGGuider", "DualCFGGuider",
+}
+
+
+def infer_type(value: Any) -> str:
+    if isinstance(value, bool):
+        return "bool"
+    if isinstance(value, int):
+        return "int"
+    if isinstance(value, float):
+        return "float"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, list):
+        return "link"
+    if isinstance(value, dict):
+        return "object"
+    return "unknown"
+
+
+def trace_to_node(workflow: dict, link: list, *, max_hops: int = 8) -> str | None:
+    """Follow a [node_id, slot] link, hopping through Reroute / Primitive nodes
+    if needed, to find the *upstream* node id that holds the actual value/input.
+
+    Bounded by both `max_hops` AND a visited-set to prevent infinite loops on
+    pathological graphs.
+    """
+    if not is_link(link):
+        return None
+    nid: str | None = link[0]
+    visited: set[str] = set()
+    for _ in range(max_hops):
+        if nid is None or nid in visited:
+            return nid
+        visited.add(nid)
+        node = workflow.get(nid)
+        if not isinstance(node, dict):
+            return None
+        cls = node.get("class_type", "")
+        # Reroute / Primitive / passthrough 包装器
+        if cls in {"Reroute", "PrimitiveNode", "Note", "easy showAnything"}:
+            inputs = node.get("inputs", {}) or {}
+            # 找到第一个 link 型输入并跟随它
+            next_link = next((v for v in inputs.values() if is_link(v)), None)
+            if next_link is None:
+                return nid
+            nid = next_link[0]
+            continue
+        return nid
+    return nid
+
+
+def find_negative_prompt_node(workflow: dict) -> str | None:
+    """Trace `negative` input of a sampler back to the source text encoder."""
+    for nid, node in iter_nodes(workflow):
+        if node["class_type"] not in SAMPLER_NODE_FAMILY:
+            continue
+        inputs = node.get("inputs", {}) or {}
+        neg = inputs.get("negative")
+        if not is_link(neg):
+            continue
+        src = trace_to_node(workflow, neg)
+        if src and isinstance(workflow.get(src), dict):
+            cls = workflow[src].get("class_type", "")
+            if cls.startswith("CLIPTextEncode") or cls in {"smZ CLIPTextEncode", "BNK_CLIPTextEncodeAdvanced"}:
+                return src
+    return None
+
+
+def find_positive_prompt_node(workflow: dict) -> str | None:
+    for nid, node in iter_nodes(workflow):
+        if node["class_type"] not in SAMPLER_NODE_FAMILY:
+            continue
+        inputs = node.get("inputs", {}) or {}
+        pos = inputs.get("positive")
+        if not is_link(pos):
+            continue
+        src = trace_to_node(workflow, pos)
+        if src and isinstance(workflow.get(src), dict):
+            cls = workflow[src].get("class_type", "")
+            if cls.startswith("CLIPTextEncode") or cls in {"smZ CLIPTextEncode", "BNK_CLIPTextEncodeAdvanced"}:
+                return src
+    return None
+
+
+def extract_schema(workflow: dict) -> dict:
+    """Extract controllable parameters from a workflow.
+
+    Returns:
+        {
+          "parameters": { friendly_name: {node_id, field, type, value, ...} },
+          "output_nodes": [node_id, ...],
+          "model_dependencies": [{node_id, class_type, field, value, folder}],
+          "embedding_dependencies": [{node_id, embedding_name, found_in_field, value_excerpt}],
+          "summary": {...}
+        }
+    """
+    output_nodes: list[str] = []
+
+    # 第一步：通过连接追踪识别正向 / 负向提示词节点
+    pos_node = find_positive_prompt_node(workflow)
+    neg_node = find_negative_prompt_node(workflow)
+
+    # ----- 收集原始参数候选 -----
+    # 每个候选 = (friendly_name, node_id, field, value)
+    # 我们在循环结束后再去重相同的 friendly_names，以确保去重是对称的。
+    raw_params: list[dict] = []
+
+    for node_id, node in iter_nodes(workflow):
+        cls = node["class_type"]
+        inputs = node.get("inputs", {}) or {}
+
+        if cls in OUTPUT_NODES:
+            output_nodes.append(node_id)
+
+        # 将此节点与 PARAM_PATTERNS 进行匹配
+        for p_class, p_field, friendly in PARAM_PATTERNS:
+            if cls != p_class:
+                continue
+            if p_field not in inputs:
+                continue
+            value = inputs[p_field]
+            t = infer_type(value)
+            if t == "link":
+                continue  # 连接无法直接控制
+
+            actual_name = friendly
+
+            # 通过连接追踪来消歧提示词与负向提示词
+            if friendly == "prompt":
+                if node_id == neg_node and pos_node != neg_node:
+                    actual_name = "negative_prompt"
+                elif node_id == pos_node:
+                    actual_name = "prompt"
+                else:
+                    # 回退：如果存在 _meta.title 提示，则使用它们
+                    meta_title = (node.get("_meta") or {}).get("title", "").lower()
+                    if any(t_ in meta_title for t_ in ("negative", "neg", "-prompt", "anti")):
+                        actual_name = "negative_prompt"
+
+            raw_params.append({
+                "name_hint": actual_name,
+                "node_id": node_id,
+                "field": p_field,
+                "type": t,
+                "value": value,
+                "class_type": cls,
+            })
+
+    # ----- 对称的重复名称解析 -----
+    # 按 name_hint 分组。如果某个提示只出现一次，则保留。如果出现多次，则添加后缀
+    # 给所有这些加上它们的 node_id。始终稳定，始终可唯一寻址。
+    by_name: dict[str, list[dict]] = {}
+    for r in raw_params:
+        by_name.setdefault(r["name_hint"], []).append(r)
+
+    parameters: dict[str, dict] = {}
+    for name, entries in by_name.items():
+        if len(entries) == 1:
+            r = entries[0]
+            parameters[name] = {
+                "node_id": r["node_id"], "field": r["field"],
+                "type": r["type"], "value": r["value"],
+                "class_type": r["class_type"],
+            }
+        else:
+            # 按 node_id（字符串自然排序）排序以保持稳定
+            entries.sort(key=lambda x: (str(x["node_id"]).zfill(8), x["field"]))
+            for r in entries:
+                full_name = f"{name}_{r['node_id']}"
+                parameters[full_name] = {
+                    "node_id": r["node_id"], "field": r["field"],
+                    "type": r["type"], "value": r["value"],
+                    "class_type": r["class_type"],
+                    "alias_of": name,
+                }
+
+    # ----- 模型依赖 -----
+    model_deps = list(iter_model_deps(workflow))
+
+    # ----- 嵌入依赖（在提示词文本中） -----
+    embedding_deps: list[dict] = []
+    seen_emb: set[tuple[str, str]] = set()
+    for nid, emb_name in iter_embedding_refs(workflow):
+        key = (nid, emb_name)
+        if key in seen_emb:
+            continue
+        seen_emb.add(key)
+        # 找到包含引用的字段，作为上下文
+        node = workflow.get(nid, {})
+        inputs = node.get("inputs", {}) or {}
+        found_field = None
+        excerpt = None
+        for fname, fval in inputs.items():
+            if isinstance(fval, str) and fname in PROMPT_FIELDS and emb_name in fval:
+                found_field = fname
+                excerpt = fval[:120]
+                break
+        embedding_deps.append({
+            "node_id": nid,
+            "embedding_name": emb_name,
+            "field": found_field,
+            "value_excerpt": excerpt,
+            "folder": "embeddings",
+        })
+
+    # ----- 摘要 -----
+    summary = {
+        "parameter_count": len(parameters),
+        "output_node_count": len(output_nodes),
+        "model_dep_count": len(model_deps),
+        "embedding_dep_count": len(embedding_deps),
+        "has_negative_prompt": "negative_prompt" in parameters,
+        "has_seed": "seed" in parameters or any(p.startswith("seed_") for p in parameters),
+        "is_video_workflow": any(
+            workflow.get(n, {}).get("class_type", "") in {
+                "VHS_VideoCombine", "SaveVideo", "SaveAnimatedWEBP", "SaveAnimatedPNG",
+            } for n in output_nodes
+        ),
+    }
+
+    return {
+        "parameters": parameters,
+        "output_nodes": output_nodes,
+        "model_dependencies": model_deps,
+        "embedding_dependencies": embedding_deps,
+        "summary": summary,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="Extract controllable parameters from a ComfyUI workflow")
+    p.add_argument("workflow", help="Path to workflow API JSON file")
+    p.add_argument("--output", "-o", help="Output file (default: stdout)")
+    p.add_argument("--summary-only", action="store_true",
+                   help="Only print the summary block")
+    args = p.parse_args(argv)
+
+    wf_path = Path(args.workflow).expanduser()
+    if not wf_path.exists():
+        print(f"Error: {wf_path} not found", file=sys.stderr)
+        return 1
+
+    try:
+        with wf_path.open() as f:
+            payload = json.load(f)
+        workflow = unwrap_workflow(payload)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"Error: invalid JSON — {e}", file=sys.stderr)
+        return 1
+
+    schema = extract_schema(workflow)
+
+    if args.summary_only:
+        out = json.dumps(schema["summary"], indent=2)
+    else:
+        out = json.dumps(schema, indent=2, default=str)
+
+    if args.output:
+        Path(args.output).write_text(out)
+        print(f"Schema written to {args.output}", file=sys.stderr)
+    else:
+        print(out)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())