Files
llmgw/internal/comfy/nodes.go
T
Ilker ManapandClaude Opus 5.5 88781cfcfe A job says how far along it is; a ComfyUI model brings its custom nodes
G2: the gate keeps a websocket open to its ComfyUI under a client id of its
own, puts that id on every workflow it lets through — ComfyUI tells only
the client that queued a workflow how it goes — and keeps the last word on
each: the node running, its step of how many. It answers at
/progress/{prompt_id}. While a job's request waits, the router reads the
queue (queued, n ahead) and the gate (running, node, step, percent) and
writes it into the job, which a client reads back. Only into a job of the
same key: a tag naming another's job writes nothing.

G3, the rest of the plumbing: comfyui.nodes names custom nodes by https
repository and full commit, with the PyPI packages they need. The gate puts
each in the replica's own custom_nodes at that commit and installs the
packages beside the replica, constrained to the versions ComfyUI's
environment already has, which it never changes. The catalog refuses a
branch for a commit and anything but package specs for requirements. An
OBJ a node saves leaves the gateway as a GLB, colours kept, so every mesh
can carry its licence.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 18:46:44 +02:00

139 lines
5.0 KiB
Go

package comfy
import (
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"path"
"path/filepath"
"regexp"
"strings"
"time"
)
// Custom nodes, put in a replica's own base directory at the commit the
// catalog names, their packages installed beside the replica rather than
// into ComfyUI's environment: one model's node cannot break another
// model's replicas, or the pictures every replica makes.
// Node is a custom node as the catalog gives it.
type Node struct {
Repo string `json:"repo"`
Commit string `json:"commit"`
Requirements []string `json:"requirements,omitempty"`
}
// NodesEnv is where the agent hands the gate a model's custom nodes.
const NodesEnv = "LLMGW_COMFYUI_NODES"
var nodeDir = regexp.MustCompile(`[^A-Za-z0-9._-]`)
// installNodes puts each node in state/custom_nodes at its commit and its
// packages in state/site, and returns the PYTHONPATH ComfyUI is started
// with: empty when no node wants a package. Run as the engines' user, in
// the replica's own directory, before ComfyUI starts.
func installNodes(ctx context.Context, state, python string, nodes []Node, uv string, out func(string)) (string, error) {
if len(nodes) == 0 {
return "", nil
}
ctx, cancel := context.WithTimeout(ctx, 20*time.Minute)
defer cancel()
var reqs []string
for _, n := range nodes {
name := nodeDir.ReplaceAllString(strings.TrimSuffix(path.Base(n.Repo), ".git"), "_")
dir := filepath.Join(state, "custom_nodes", name)
if head, err := gitOutput(ctx, dir, "rev-parse", "HEAD"); err == nil && head == n.Commit {
reqs = append(reqs, n.Requirements...)
continue
}
out(fmt.Sprintf("custom node %s at %s", n.Repo, n.Commit[:12]))
_ = os.RemoveAll(dir)
for _, args := range [][]string{
{"init", "-q", dir},
{"-C", dir, "remote", "add", "origin", n.Repo},
{"-C", dir, "fetch", "-q", "--depth", "1", "origin", n.Commit},
{"-C", dir, "checkout", "-q", "FETCH_HEAD"},
} {
if b, err := exec.CommandContext(ctx, "git", args...).CombinedOutput(); err != nil { //nolint:gosec // the catalog's repository, checked as https
return "", fmt.Errorf("custom node %s at %s: git %s: %v: %s", n.Repo, n.Commit, args[len(args)-2], err, lastLines(b))
}
}
reqs = append(reqs, n.Requirements...)
}
if len(reqs) == 0 {
return "", nil
}
if uv == "" {
return "", fmt.Errorf("custom nodes need %s, and no uv is installed to install them with", strings.Join(reqs, ", "))
}
site := filepath.Join(state, "site")
marker := filepath.Join(site, ".llmgw-requirements")
want := strings.Join(reqs, "\n")
if b, err := os.ReadFile(marker); err == nil && string(b) == want {
return site, nil
}
out("installing " + strings.Join(reqs, " ") + " for the custom nodes")
// What ComfyUI's environment has, as constraints: a package both want is
// installed at the version ComfyUI runs, so the replica's copy and
// ComfyUI's never disagree.
freeze, err := exec.CommandContext(ctx, uv, "pip", "freeze", "--python", python).Output() //nolint:gosec // the agent's own uv
if err != nil {
return "", fmt.Errorf("reading ComfyUI's packages: %w", err)
}
constraints := filepath.Join(state, "constraints.txt")
if err := os.WriteFile(constraints, freeze, 0o644); err != nil { //nolint:gosec // not secret
return "", err
}
_ = os.RemoveAll(site)
args := append([]string{"pip", "install", "--python", python, "--target", site, "-c", constraints, "--quiet"}, reqs...)
cmd := exec.CommandContext(ctx, uv, args...) //nolint:gosec // requirements checked by the catalog as package specs
cmd.Env = append(os.Environ(), "UV_NO_CONFIG=1", "UV_CACHE_DIR="+filepath.Join(state, ".uv-cache"))
if b, err := cmd.CombinedOutput(); err != nil {
return "", fmt.Errorf("installing the custom nodes' packages (%s): %v: %s", strings.Join(reqs, " "), err, lastLines(b))
}
// The replica's copies come first on ComfyUI's path, but of anything
// both have they are the same version, so which is found is the same.
if err := os.WriteFile(marker, []byte(want), 0o644); err != nil { //nolint:gosec // not secret
return "", err
}
return site, nil
}
// parseNodes reads the nodes the agent handed over.
func parseNodes(s string) ([]Node, error) {
if strings.TrimSpace(s) == "" {
return nil, nil
}
var nodes []Node
if err := json.Unmarshal([]byte(s), &nodes); err != nil {
return nil, fmt.Errorf("%s: %w", NodesEnv, err)
}
return nodes, nil
}
// findUV is the uv the agent installed engines with.
func findUV() string {
if m, _ := filepath.Glob("/opt/llmgw/engines/uv/*/*/uv"); len(m) > 0 {
return m[len(m)-1]
}
if p, err := exec.LookPath("uv"); err == nil {
return p
}
return ""
}
func gitOutput(ctx context.Context, dir string, args ...string) (string, error) {
b, err := exec.CommandContext(ctx, "git", append([]string{"-C", dir}, args...)...).Output() //nolint:gosec // fixed arguments
return strings.TrimSpace(string(b)), err
}
func lastLines(b []byte) string {
lines := strings.Split(strings.TrimSpace(string(b)), "\n")
if len(lines) > 4 {
lines = lines[len(lines)-4:]
}
return strings.Join(lines, " | ")
}