A ComfyUI model may make meshes: from a picture, with its licence inside

G3, the part that needs no model: a ComfyUI model's comfyui.output (or
external.output) says pictures or meshes. A request for a 3D model — a
job at /v1/3d/generations — carries the picture as base64; at the replica
it is uploaded to ComfyUI's input directory (the gate lets /upload/image
through), the workflow is filled in with its name, the seed and the
resolution, and the mesh the workflow saves comes back with its type,
which is the file the job keeps. comfy.Client reads every list of files an
output names, not "images" only, and types a file by its extension where
ComfyUI sends octet-stream.

A model's license (name, url, notice) is said in /v1/models and in the
job, and written into a GLB's asset.extras, since the file travels without
the API; a mesh it cannot be written into is refused. per_mesh in
auth.pricing, usage.meshes in the rows, the sums and the export
(migration 0045). A picture asked of a mesh model, or a mesh of a picture
model, is refused saying which it makes.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-10 18:30:52 +02:00
1 parent ec233d3586
commit c87e413360
27 files changed
+899 -57

No files matched your search

+130 -19
View File
@@ -21,8 +21,10 @@ import (
"fmt"
"io"
"math/big"
"mime/multipart"
"net/http"
"net/url"
"path"
"slices"
"strconv"
"strings"
@@ -98,6 +100,11 @@ type Params struct {
Seed int64
Steps int
Guidance float64
// Image is the input picture, by the name Upload gave it in ComfyUI's
// input directory: {{image}}.
Image string
// Extra are a workflow's own placeholders, by name: {{resolution}}.
Extra map[string]any
}
func (p Params) value(name string) (any, bool) {
@@ -120,8 +127,11 @@ func (p Params) value(name string) (any, bool) {
return p.Steps, p.Steps > 0
case "guidance":
return p.Guidance, p.Guidance > 0
case "image":
return p.Image, p.Image != ""
}
return nil, false
v, ok := p.Extra[name]
return v, ok
}
// Fill is the workflow for one request.
@@ -207,10 +217,12 @@ func RandomSeed() int64 {
return n.Int64()
}
// Image is one picture made.
// Image is one file a workflow made: a picture, a mesh.
type Image struct {
Data []byte
ContentType string
// Name is the file's own, as ComfyUI saved it.
Name string
}
// Error is a failure, said as what it means for the request.
@@ -299,13 +311,16 @@ type historyEntry struct {
Completed bool `json:"completed"`
Messages [][]json.RawMessage `json:"messages"`
} `json:"status"`
Outputs map[string]struct {
Images []struct {
Filename string `json:"filename"`
Subfolder string `json:"subfolder"`
Type string `json:"type"`
} `json:"images"`
} `json:"outputs"`
// Outputs are each node's, by kind: "images" for a picture, "3d" for
// the mesh a 3D node saves, and whatever else a custom node names.
Outputs map[string]map[string]json.RawMessage `json:"outputs"`
}
// fileRef is a file an output names, to be read from /view.
type fileRef struct {
Filename string `json:"filename"`
Subfolder string `json:"subfolder"`
Type string `json:"type"`
}
// failure is what ComfyUI said went wrong, from its execution_error.
@@ -341,17 +356,38 @@ func (c *Client) fetch(ctx context.Context, base, apiKey string, h historyEntry)
})
var out []Image
for _, n := range nodes {
for _, im := range h.Outputs[n].Images {
q := url.Values{"filename": {im.Filename}, "subfolder": {im.Subfolder}, "type": {im.Type}}
img, err := c.get(ctx, base+"/view?"+q.Encode(), apiKey)
if err != nil {
return nil, err
kinds := make([]string, 0, len(h.Outputs[n]))
for k := range h.Outputs[n] {
kinds = append(kinds, k)
}
slices.Sort(kinds)
for _, k := range kinds {
// Any list of files, whatever the node calls it; text and
// numbers a node reports beside them are not files.
var refs []fileRef
if json.Unmarshal(h.Outputs[n][k], &refs) != nil {
continue
}
for _, f := range refs {
if f.Filename == "" {
continue
}
q := url.Values{"filename": {f.Filename}, "subfolder": {f.Subfolder}, "type": {f.Type}}
img, err := c.get(ctx, base+"/view?"+q.Encode(), apiKey)
if err != nil {
return nil, err
}
img.Name = f.Filename
if t := typeByName(f.Filename); t != "" && (img.ContentType == "" ||
strings.HasPrefix(img.ContentType, "application/octet-stream") || strings.HasPrefix(img.ContentType, "text/plain")) {
img.ContentType = t
}
out = append(out, img)
}
out = append(out, img)
}
}
if len(out) == 0 {
return nil, &Error{Msg: "the workflow finished without a picture: it has no SaveImage or PreviewImage node"}
return nil, &Error{Msg: "the workflow finished without a file: it has no node that saves one"}
}
return out, nil
}
@@ -434,12 +470,12 @@ func (c *Client) get(ctx context.Context, u, apiKey string) (Image, error) {
return Image{}, err
}
defer resp.Body.Close()
b, err := io.ReadAll(io.LimitReader(resp.Body, 64<<20))
b, err := io.ReadAll(io.LimitReader(resp.Body, maxFile))
if err != nil {
return Image{}, &Error{Msg: "reading a picture from ComfyUI: " + err.Error(), Retryable: true}
return Image{}, &Error{Msg: "reading a file from ComfyUI: " + err.Error(), Retryable: true}
}
if resp.StatusCode != http.StatusOK {
return Image{}, &Error{Msg: fmt.Sprintf("ComfyUI answered %d for a picture it made", resp.StatusCode)}
return Image{}, &Error{Msg: fmt.Sprintf("ComfyUI answered %d for a file it made", resp.StatusCode)}
}
ct := resp.Header.Get("Content-Type")
if ct == "" || ct == "application/octet-stream" {
@@ -527,3 +563,78 @@ func snippet(b []byte) string {
}
return s
}
// maxFile bounds one file read from ComfyUI: a mesh with its textures runs
// to tens of megabytes, a picture to a few.
const maxFile = 256 << 20
// typeByName is a file's type by its extension, for those a server sends
// as octet-stream: the meshes a 3D node saves.
func typeByName(name string) string {
switch strings.ToLower(path.Ext(name)) {
case ".glb":
return "model/gltf-binary"
case ".gltf":
return "model/gltf+json"
case ".obj":
return "model/obj"
case ".stl":
return "model/stl"
case ".ply":
return "application/ply"
case ".png":
return "image/png"
}
return ""
}
// Upload puts a picture in ComfyUI's input directory, where a LoadImage node
// reads it, and returns the name it was given there.
func (c *Client) Upload(ctx context.Context, base, apiKey, name string, data []byte) (string, error) {
base = strings.TrimRight(base, "/")
var body bytes.Buffer
mw := multipart.NewWriter(&body)
fw, err := mw.CreateFormFile("image", name)
if err != nil {
return "", err
}
if _, err := fw.Write(data); err != nil {
return "", err
}
_ = mw.WriteField("type", "input")
_ = mw.WriteField("overwrite", "true")
if err := mw.Close(); err != nil {
return "", err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, base+"/upload/image", &body)
if err != nil {
return "", err
}
req.Header.Set("Content-Type", mw.FormDataContentType())
if apiKey != "" {
req.Header.Set("Authorization", "Bearer "+apiKey)
}
resp, err := c.client().Do(req)
if err != nil {
if ctx.Err() != nil {
return "", ctx.Err()
}
return "", &Error{Msg: "ComfyUI could not be reached: " + err.Error(), Retryable: true}
}
defer resp.Body.Close()
b, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
if resp.StatusCode >= 500 {
return "", &Error{Msg: fmt.Sprintf("ComfyUI answered %d to the picture: %s", resp.StatusCode, snippet(b)), Retryable: true}
}
var out struct {
Name string `json:"name"`
Subfolder string `json:"subfolder"`
}
if resp.StatusCode != http.StatusOK || json.Unmarshal(b, &out) != nil || out.Name == "" {
return "", &Error{Msg: fmt.Sprintf("ComfyUI did not take the picture (%d): %s", resp.StatusCode, snippet(b))}
}
if out.Subfolder != "" {
return out.Subfolder + "/" + out.Name, nil
}
return out.Name, nil
}
+4 -1
View File
@@ -63,7 +63,10 @@ type GateConfig struct {
// The requests the router makes of ComfyUI: queueing, waiting, fetching and
// cancelling. Nothing that uploads, installs or changes ComfyUI.
var gatePaths = []string{"/prompt", "/history/", "/view", "/queue", "/interrupt", "/system_stats", "/object_info"}
var gatePaths = []string{"/prompt", "/history/", "/view", "/queue", "/interrupt", "/system_stats", "/object_info",
// The input picture of a 3D model: into ComfyUI's input directory,
// which is the replica's own.
"/upload/image"}
// modelFolders are the kinds of file ComfyUI's loaders look for. Each is
// shown the same directory: a workflow names its files, so a file being
+2 -2
View File
@@ -45,12 +45,12 @@ func TestTheGateWantsTheKeyAndLetsThroughOnlyTheRoutersRequests(t *testing.T) {
if code, _ := do("POST", "/prompt", "wrong"); code != http.StatusUnauthorized {
t.Errorf("wrong key: %d", code)
}
for _, p := range []string{"/upload/image", "/api/manager/queue/install", "/userdata/x", "/internal/logs"} {
for _, p := range []string{"/upload/mask", "/api/manager/queue/install", "/userdata/x", "/internal/logs"} {
if code, _ := do("POST", p, "k"); code != http.StatusNotFound {
t.Errorf("%s: %d, want it refused", p, code)
}
}
for _, p := range []string{"/prompt", "/history/p1", "/view?filename=a.png", "/queue", "/interrupt"} {
for _, p := range []string{"/prompt", "/history/p1", "/view?filename=a.png", "/queue", "/interrupt", "/upload/image"} {
if code, _ := do("POST", p, "k"); code != http.StatusOK {
t.Errorf("%s: %d", p, code)
}