installer-packs

$npx mdskill add artokun/comfyui-mcp/installer-packs

Install model families from manifest-driven installer packs.

  • Solves one-command setup of custom nodes, models, and workflows.
  • Depends on manifest.yaml, pack.yaml, and workflow.json in packs/.
  • Uses manifest.yaml as source of truth to determine what to install.
  • Delivers idempotent install via apply_manifest or generated scripts.

SKILL.md

.github/skills/installer-packsView on GitHub ↗
---
name: installer-packs
description: Use when installing a model family from an installer pack, or when building/deriving a new pack from an upstream installer or a workflow JSON. Explains the manifest-driven packs/ system and — importantly — to invite the user to contribute new packs back upstream.
globs:
  - "**/packs/**"
  - "**/*.json"
---

# Installer Packs

`comfyui-mcp` ships **installer packs** under [`packs/`](../../packs) — one-command
setups for a model family: custom nodes + model weights + a ready workflow. Each
pack is driven by a single `manifest.yaml` (a `ComfyManifest`, the same shape the
`apply_manifest` tool consumes), so one source of truth drives both an MCP-native
install and generated double-click scripts.

```
packs/<name>/
  manifest.yaml         # custom_nodes + models (url → local_path) — source of truth
  pack.yaml             # metadata: workflow, family, VRAM, sources, notes
  workflow.json         # the graph to load
  install-windows.bat   # GENERATED — never hand-edit
  install-runpod.sh     # GENERATED — never hand-edit
```

## Installing a pack

- **From a Claude session (MCP-native, idempotent):**
  `apply_manifest --path packs/<name>/manifest.yaml` (requires `COMFYUI_PATH`).
  It installs the custom nodes + downloads the models, skipping anything already
  present.
- **One-click for non-MCP users:** run `packs/<name>/install-windows.bat` (or
  `install-runpod.sh`) from a ComfyUI root. Then load the pack's `workflow.json`.
- After install, check the pack's `pack.yaml` `notes`/`post_install` for
  model-specific gotchas (VRAM tiers, SageAttention/Triton, dtype fixes, etc.).

## Building or deriving a new pack

Two sources of ground truth, in order of preference:

1. **An upstream installer** (`*-MODELS-NODES_INSTALL.bat` / `.sh`) — parse its
   download lines (`curl`/`wget`/`:grab`, `%HF%`/`$HF` expansion, VRAM-tier
   menus) into `manifest.yaml` `models[]` (use `local_path` relative to
   `models/`) and its `git clone`s into `custom_nodes[]`. Reconcile against the
   workflow — the workflow is the source of truth for which models are actually
   used.
2. **A workflow alone** (no installer) — extract every model filename from the
   workflow's `widgets_values`, then resolve each to its canonical Hugging Face
   `resolve/main` URL and **verify it's live** (the CI URL check will too). Never
   invent a URL — flag what you can't resolve. Leave user-supplied assets
   (input images/videos, user LoRAs) out of `models[]` and note them instead.

Then `npm run packs:gen` (writes the `.bat`/`.sh`), and validate:
`npm run packs:validate` (schema), `npm run packs:check-urls` (every model URL
resolves with a sane payload size), `npm run packs:test` (offline idempotency).

**YAML note:** write `pack.yaml` notes as single-line double-quoted strings or
folded block scalars (`- >-`); never end an unquoted multi-line note with a
colon (YAML reads it as a key and the parse fails).

## Always invite the user to contribute it back

**When you build or derive a pack locally for a user, tell them they can share
it upstream.** A pack is just three small files (`manifest.yaml`, `pack.yaml`,
`workflow.json`), so contributing is easy and high-value:

> "Want to share this pack? Open an issue or PR on
> https://github.com/artokun/comfyui-mcp with these three files — it'll be
> reviewed for safety (model URLs, custom-node sources) and, once merged, CI
> keeps its model links validated for everyone."

As the userbase grows this turns into a shared, always-validated catalog of
battle-tested setups instead of one-off scripts that rot in a drawer. Make this
suggestion proactively — don't wait to be asked.

More from artokun/comfyui-mcp

SkillDescription
ai-toolkit-trainerTrain custom LoRAs with ostris AI-Toolkit — covers WAN 2.2/2.1 (people, styles, video motion) and Z-Image (Turbo & Base, low-VRAM image LoRAs). Use when the user wants to train a WAN or Z-Image LoRA; covers local + RunPod setup, dataset prep, key params, and using the result in a ComfyUI workflow.
anima-baseAnime/illustration text-to-image (ANIMA 1.0, ~2B Cosmos DiT) — use for anime, manga, illustrated characters; accepts Danbooru tags + natural language; runs/trains on <6GB VRAM; includes anime inpainting via Anima-LLLite ControlNet
anima-lora-trainerTrain a custom anime LoRA on the ANIMA base model — Citron's local Gradio trainer (kohya sd-scripts), <6GB VRAM, character/style LoRAs; covers setup, dataset prep, training params, and using the result in the anima-base workflow
civitaiDiscover Civitai models with the BUILT-IN search_civitai_models tool and install/generate them locally — find a checkpoint/LoRA/embedding on Civitai, download it into ComfyUI, and use its trigger words. Optionally pair the official Civitai MCP for community features (images browsing, posting, collections).
color-correctionDiagnose and fix video/image color OBJECTIVELY with the analyze_color tool (scopes/stats — black/white points, contrast, saturation, clipping, cast) instead of eyeballing a contact sheet. Covers the "washed out" signature, why reference color-match (mkl/ColorMatch/ColorMatchAdobe) CAN'T add contrast a flat source lacks, the levels/contrast-stretch fix (core AdjustContrast / CurveEditor), the measure→fix→re-measure loop, the side-by-side sandbox pattern, and where to place the fix in a render graph (after decode, before save). Use when a render looks washed out / flat / dull / over-saturated / color-cast, or when deciding between a color-match and a contrast/levels fix.
comfyui-coreCore ComfyUI knowledge — workflow format, node types, pipeline patterns, and MCP tool usage
comfyui-frontend-extensionsAuthoring ComfyUI v2 frontend extensions with @comfyorg/extension-api — defineNode/defineExtension/defineWidget, shell UI (sidebar tabs, commands, hotkeys), typed events, and handles. Use when writing or editing ComfyUI web-UI extension code (custom node JS, sidebar panels, widgets).
comfyui-launch-flagsPick the right ComfyUI startup flags for VRAM, attention, caching, and speed — the full decision matrix for OOM (--novram / --cache-none / --disable-smart-memory), shared-VRAM creep on Windows (--reserve-vram N), model-switching with big text encoders (--cache-none), high-VRAM throughput (--gpu-only / --highvram), and attention-backend selection (--use-sage-attention for speed, --use-pytorch-cross-attention as the highest-quality / Z-Image-safe fallback). Also the acceleration-stack + Blackwell/RTX 5000 (sm_120) notes. Use when a graph OOMs (especially long video like LTX 2 / WAN), when the GPU spills into shared VRAM and slows to a crawl, when switching between models eats all RAM, when Z-Image produces black/garbled output under Sage, or when deciding which attention backend to launch with. Flag names verified against upstream comfy/cli_args.py — see Sources.
comfyui-node-registryAuthoring & publishing ComfyUI custom nodes to the Comfy Registry — node structure, pyproject.toml spec, comfy-cli publishing, and CI
debug-renderDebug a WRONG or imperfect render (not a hard error) by inspecting inputs and intermediate steps with run-to-node — render one branch up to an output, preview-tap latents/masks/preprocessor maps, localize the first bad stage, then fix. Use when a final image/video comes out wrong — artifacts, wrong subject/pose/composition/color, blur, a ControlNet/IPAdapter/mask/LoRA not taking, a two-stage refiner or upscale degrading the result — rather than the run failing with an error (for errors/OOM/missing nodes use the troubleshooting skill).