dsh-multimodal-node 0.0.0-stage → 0.3.1

package/lib/workflows.js

@@ -0,0 +1,472 @@
+/**
+ * Workflows on the far side of the gateway.
+ *
+ * ComfyUI keeps saved workflows as UI graphs (`/api/userdata?dir=workflows`),
+ * but `/prompt` only accepts the API form, so a remote console that offers
+ * "pick a workflow and press generate" has to convert. The conversion here is
+ * deliberately mechanical and conservative:
+ *
+ *   - a link that feeds an input wins over that input's widget value;
+ *   - widget values are assigned to inputs in `input.required`/`optional` order,
+ *     honouring `control_after_generate` (seed rows carry a follow-up value that
+ *     is not an input at all);
+ *   - a widget value that is an object with `__value__` (a converted widget) is
+ *     unwrapped;
+ *   - nodes whose class is unknown to the instance are reported, not guessed.
+ *
+ * Anything the instance's own /object_info cannot describe is surfaced as a
+ * warning so the console can tell the user which node will not run, instead of
+ * shipping a prompt that fails upstream with a cryptic error.
+ */
+
+/** Input names a class accepts, in widget order (ComfyUI's own rule). */
+function inputNames(spec) {
+    const names = [];
+    const sections = [spec?.input?.required ?? {}, spec?.input?.optional ?? {}];
+    for (const section of sections) {
+        for (const [name, declaration] of Object.entries(section)) {
+            const type = Array.isArray(declaration) ? declaration[0] : declaration?.type;
+            // A required link declaration is a type name string; a widget is an
+            // array whose first element is either a list of options or a type.
+            names.push({ name, type, declaration });
+        }
+    }
+    return names;
+}
+
+/** ComfyUI marks a widget "socket only" by omitting it from the widget order. */
+function widgetInputs(spec) {
+    const rows = [];
+    for (const entry of inputNames(spec)) {
+        const declaration = entry.declaration;
+        if (declaration === undefined) continue;
+        const isWidget =
+            Array.isArray(declaration) &&
+            declaration.length > 0 &&
+            (Array.isArray(declaration[0]) || ['INT', 'FLOAT', 'STRING', 'BOOLEAN'].includes(declaration[0]));
+        if (!isWidget) continue;
+        rows.push(entry);
+    }
+    return rows;
+}
+
+const UPLOAD_TYPES = new Set(['IMAGE', 'MASK', 'VIDEO', 'AUDIO']);
+const TEXT_TYPES = new Set(['STRING']);
+
+/**
+ * Convert one UI graph to API format.
+ * @returns {{prompt: object|null, warnings: string[], error?: string}}
+ */
+export function graphToApi(graph, objectInfo) {
+    const warnings = [];
+    if (graph === null || typeof graph !== 'object') return { prompt: null, warnings, error: '工作流不是 JSON 对象' };
+    if (typeof graph.nodes !== 'object' || !Array.isArray(graph.nodes)) {
+        // Already API format: a map of node id to {class_type, inputs}.
+        const entries = Object.entries(graph);
+        const looksApi = entries.length > 0 && entries.every(([, node]) => node && typeof node === 'object' && typeof node.class_type === 'string');
+        if (looksApi) return { prompt: graph, warnings };
+        return { prompt: null, warnings, error: '无法识别的格式：既没有 nodes 数组，也不是 API 格式（class_type/inputs）' };
+    }
+
+    const nodes = graph.nodes.filter((node) => node !== null && typeof node === 'object');
+    const byId = new Map(nodes.map((node) => [String(node.id), node]));
+    // links: [linkId, originNode, originSlot, targetNode, targetSlot, type]
+    const linkById = new Map();
+    for (const link of Array.isArray(graph.links) ? graph.links : []) {
+        if (Array.isArray(link) && link.length >= 5) {
+            linkById.set(String(link[0]), { origin: String(link[1]), originSlot: Number(link[2]), type: link[5] });
+        }
+    }
+
+    const prompt = {};
+    for (const node of nodes) {
+        const classType = String(node.type ?? node.class_type ?? '');
+        if (classType === '' || classType === 'Reroute' || classType === 'Note' || classType === 'MarkdownNote') continue;
+        if (node.mode === 2 || node.mode === 4) continue; // muted / bypassed
+        const spec = objectInfo[classType];
+        if (spec === undefined) {
+            warnings.push(`实例里没有节点 ${classType}（#${node.id}），该节点会被跳过`);
+            continue;
+        }
+        const inputs = {};
+        // 1. Link-fed inputs win: the graph's wires are the real dataflow.
+        for (const input of Array.isArray(node.inputs) ? node.inputs : []) {
+            if (input === null || typeof input !== 'object') continue;
+            const link = input.link === undefined || input.link === null ? undefined : linkById.get(String(input.link));
+            if (link === undefined) continue;
+            inputs[input.name] = [link.origin, nodeSlotIndex(byId.get(link.origin), link.originSlot)];
+        }
+        // 2. Widget values fill the gaps, in declaration order.
+        const widgets = widgetInputs(spec);
+        const values = Array.isArray(node.widgets_values) ? node.widgets_values : [];
+        let cursor = 0;
+        for (const widget of widgets) {
+            if (cursor >= values.length) break;
+            let value = values[cursor];
+            cursor += 1;
+            // A seed widget writes TWO entries: the value and its control mode.
+            const declaration = widget.declaration;
+            // The options live in the second element as an object — a list there
+            // means "these are the allowed values", not widget options.
+            const options = declaration?.[1] !== null && typeof declaration?.[1] === 'object' && !Array.isArray(declaration[1])
+                ? declaration[1]
+                : {};
+            if (options.control_after_generate === true) cursor += 1;
+            if (value !== null && typeof value === 'object' && '__value__' in value) value = value.__value__;
+            if (widget.name in inputs) continue;
+            inputs[widget.name] = value;
+        }
+        prompt[String(node.id)] = { class_type: classType, inputs };
+    }
+    if (Object.keys(prompt).length === 0) {
+        return { prompt: null, warnings, error: '工作流里没有可用节点' };
+    }
+    return { prompt, warnings };
+}
+
+function nodeSlotIndex(node, slot) {
+    const outputs = Array.isArray(node?.outputs) ? node.outputs : [];
+    const output = outputs[slot];
+    if (output === undefined) return 0;
+    // The API addresses the slot that carries data; `links` on the UI output lists
+    // every outgoing link, and slot order matches unless a node declares an index.
+    return typeof output.slot_index === 'number' ? output.slot_index : slot;
+}
+
+/** Find the text inputs a person would type into (positive / negative). */
+export function promptTargets(prompt, declared) {
+    // Which encoder is the negative one is not written on the encoder: a
+    // CLIPTextEncode only has `text`. The sampler's `negative` link is the truth,
+    // so trace it first and fall back to naming heuristics after.
+    const negative = new Set();
+    const positive = new Set();
+    for (const node of Object.values(prompt ?? {})) {
+        for (const [name, value] of Object.entries(node?.inputs ?? {})) {
+            if (!Array.isArray(value) || value.length < 1) continue;
+            const target = String(value[0]);
+            if (/^negative$/i.test(name)) negative.add(target);
+            else if (/^positive$/i.test(name)) positive.add(target);
+        }
+    }
+ /**
+     * An operator declaration, when there IS one, decides every node's role.
+     *
+     * Inference answers "what does the sampler think this is"; the declaration answers "what
+     * does the person running this rig want this slot to be". On a graph with several text
+     * nodes feeding one sampler, inference returns the same role for all of them and the
+     * console cannot tell the boxes apart — so when a declaration exists it is the WHOLE
+     * answer: a node it does not name is `ignored`, not "inferred".
+     *
+     * That last part changed in 0.7.25. The old rule kept an undeclared node's inferred role
+     * "so a partial declaration does not silently unlabel the rest", which sounded cautious
+     * and behaved the opposite way: choosing 不参与 for a node did nothing at all, because
+     * the node was simply absent from both lists and immediately re-inferred as positive.
+     * "Every node 不参与" was likewise inexpressible — the console always grew a box back.
+     */
+    const declaration = declared !== null && typeof declared === 'object' && !Array.isArray(declared) ? declared : null;
+    /**
+     * Declarations may address a SLOT (`nodeId::input`) or just a node.
+     *
+     * A single node can hold several string inputs — `StringFunction|pysssss` has text_a /
+     * text_b / text_c, and 3lora人物 feeds two of them. Keying only by node made those two
+     * inseparable: one role for both, one head for both, and the editor listed the node twice
+     * with no way to tell which row was which. Slot keys fix that, and a bare node key still
+     * works so old records keep their meaning (it applies to every input of that node).
+     */
+    const declaredPositive = new Set((declaration?.positive ?? []).map(String));
+    const declaredNegative = new Set((declaration?.negative ?? []).map(String));
+    /**
+     * Slots the operator parked explicitly, by slot key or bare node id.
+     *
+     * This is the only thing that can keep a slot holding TEXT on 不参与 — absence from both
+     * lists cannot, because absence also means "never classified". Without it 不参与 was
+     * one-way: a slot with text always fell back to its inferred role and came back on.
+     */
+    const declaredIgnored = new Set((declaration?.ignored ?? []).map(String));
+    /**
+     * `{positive: [], negative: []}` is "switch every slot OFF" — a decision, not silence.
+     *
+     * `null` means "never classified" and inference still runs. An object with both lists empty
+     * means the operator parked everything on purpose, so every slot must land on 不参与 even
+     * when it holds text.
+     */
+    const allOff = declaration !== null
+        && declaredPositive.size === 0
+        && declaredNegative.size === 0
+        && declaredIgnored.size === 0;
+    const rolesFor = (id, name) => {
+        const slot = `${id}::${name}`;
+        if (declaredNegative.has(slot)) return 'negative';
+        if (declaredPositive.has(slot)) return 'positive';
+        // An explicit park wins over inference, but not over an explicit assignment above.
+        if (declaredIgnored.has(slot)) return 'ignored';
+        if (allOff) return 'ignored';
+        /**
+         * A bare node id only speaks for a node with ONE text slot.
+         *
+         * It cannot say which of text_a / text_b / text_c it meant, so applying it to all three
+         * forced them into the same role — and worse, dragged the empty ones along with it.
+         * On a multi-slot node the bare id is ignored entirely; those rows fall through to the
+         * dormant-slot rule (不参与) and the operator assigns them per slot.
+         */
+        const siblings = Object.keys(prompt?.[id]?.inputs ?? {})
+            .filter((key) => /text/i.test(key) && (typeof prompt[id].inputs[key] === 'string' || Array.isArray(prompt[id].inputs[key])))
+            .length;
+        if (siblings <= 1) {
+            if (declaredNegative.has(id)) return 'negative';
+            if (declaredPositive.has(id)) return 'positive';
+            if (declaredIgnored.has(id)) return 'ignored';
+        }
+        return '';
+    };
+    /** Does the declaration mention this node at all — by slot or by whole node? */
+    const declaredAnywhere = (id, name) => {
+        const slot = `${id}::${name}`;
+        if (declaredPositive.has(slot) || declaredNegative.has(slot)) return true;
+        if (declaredPositive.has(id) || declaredNegative.has(id)) return true;
+        return false;
+    };
+    /**
+     * A declaration is "in force" when the caller passed one at all — an object, even with
+     * both lists empty. `null`/`undefined` means the workflow was never classified, and then
+     * inference still runs (that is every workflow written before this field existed).
+     */
+    const hasDeclaration = declaration !== null;
+
+    const rows = [];
+    for (const [id, node] of Object.entries(prompt ?? {})) {
+        const classType = String(node.class_type ?? '');
+        for (const [name, value] of Object.entries(node.inputs ?? {})) {
+            /**
+             * Every `text*` input of a text node is a SLOT — empty strings and links included.
+             *
+             * `StringFunction|pysssss` is the case this is built for. Its node 15 has:
+             *
+             *   text_a  "score_9, …, 1girl, solo"   ← typed here
+             *   text_b  ["14", 0]                    ← wired from node 14
+             *   text_c  ""                           ← untouched, still a real input
+             *
+             * All three are places the node reads a prompt from, so all three get a box: the
+             * operator decides which one a tag goes into, and an empty one is exactly where a
+             * new line belongs. Hiding `text_c` because it happens to be empty made the panel
+             * show two boxes for a node with three inputs — the reported「节点15识别3个文本框
+             * 错误」, which was really "it shows the wrong two".
+             *
+             * A LINKED slot is included but flagged `wired`: its value comes from another node,
+             * so the console shows it read-only rather than pretending an edit would stick.
+             *
+             * `action` / `tidy_tags` are NOT slots: they hold enum words like "append" and
+             * "yes". The name test below is what keeps them out.
+             */
+            const isLink = Array.isArray(value);
+            if (!isLink && typeof value !== 'string') continue;
+            /**
+             * Which inputs are prompt TEXT.
+             *
+             * `text*` is the real rule: text, text_a, text_b, text_c, text_g, text_l. Those are
+             * the slots a person types into, whether they hold a string, an empty string, or a
+             * link.
+             *
+             * `clip`, `positive`, `negative` are different: they carry a CONDITIONING link
+             * (`["5", 1]`), never text. Accepting them as slots produced a wall of phantom rows
+             * — `3::positive`, `6::clip`, `10::clip` — one per encoder in the graph. They are
+             * only text when they genuinely hold a string (some custom nodes do that).
+             */
+            const isTextName = /text/i.test(name);
+            const isConditioningName = /^(clip|clip_l|t5xxl|prompt|positive|negative)$/i.test(name);
+            if (!isTextName && !(isConditioningName && !isLink)) continue;
+            let role = 'positive';
+            /**
+             * A slot is DORMANT when it has nothing to contribute — and dormant means 不参与.
+             *
+             * Two cases, same answer:
+             *   - empty string  — nothing typed, nowhere for a tag to go yet;
+             *   - wired (a link) — the text comes from another node, so a box here would accept
+             *     typing that the link overwrites at run time.
+             *
+             * Both still get a box in the EDITOR (every text slot is listed, so the operator can
+             * switch one on) but default to 不参与, which keeps them out of the console. That is
+             * the requested rule: 「空值默认归类不参与」. `15::text_c` is the case — a real input
+             * of the node, empty, editable in the workbench and absent from the run form.
+             */
+            const dormantSlot = isLink || String(value).trim() === '';
+            if (dormantSlot) role = 'ignored';
+            else if (negative.has(id) && !positive.has(id)) role = 'negative';
+            else if (/neg/i.test(name) || /neg/i.test(classType)) role = 'negative';
+            if (hasDeclaration) {
+                /**
+                 * A slot-level declaration is the answer when present.
+                 *
+                 * When it is absent, do NOT blanket-assign `ignored` — that is what erased a
+                 * real prompt. `3lora人物` stores a legacy `negative: ["7","15"]`; the bare id
+                 * cannot say which of node 15's three inputs it meant, so it is ignored, and
+                 * blanket-`ignored` then dropped `text_a` — which holds the actual positive
+                 * prompt — out of the console entirely.
+                 *
+                 * The rule is the same one the no-declaration case uses: a slot with text keeps
+                 * its inferred role, an empty slot is 不参与. A declaration only overrides the
+                 * slots it names.
+                 */
+                const slotRole = rolesFor(id, name);
+                if (slotRole !== '') role = slotRole;
+                else if (dormantSlot) role = 'ignored';
+                // else: keep the inferred role computed above — the slot has text of its own.
+                void declaredAnywhere;
+            }
+            rows.push({
+                nodeId: id,
+                input: name,
+                classType,
+                /**
+                 * A wired slot carries no text of its own — report the link, and say so.
+                 *
+                 * `value` stays a string everywhere downstream (it is the encoder text), so a
+                 * link becomes '' plus `wired: true`; the console renders that box read-only
+                 * with a note instead of pretending an edit would survive.
+                 */
+                value: isLink ? '' : value,
+                wired: isLink,
+                role,
+            });
+        }
+    }
+    // A CLIPTextEncode has exactly one `text`; several of them means positive and
+    // negative encoders, and the console shows both with their ids.
+    return rows;
+}
+
+/** Find the image inputs an upload can fill, and the node that will be written. */
+/**
+ * Strip the annotation ComfyUI's own frontend appends to a filename.
+ *
+ * Its image dropdown offers entries like `Upscale_2x_Pure_00003_.png [output]` — the bracket
+ * says which folder the file came from. That string is a UI label, not a filename: passing it
+ * to the instance means "this file does not exist", and it also fails the extension check here,
+ * which is why 去除衣物's node 4 reported no image input at all.
+ *
+ * Only a trailing `[something]` is removed, so a legitimate name containing brackets in the
+ * middle survives.
+ */
+export function stripNameAnnotation(value) {
+    return String(value ?? '').replace(/\s*\[[^\]]*\]\s*$/, '').trim();
+}
+
+/** The extension test every image/audio/video slot uses, applied to the de-annotated name. */
+const MEDIA_FILE = /\.(png|jpe?g|webp|bmp|gif|tiff?|avif|mp4|webm|mov|mkv|mp3|wav|flac|ogg)$/i;
+
+export function imageTargets(prompt, objectInfo) {
+    const rows = [];
+    for (const [id, node] of Object.entries(prompt ?? {})) {
+        const spec = objectInfo?.[node.class_type];
+        for (const [name, value] of Object.entries(node.inputs ?? {})) {
+            if (typeof value !== 'string') continue;
+            const declaration = spec?.input?.required?.[name] ?? spec?.input?.optional?.[name];
+            const type = Array.isArray(declaration) ? declaration[0] : undefined;
+            /**
+             * What counts as an image slot.
+             *
+             * The declaration is authoritative when the instance knows the class: IMAGE and
+             * MASK are both filled from an uploaded file.
+             *
+             * The name fallback is deliberately broad. It used to be an exact match on
+             * `image|image_path|mask|video`, which missed real inputs like `mask_path` — so a
+             * node holding BOTH an image and a mask reported a single slot, and the second one
+             * could never be set from the console even though the graph had two. Matching the
+             * concept anywhere in the name ("this input wants a picture") is what makes
+             * 「图生图可能有多个图片输入点」 actually reachable; the extension check below
+             * still rejects anything that is plainly not a file.
+             */
+            const nameIsImagey = /(^|_)(image|images|img|mask|masks|video|clip_frame|frame|init|reference|ref)(_|$)/i.test(name)
+                || /^(image|image_path|mask|mask_path|video|video_path)$/i.test(name);
+            const isImage = type === 'IMAGE' || type === 'MASK' || nameIsImagey;
+            /**
+             * Test the DE-ANNOTATED name, and report it so the console shows a real filename.
+             *
+             * `Upscale_2x_Pure_00003_.png [output]` is what the ComfyUI frontend stores when a
+             * file was picked from its dropdown; stripping is required both to recognise the
+             * slot and to submit something the instance can open.
+             */
+            const clean = stripNameAnnotation(value);
+            if (isImage && MEDIA_FILE.test(clean)) {
+                rows.push({ nodeId: id, input: name, classType: node.class_type, value: clean });
+            }
+        }
+    }
+    return rows;
+}
+
+/** Swap one text input's value without touching anything else. */
+/**
+ * Write prompt text into a node.
+ *
+ * `input` names the exact slot when the caller knows it, and the caller almost always does now:
+ * a text node can hold several strings (`StringFunction|pysssss` has `action`, `tidy_tags`,
+ * `text_a`, `text_b`, `text_c`). Picking "the first string field" wrote `blue_sky` into `action`
+ * — the node's setting, not its prompt — and the operator's text silently never reached the
+ * graph. Same rule as `setImage`: name the slot, and only fall back when nobody named one.
+ */
+export function setText(prompt, nodeId, value, input = '') {
+    const target = prompt?.[nodeId];
+    if (target === undefined || typeof target !== 'object') return false;
+    const inputs = target.inputs ?? {};
+    /**
+     * A named slot wins — but only if it currently holds a STRING.
+     *
+     * A wired slot holds a link (`["14", 0]`). Overwriting that with text would detach the other
+     * node and submit `"14,0,…"` as a literal, which ComfyUI accepts and then renders wrong.
+     */
+    if (typeof input === 'string' && input !== '') {
+        if (typeof inputs[input] !== 'string') return false;
+        inputs[input] = value;
+        return true;
+    }
+    /**
+     * No slot named (chain steps, older clients): prefer a field that looks like prompt text
+     * over the node's own settings. `action` / `tidy_tags` are enum words, not prompts.
+     */
+    const keys = Object.keys(inputs);
+    const looksLikePrompt = keys.find((key) => /text|prompt|clip/i.test(key) && typeof inputs[key] === 'string');
+    const fallback = looksLikePrompt ?? keys.find((key) => typeof inputs[key] === 'string');
+    if (fallback === undefined) return false;
+    inputs[fallback] = value;
+    return true;
+}
+
+/**
+ * Point an image input at a freshly uploaded file.
+ *
+ * `input` names the exact slot when the caller knows it. That matters once a graph has more
+ * than one image input on the same node: writing by node id alone picks the first matching
+ * field and leaves the other slot holding a filename nobody chose. When `input` is omitted
+ * (chain steps, older clients) the previous heuristic runs unchanged.
+ */
+export function setImage(prompt, nodeId, filename, input = '') {
+    const target = prompt?.[nodeId];
+    if (target === undefined || typeof target !== 'object') return false;
+    const named = String(input ?? '');
+    if (named !== '' && target.inputs !== null && typeof target.inputs === 'object' && named in target.inputs) {
+        target.inputs[named] = filename;
+        return true;
+    }
+    for (const key of Object.keys(target.inputs ?? {})) {
+        const current = target.inputs[key];
+        /**
+         * Compare the de-annotated name: a stored `x.png [output]` is a real image slot even
+         * though the raw string does not end in an image extension.
+         */
+        if (typeof current === 'string' && MEDIA_FILE.test(stripNameAnnotation(current))) {
+            target.inputs[key] = filename;
+            return true;
+        }
+    }
+    // No file value yet: the first string field on a loader is the filename slot.
+    for (const key of Object.keys(target.inputs ?? {})) {
+        if (typeof target.inputs[key] === 'string') {
+            target.inputs[key] = filename;
+            return true;
+        }
+    }
+    return false;
+}
+
+export { UPLOAD_TYPES, TEXT_TYPES };

package/lib/ws.js

@@ -0,0 +1,106 @@
+/**
+ * A dependency-free WebSocket server side: handshake plus text frames.
+ *
+ * The gateway only needs to *push* JSON at the official ComfyUI frontend
+ * (status / executing / progress / execution_success). Reading client frames
+ * is limited to ping/pong and close, which is all the frontend sends.
+ */
+import { createHash } from 'node:crypto';
+
+const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+function acceptKey(key) {
+    return createHash('sha1').update(key + GUID).digest('base64');
+}
+
+/** Encode one text frame from the server (never masked). */
+export function encodeText(text) {
+    const payload = Buffer.from(text, 'utf8');
+    const length = payload.length;
+    let header;
+    if (length < 126) {
+        header = Buffer.from([0x81, length]);
+    } else if (length < 65536) {
+        header = Buffer.alloc(4);
+        header[0] = 0x81;
+        header[1] = 126;
+        header.writeUInt16BE(length, 2);
+    } else {
+        header = Buffer.alloc(10);
+        header[0] = 0x81;
+        header[1] = 127;
+        header.writeBigUInt64BE(BigInt(length), 2);
+    }
+    return Buffer.concat([header, payload]);
+}
+
+export class WsServer {
+    constructor() {
+        /** @type {Set<import('node:net').Socket>} */
+        this.clients = new Set();
+    }
+
+    /**
+     * Complete the upgrade handshake for one socket.
+     * @returns {boolean} whether the socket is now a live client.
+     */
+    accept(request, socket) {
+        const key = request.headers['sec-websocket-key'];
+        if (typeof key !== 'string' || key === '') {
+            socket.destroy();
+            return false;
+        }
+        socket.write(
+            [
+                'HTTP/1.1 101 Switching Protocols',
+                'Upgrade: websocket',
+                'Connection: Upgrade',
+                `Sec-WebSocket-Accept: ${acceptKey(key)}`,
+                '\r\n',
+            ].join('\r\n'),
+        );
+        socket.setNoDelay(true);
+        this.clients.add(socket);
+        const drop = () => this.clients.delete(socket);
+        socket.on('close', drop);
+        socket.on('error', drop);
+        socket.on('data', (chunk) => {
+            // Answer pings, honour close; ignore everything else.
+            if (chunk.length > 0 && (chunk[0] & 0x0f) === 0x8) {
+                socket.end();
+                this.clients.delete(socket);
+            } else if (chunk.length > 0 && (chunk[0] & 0x0f) === 0x9) {
+                socket.write(Buffer.from([0x8a, 0x00]));
+            }
+        });
+        return true;
+    }
+
+    /** Broadcast one JSON message; dead sockets are dropped silently. */
+    broadcast(type, data) {
+        if (this.clients.size === 0) return;
+        const frame = encodeText(JSON.stringify({ type, data }));
+        for (const socket of this.clients) {
+            try {
+                socket.write(frame);
+            } catch {
+                this.clients.delete(socket);
+            }
+        }
+    }
+
+    get size() {
+        return this.clients.size;
+    }
+
+    dispose() {
+        for (const socket of this.clients) {
+            try {
+                socket.destroy();
+            } catch {
+                // already gone
+            }
+        }
+        this.clients.clear();
+    }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "title": "Multimodal Node",
+  "tab": "Multimodal",
+  "settingsSection": "Multimodal Node",
+  "summary": "One plugin, two identities: a service node opens ports, dispatches work and hosts the ComfyUI/Blender ports; a user node opens nothing and pulls templates, the queue and models from a service node, saving products locally."
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "title": "多模态节点",
+  "tab": "多模态",
+  "settingsSection": "多模态节点",
+  "summary": "一个插件两种身份：服务节点开门派发任务并托管 ComfyUI/Blender 端口；用户节点不开门，连服务节点拿模板、队列、模型，产物落本机目录。"
+}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "dsh-multimodal-node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.1",
+  "description": "多模态节点：一个插件两种身份。服务节点开门（API 接入端口 + 网页端口），把任务排队分发到绑定的 ComfyUI 实例并托管本机 Blender 渲染；用户节点不开门，连服务节点拿工作流模板、当前队列、模型列表，产物落到本机目录。含网页账号与 apikey 两套凭据、SFW/NSFW 分级。",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "lib",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "dsh-plugin",
+    "comfyui",
+    "blender",
+    "multimodal",
+    "render-farm",
+    "task-pool",
+    "deepseek-harness"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
+  "scripts": {
+    "test": "node test/all.mjs",
+    "test:render": "node test/render.mjs",
+    "test:isolation": "node test/isolation.mjs",
+    "test:deps": "node test/deps.mjs",
+    "test:mutate": "node test/mutate.mjs",
+    "test:packgate": "node test/packgate.mjs",
+    "test:blender-real": "node test/blender-real.mjs",
+    "test:blender-edge": "node test/blender-edge.mjs"
+  },
+  "license": "MIT",
+  "author": "lc297948801",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    }
+  }
+}