dsh-comfyui 0.3.0-beta.0

package/lib/convert.js

@@ -0,0 +1,289 @@
+/** Node types that exist only in the UI and carry no data flow. */
+const UI_ONLY = new Set(['Note', 'StickyNote', 'Reroute', 'Fast Groups Bypasser (rgthree)']);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isWidgetSpec(typeSpec, options) {
+    return (typeof typeSpec === 'string' &&
+        (typeSpec === 'INT' || typeSpec === 'FLOAT' || typeSpec === 'STRING' || typeSpec === 'BOOLEAN')) || Array.isArray(typeSpec) || options?.widget?.name !== undefined;
+}
+/** The object_info input spec for one input name of a node class, if declared. */
+function inputSpec(objectInfo, classType, name) {
+    const def = objectInfo[classType];
+    const input = isObject(def) && isObject(def.input) ? def.input : undefined;
+    if (input === undefined)
+        return undefined;
+    for (const group of ['required', 'optional']) {
+        const fields = isObject(input[group]) ? input[group] : {};
+        if (name in fields)
+            return fields[name];
+    }
+    return undefined;
+}
+/**
+ * Derive the ordered widget-input names for one node. The graph's own input
+ * array is the source of truth — widgets_values is stored in UI widget order,
+ * which includes dynamic sub-widgets (e.g. TextGenerate's sampling_mode.*) and
+ * still holds values for linked widget inputs. object_info only supplies the
+ * control_after_generate combo that follows an INT widget with that option.
+ */
+function widgetNamesFor(classType, objectInfo, node) {
+    const names = [];
+    const addUnique = (name) => {
+        if (!names.includes(name))
+            names.push(name);
+    };
+    for (const entry of node.inputs ?? []) {
+        const name = entry.widget?.name;
+        if (typeof name !== 'string' || name === '')
+            continue;
+        addUnique(name);
+        const spec = inputSpec(objectInfo, classType, entry.name);
+        const typeSpec = Array.isArray(spec) ? spec[0] : undefined;
+        const options = Array.isArray(spec) && isObject(spec[1]) ? spec[1] : undefined;
+        if (typeSpec === 'INT' && options?.control_after_generate === true) {
+            addUnique('control_after_generate');
+        }
+    }
+    // DynamicCombo V3 widgets serialize in UI order: the master combo's value
+    // comes BEFORE its sub-widgets, while the graph's inputs array lists the
+    // sub-widgets first. Reorder the master combo ahead of its `prefix.*`
+    // sub-widgets so the zip below aligns with widgets_values.
+    const dynamicCombos = (node.inputs ?? [])
+        .map((entry) => entry.widget?.name)
+        .filter((name) => typeof name === 'string' && name !== '')
+        .filter((name) => {
+        const spec = inputSpec(objectInfo, classType, name);
+        return Array.isArray(spec) && spec[0] === 'COMFY_DYNAMICCOMBO_V3';
+    });
+    if (dynamicCombos.length > 0) {
+        const reordered = [];
+        for (const name of names) {
+            const master = dynamicCombos.find((prefix) => name.startsWith(`${prefix}.`));
+            if (master !== undefined) {
+                if (!reordered.includes(master))
+                    reordered.push(master);
+                reordered.push(name);
+                continue;
+            }
+            if (!dynamicCombos.includes(name) || !names.some((other) => other.startsWith(`${name}.`))) {
+                reordered.push(name);
+            }
+        }
+        names.splice(0, names.length, ...reordered);
+    }
+    // Fallback: object_info-declared widget inputs the graph did not list.
+    const def = objectInfo[classType];
+    const input = isObject(def) && isObject(def.input) ? def.input : undefined;
+    if (input !== undefined) {
+        const collect = (group) => {
+            const fields = isObject(input[group]) ? input[group] : {};
+            for (const [key, spec] of Object.entries(fields)) {
+                if (spec === null || spec === undefined)
+                    continue;
+                const [typeSpec, options] = Array.isArray(spec)
+                    ? [spec[0], isObject(spec[1]) ? spec[1] : undefined]
+                    : [undefined, undefined];
+                if (!isWidgetSpec(typeSpec, options))
+                    continue;
+                addUnique(options?.widget?.name ?? key);
+            }
+        };
+        collect('required');
+        collect('optional');
+    }
+    return names;
+}
+/** Resolve a link to its effective origin, following Reroute and bypassed nodes. */
+function resolveOutput(linkId, links, nodesById, objectInfo, warnings) {
+    const link = links.get(linkId);
+    if (link === undefined)
+        return 'missing';
+    return resolveOrigin(link[1], link[2], links, nodesById, objectInfo, warnings);
+}
+function resolveOrigin(nodeId, slot, links, nodesById, objectInfo, warnings) {
+    const node = nodesById.get(nodeId);
+    if (node === undefined)
+        return 'missing';
+    // Reroute: the output mirrors the node's input.
+    if (node.type === 'Reroute') {
+        const inputLink = (node.inputs ?? []).find((entry) => entry.link !== null)?.link;
+        if (inputLink === undefined || inputLink === null)
+            return 'missing';
+        return resolveOutput(inputLink, links, nodesById, objectInfo, warnings);
+    }
+    // Bypassed nodes act as pass-throughs: the output follows the first wired input.
+    if (node.mode === 4) {
+        const inputLink = (node.inputs ?? []).find((entry) => entry.link !== null)?.link;
+        if (inputLink === undefined || inputLink === null)
+            return 'missing';
+        return resolveOutput(inputLink, links, nodesById, objectInfo, warnings);
+    }
+    // Unregistered node types: a UI-only value source inlines its first widget;
+    // anything else wired into the chain is a hard conversion error.
+    if (objectInfo[node.type] === undefined) {
+        const value = Array.isArray(node.widgets_values) ? node.widgets_values[0] : undefined;
+        return value !== undefined ? value : 'missing';
+    }
+    // Node id references must be strings: the server keys prompts by string id
+    // and does a direct dict lookup (execution.py validate_inputs). Slots beyond
+    // the server-side output count are graph artifacts (e.g. SaveImage saving an
+    // extra UI output) — drop the reference and surface a warning.
+    const outputCount = Array.isArray(objectInfo[node.type]?.output)
+        ? objectInfo[node.type].output.length
+        : undefined;
+    if (outputCount !== undefined && slot >= outputCount) {
+        warnings.push(`节点 ${node.type} 的第 ${slot} 号输出在服务端不存在，已断开相关连线`);
+        return 'missing';
+    }
+    return [String(nodeId), slot];
+}
+/**
+ * Convert a UI-graph workflow (or one extracted component of it) to API
+ * format using the live node definitions.
+ * @param graph - parsed ComfyUI UI graph (v0.4 format).
+ * @param objectInfo - the server's `/object_info` response.
+ * @param options - `includeNodeIds` restricts conversion to one connected
+ *   component (extraction); link resolution still uses the full graph, which
+ *   is safe because components never share links.
+ */
+export function convertGraphToApi(graph, objectInfo, options) {
+    if (!isObject(graph))
+        return { ok: false, error: '不是 ComfyUI 图格式（缺少 nodes/links）' };
+    const rawNodes = graph.nodes;
+    const rawLinks = graph.links;
+    if (!Array.isArray(rawNodes))
+        return { ok: false, error: '缺少 nodes 数组' };
+    if (!Array.isArray(rawLinks))
+        return { ok: false, error: '缺少 links 数组' };
+    const nodes = rawNodes.filter(isObject).map((raw) => {
+        const id = typeof raw.id === 'number' ? raw.id : Number(raw.id);
+        const inputs = Array.isArray(raw.inputs) ? raw.inputs.filter(isObject).map((entry) => ({
+            name: typeof entry.name === 'string' ? entry.name : '',
+            link: typeof entry.link === 'number' ? entry.link : null,
+            widget: isObject(entry.widget) ? entry.widget : undefined,
+        })) : [];
+        const outputs = Array.isArray(raw.outputs) ? raw.outputs.filter(isObject).map((entry) => ({
+            links: Array.isArray(entry.links) ? entry.links.filter((link) => typeof link === 'number') : [],
+        })) : [];
+        return {
+            id,
+            type: typeof raw.type === 'string' ? raw.type : '',
+            mode: typeof raw.mode === 'number' ? raw.mode : 0,
+            inputs,
+            outputs,
+            widgets_values: Array.isArray(raw.widgets_values) || isObject(raw.widgets_values)
+                ? raw.widgets_values
+                : undefined,
+        };
+    });
+    const links = new Map();
+    for (const raw of rawLinks) {
+        if (!Array.isArray(raw) || raw.length < 6)
+            continue;
+        const link = raw;
+        if (typeof link[0] === 'number')
+            links.set(link[0], link);
+    }
+    const nodesById = new Map(nodes.map((node) => [node.id, node]));
+    const included = options?.includeNodeIds;
+    const candidates = included !== undefined ? nodes.filter((node) => included.has(node.id)) : nodes;
+    const hasUsedOutput = (node) => (node.outputs ?? []).some((output) => output.links.some((linkId) => {
+        if (linkId === null)
+            return false;
+        const link = links.get(linkId);
+        return link !== undefined && nodesById.get(link[3]) !== undefined;
+    }));
+    const workflow = {};
+    const warnings = [];
+    for (const node of candidates) {
+        if (node.type === '' || UI_ONLY.has(node.type))
+            continue;
+        if (node.mode === 4)
+            continue;
+        if (node.type.startsWith('workflow')) {
+            return { ok: false, error: `包含子图节点 "${node.type}"，暂不支持转换` };
+        }
+        if (objectInfo[node.type] === undefined) {
+            if (!hasUsedOutput(node) || node.type.startsWith('Primitive'))
+                continue;
+            return { ok: false, error: `包含未注册的 UI-only 节点 "${node.type}"，无法转换` };
+        }
+        const inputs = {};
+        for (const entry of node.inputs ?? []) {
+            if (entry.link === undefined || entry.link === null)
+                continue;
+            const resolved = resolveOutput(entry.link, links, nodesById, objectInfo, warnings);
+            if (resolved !== 'missing')
+                inputs[entry.name] = resolved;
+        }
+        const values = node.widgets_values;
+        if (Array.isArray(values)) {
+            let valueIndex = 0;
+            for (const name of widgetNamesFor(node.type, objectInfo, node)) {
+                if (valueIndex >= values.length)
+                    break;
+                if (!(name in inputs))
+                    inputs[name] = values[valueIndex];
+                valueIndex++;
+            }
+        }
+        else if (isObject(values)) {
+            // Some nodes (e.g. VHS_VideoCombine) serialize widgets as a keyed object
+            // including internal UI state; copy the plain input values by name.
+            for (const [name, value] of Object.entries(values)) {
+                if (name === 'videopreview')
+                    continue;
+                if (isObject(value) && value.hidden === true)
+                    continue;
+                if (!(name in inputs))
+                    inputs[name] = value;
+            }
+        }
+        // Collapse DynamicCombo V3 flat keys back into the API object shape:
+        // { key, inputs: { subWidget: value } } — the master combo's value is the
+        // selected option key, and its `master.sub` siblings become the sub-inputs.
+        for (const [name, value] of Object.entries(inputs)) {
+            const spec = inputSpec(objectInfo, node.type, name);
+            if (!Array.isArray(spec) || spec[0] !== 'COMFY_DYNAMICCOMBO_V3')
+                continue;
+            const sub = {};
+            for (const [other, otherValue] of Object.entries(inputs)) {
+                if (other.startsWith(`${name}.`))
+                    sub[other.slice(name.length + 1)] = otherValue;
+            }
+            inputs[name] = { key: value, inputs: sub };
+            for (const subName of Object.keys(sub))
+                delete inputs[`${name}.${subName}`];
+        }
+        workflow[String(node.id)] = { class_type: node.type, inputs };
+    }
+    if (Object.keys(workflow).length === 0) {
+        return { ok: false, error: '转换结果为空（图中没有可执行的节点）' };
+    }
+    // Fail loudly on nodes whose required inputs are missing — the source graph
+    // itself is broken (inputs never wired), and the server would only echo a
+    // confusing per-node error at run time. Growable/lazy v3 inputs (template
+    // types like COMFY_AUTOGROW_V3) are skipped: their generated sub-inputs
+    // (values.a, sampling_mode.temperature, ...) satisfy them.
+    for (const [id, node] of Object.entries(workflow)) {
+        const def = objectInfo[node.class_type];
+        const required = isObject(def) && isObject(def.input) && isObject(def.input.required)
+            ? Object.keys(def.input.required)
+            : [];
+        const missing = required.filter((name) => {
+            if (name in node.inputs)
+                return false;
+            const spec = inputSpec(objectInfo, node.class_type, name);
+            const options = Array.isArray(spec) && isObject(spec[1]) ? spec[1] : undefined;
+            return options?.lazy !== true && options?.template === undefined;
+        });
+        if (missing.length > 0) {
+            return {
+                ok: false,
+                error: `节点 ${node.class_type}（id ${id}）缺少必需输入：${missing.join('、')}——源工作流中这些输入没有连线`,
+            };
+        }
+    }
+    return { ok: true, workflow, warnings };
+}

package/lib/host-hint.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Host hint: remember the origin browsers use to reach this web server, so
+ * generated media URLs (tool results) point at an address the requesting
+ * browser can actually load. The hint is derived from the Host header and the
+ * Referer of every /comfyui/* request the browser makes: a panel load records
+ * the Host header before any generation happens, and a media <img> fetch
+ * carries the page's own URL in Referer — which recovers the external origin
+ * even when an earlier generated URL already fell back to loopback.
+ *
+ * Loopback origins (127.0.0.1/localhost) never displace an already-seen
+ * external origin: server-side tool calls and local debug requests must not
+ * overwrite the address remote browsers use.
+ */
+import type { IncomingMessage } from 'node:http';
+/**
+ * The server's own first reachable LAN origin (e.g. http://192.168.1.5:3080),
+ * used as the media-URL fallback before loopback. Picks the first non-internal
+ * IPv4 that is not loopback or link-local. Returns undefined when no such
+ * address exists (no network interface), in which case callers keep loopback.
+ */
+export declare function detectLanOrigin(port: number): string | undefined;
+export interface HostHint {
+    /** Record the origin of one request (Host header + Referer + forwarded proto). */
+    record(request: IncomingMessage): void;
+    /** The best-known origin: the last external one, else the last loopback one, else undefined. */
+    origin(): string | undefined;
+}
+/** Create a host hint accumulator. */
+export declare function createHostHint(): HostHint;

package/lib/host-hint.js

@@ -0,0 +1,73 @@
+import { networkInterfaces } from 'node:os';
+/**
+ * The server's own first reachable LAN origin (e.g. http://192.168.1.5:3080),
+ * used as the media-URL fallback before loopback. Picks the first non-internal
+ * IPv4 that is not loopback or link-local. Returns undefined when no such
+ * address exists (no network interface), in which case callers keep loopback.
+ */
+export function detectLanOrigin(port) {
+    for (const list of Object.values(networkInterfaces())) {
+        if (list === undefined)
+            continue;
+        for (const net of list) {
+            if (net.family !== 'IPv4' || net.internal)
+                continue;
+            const ip = net.address;
+            if (ip === '127.0.0.1' || ip.startsWith('169.254.'))
+                continue;
+            return `http://${ip}:${port}`;
+        }
+    }
+    return undefined;
+}
+/** Whether a Host header value names the local machine. */
+function isLoopback(host) {
+    const bare = host.replace(/^\[/, '').replace(/\].*$/, '').replace(/:\d+$/, '').toLowerCase();
+    return bare === '127.0.0.1' || bare === 'localhost' || bare === '::1';
+}
+/** Extract the http(s) origin of a Referer header value, or undefined. */
+function parseRefererOrigin(referer) {
+    const raw = Array.isArray(referer) ? referer[0] : referer;
+    if (typeof raw !== 'string' || raw === '')
+        return undefined;
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return undefined;
+        return `${url.protocol}//${url.host}`.replace(/\/+$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether an origin string names the local machine. */
+function isLoopbackOrigin(origin) {
+    const match = origin.match(/^https?:\/\/([^/:]+)/);
+    return match === null || isLoopback(match[1] ?? '');
+}
+/** Create a host hint accumulator. */
+export function createHostHint() {
+    let loopback;
+    let external;
+    return {
+        record(request) {
+            const host = request.headers.host;
+            const forwarded = request.headers['x-forwarded-proto'];
+            const proto = typeof forwarded === 'string' ? (forwarded.split(',')[0]?.trim() || 'http') : 'http';
+            const hostOrigin = typeof host === 'string' && host !== ''
+                ? `${proto}://${host}`.replace(/\/+$/, '')
+                : undefined;
+            const refererOrigin = parseRefererOrigin(request.headers.referer);
+            const externalSignal = (hostOrigin !== undefined && !isLoopbackOrigin(hostOrigin))
+                ? hostOrigin
+                : (refererOrigin !== undefined && !isLoopbackOrigin(refererOrigin) ? refererOrigin : undefined);
+            if (externalSignal !== undefined)
+                external = externalSignal;
+            if (hostOrigin !== undefined && isLoopbackOrigin(hostOrigin))
+                loopback = hostOrigin;
+        },
+        origin() {
+            return external ?? loopback;
+        },
+    };
+}

package/lib/http.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Small HTTP helpers for the dsh-comfyui routes, mirroring the shapes the
+ * dshmarket bundle uses for its own same-origin API.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Send a JSON response with no-store caching. */
+export declare function sendJson(response: ServerResponse, status: number, body: unknown): void;
+/** Read and parse a JSON request body; undefined when the body is empty. */
+export declare function readJsonBody(request: IncomingMessage): Promise<unknown>;
+/** Read a raw (possibly binary) request body, e.g. for multipart forwarding. */
+export declare function readRawBody(request: IncomingMessage): Promise<Buffer>;
+/** Whether a request originates from the page that served it (Origin vs Host). */
+export declare function sameOrigin(request: IncomingMessage): boolean;
+/** Human-readable error message from an unknown thrown value. */
+export declare function errorMessage(error: unknown): string;

package/lib/http.js

@@ -0,0 +1,41 @@
+/** Send a JSON response with no-store caching. */
+export function sendJson(response, status, body) {
+    const payload = JSON.stringify(body);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+    });
+    response.end(payload);
+}
+/** Read and parse a JSON request body; undefined when the body is empty. */
+export async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(chunk);
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text === '')
+        return undefined;
+    return JSON.parse(text);
+}
+/** Read a raw (possibly binary) request body, e.g. for multipart forwarding. */
+export async function readRawBody(request) {
+    const chunks = [];
+    for await (const chunk of request)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+/** Whether a request originates from the page that served it (Origin vs Host). */
+export function sameOrigin(request) {
+    const origin = request.headers.origin;
+    const host = request.headers.host;
+    if (origin === undefined)
+        return true;
+    if (host === undefined)
+        return false;
+    return origin === `http://${host}` || origin === `https://${host}`;
+}
+/** Human-readable error message from an unknown thrown value. */
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * dsh-comfyui host entry: wires the tools, HTTP routes, and media proxy, and
+ * registers the `comfyui:` settings section so the browser settings page can
+ * persist config without editing cordis.yml. Everything unmounts with the
+ * plugin fiber.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { Config, type Config as ConfigType } from './config.js';
+export declare const name = "dsh-comfyui";
+export { Config };
+/**
+ * Required services. `tools` is the model-facing registry the plugin writes
+ * into, so the fiber must wait for it: reading `ctx.tools` without declaring
+ * it here is what cordis rejects with `cannot get property "tools" without
+ * inject`. `webServer`, `settings`, and `credentials` stay OUT of this list —
+ * they are optional, and the plugin degrades gracefully without them (see
+ * apply).
+ */
+export declare const inject: string[];
+/**
+ * The plugin body. The loader validates the entry config against `Config`
+ * (defaults applied), then hands the resolved object to apply.
+ */
+export declare function apply(ctx: Context, entryConfig: Partial<ConfigType>): Promise<void>;