dsh-multimodal-node 0.0.0-stage → 0.3.1

package/lib/chain.js

@@ -0,0 +1,161 @@
+/**
+ * Work chains: an ordered list of steps, run one after another.
+ *
+ * What a chain is NOT: a graph. Each step is an existing workflow plus the settings a
+ * person would have typed into the console (layers, negatives, params, a run count). The
+ * value of chaining is that step N+1 can consume step N's image, which is the thing the
+ * console cannot do — you would have to download the output, re-upload it, and pick the
+ * next workflow by hand.
+ *
+ * Storage is per account, in `chains.json`, same shape as prompts.json:
+ *   { byOwner: { <user>: [ {id, name, steps[], at} ] } }
+ *
+ * A step is validated, not trusted: it must name a workflow the account can see, and the
+ * count is clamped. An unvalidated step would only fail at run time, after the earlier
+ * steps had already burned GPU time.
+ */
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const MAX_CHAINS = 100;
+export const MAX_STEPS = 12;
+
+export class ChainLibrary {
+    constructor(dataDir) {
+        this.file = join(dataDir, 'chains.json');
+        this.byOwner = {};
+    }
+
+    async init() {
+        await mkdir(join(this.file, '..'), { recursive: true });
+        try {
+            const raw = await readFile(this.file, 'utf8');
+            const parsed = JSON.parse(raw);
+            this.byOwner = parsed !== null && typeof parsed.byOwner === 'object' && parsed.byOwner !== null ? parsed.byOwner : {};
+        } catch {
+            this.byOwner = {};
+            await this.save();
+        }
+    }
+
+    async save() {
+        const temp = `${this.file}.tmp`;
+        await writeFile(temp, `${JSON.stringify({ byOwner: this.byOwner }, null, 2)}\n`, 'utf8');
+        await rename(temp, this.file);
+    }
+
+    list(owner) {
+        const rows = Array.isArray(this.byOwner[owner]) ? this.byOwner[owner] : [];
+        return rows.slice().sort((left, right) => (right.at ?? 0) - (left.at ?? 0));
+    }
+
+    get(owner, id) {
+        return this.list(owner).find((row) => row.id === id);
+    }
+
+    /**
+     * Normalise one step.
+     *
+     * `feedPrevious` is the whole point of a chain: when true, the previous step's first
+     * output image is pushed into this step's image input. It defaults to false because
+     * feeding a text-to-image step an image it does not have an input for is a silent
+     * no-op, and defaults should not be surprising.
+     */
+    static normalizeStep(input, index) {
+        const workflowId = String(input?.workflowId ?? '');
+        const repeat = Math.min(8, Math.max(1, Math.floor(Number(input?.repeat ?? 1)) || 1));
+        const layers = Array.isArray(input?.layers) ? input.layers.map((value) => String(value ?? '')) : [];
+        const params = Array.isArray(input?.params)
+            ? input.params
+                  .filter((row) => row !== null && typeof row === 'object' && typeof row.nodeId === 'string' && typeof row.input === 'string')
+                  .map((row) => ({ nodeId: row.nodeId, input: row.input, value: row.value }))
+            : [];
+        return {
+            index,
+            workflowId,
+            // A step with no name is legal at build time (the id is what runs); the label
+            // is resolved from the library at display time so renames show up.
+            label: typeof input?.label === 'string' ? input.label.slice(0, 60) : '',
+            layers,
+            negative: typeof input?.negative === 'string' ? input.negative : '',
+            params,
+            repeat,
+            /**
+             * Seed for this step: random by default, fixed when the step names a value.
+             *
+             * Kept per step rather than per chain because a chain mixes intents — the base
+             * image wants variety, a refiner pass wants to stay on the picture it was given.
+             */
+            seed: input?.seed === undefined || input?.seed === null
+                ? { mode: 'random' }
+                : {
+                    mode: input?.seed?.mode === 'fixed' ? 'fixed' : 'random',
+                    ...(input?.seed?.value === undefined ? {} : { value: input.seed.value }),
+                },
+            feedPrevious: input?.feedPrevious === true,
+        };
+    }
+
+    /** Save (or update by name) one chain. */
+    async add(owner, input) {
+        const name = String(input?.name ?? '').trim().slice(0, 60);
+        if (name === '') throw new Error('工作链需要一个名字');
+        const rawSteps = Array.isArray(input?.steps) ? input.steps : [];
+        if (rawSteps.length === 0) throw new Error('工作链至少要有一个环节');
+        if (rawSteps.length > MAX_STEPS) throw new Error(`最多 ${MAX_STEPS} 个环节`);
+        const steps = rawSteps.map((step, index) => ChainLibrary.normalizeStep(step, index));
+        if (steps.some((step) => step.workflowId === '')) throw new Error('每个环节都要选一个工作流');
+
+        const rows = Array.isArray(this.byOwner[owner]) ? this.byOwner[owner] : [];
+        const existing = rows.find((row) => row.name === name);
+        const record = {
+            id: existing?.id ?? `c-${randomBytes(4).toString('hex')}`,
+            name,
+            steps,
+            at: Date.now(),
+        };
+        if (existing === undefined) {
+            rows.unshift(record);
+            this.byOwner[owner] = rows.slice(0, MAX_CHAINS);
+        } else {
+            rows[rows.indexOf(existing)] = record;
+            this.byOwner[owner] = rows;
+        }
+        await this.save();
+        return record;
+    }
+
+    async remove(owner, id) {
+        const rows = Array.isArray(this.byOwner[owner]) ? this.byOwner[owner] : [];
+        const next = rows.filter((row) => row.id !== id);
+        if (next.length === rows.length) throw new Error('没有这条工作链');
+        this.byOwner[owner] = next;
+        await this.save();
+        return { ok: true };
+    }
+}
+
+/**
+ * Which image a step should be fed from the previous step's outputs.
+ *
+ * Picks the first image by extension, preferring `output` over `temp`: a preview written
+ * to temp is often a lower-quality or intermediate render, and chaining off it produces a
+ * worse second step than chaining off the saved output.
+ */
+export function firstImageOutput(outputs) {
+    const rows = [];
+    for (const output of Object.values(outputs ?? {})) {
+        for (const list of Object.values(output ?? {})) {
+            if (!Array.isArray(list)) continue;
+            for (const item of list) {
+                if (item === null || typeof item !== 'object') continue;
+                if (typeof item.filename !== 'string' || item.filename === '') continue;
+                if (!/\.(png|jpe?g|webp|bmp)$/i.test(item.filename)) continue;
+                rows.push({ filename: item.filename, type: String(item.type ?? 'output') });
+            }
+        }
+    }
+    const saved = rows.find((row) => row.type === 'output');
+    return saved ?? rows[0] ?? null;
+}

package/lib/comfy.js

@@ -0,0 +1,204 @@
+/**
+ * Minimal ComfyUI HTTP client used by the gateway.
+ *
+ * One instance of this class = one ComfyUI backend (one GPU, one port). Every
+ * method is a plain fetch: the gateway is a façade, so it must stay free of
+ * dependencies and must never buffer media it can stream.
+ */
+import { Readable } from 'node:stream';
+
+/** Strip a trailing slash so `${base()}/queue` never doubles it. */
+function trimBase(url) {
+    return String(url).trim().replace(/\/+$/, '');
+}
+
+export class BackendError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.name = 'BackendError';
+        this.status = status;
+    }
+}
+
+export class Backend {
+    /** @param {{id:string,label?:string,baseUrl:string,apiKey?:string}} instance */
+    constructor(instance) {
+        this.instance = instance;
+    }
+
+    get id() {
+        return this.instance.id;
+    }
+
+    base() {
+        return trimBase(this.instance.baseUrl);
+    }
+
+    headers(extra) {
+        const head = { ...(extra ?? {}) };
+        const key = this.instance.apiKey ?? '';
+        if (key !== '') head.authorization = `Bearer ${key}`;
+        return head;
+    }
+
+    async request(path, options = {}) {
+        const url = this.base() + path;
+        const timeout = options.timeout ?? 15000;
+        const init = {
+            method: options.method ?? 'GET',
+            headers: this.headers(options.headers),
+            signal: options.signal ?? AbortSignal.timeout(timeout),
+        };
+        if (options.body !== undefined) {
+            init.body = options.body;
+            if (typeof options.body === 'string' && init.headers['content-type'] === undefined) {
+                init.headers['content-type'] = 'application/json';
+            }
+        }
+        let response;
+        try {
+            response = await fetch(url, init);
+        } catch (error) {
+            throw new BackendError(`${this.id} ${path}: ${error instanceof Error ? error.message : String(error)}`, 0);
+        }
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            /**
+             * Keep the WHOLE rejection body.
+             *
+             * This used to be `.slice(0, 200)`, and that made every upstream failure
+             * undiagnosable: a ComfyUI validation error names the exact node and input that
+             * was rejected, and 200 characters cut the string off just before
+             * `node_errors` — the one field that says WHAT was wrong. Two real failures
+             * ("精修 失败") were investigated blind because of it, and the stored row in
+             * runs.json ended up as invalid JSON that could not even be parsed back.
+             *
+             * The cap now only guards against a pathological megabyte-sized body; normal
+             * validation errors are a few hundred bytes and come through intact.
+             */
+            throw new BackendError(`${this.id} ${path} -> HTTP ${response.status}${text === '' ? '' : ` ${text.slice(0, 8000)}`}`, response.status);
+        }
+        return response;
+    }
+
+    async json(path, options) {
+        const response = await this.request(path, options);
+        return response.json();
+    }
+
+    systemStats() {
+        return this.json('/system_stats', { timeout: 4000 });
+    }
+
+    objectInfo() {
+        return this.json('/object_info', { timeout: 20000 });
+    }
+
+    queue() {
+        return this.json('/queue', { timeout: 6000 });
+    }
+
+    /** `/history?max_items=` — the map of prompt id to completed entry. */
+    history(maxItems = 64) {
+        return this.json(`/history?max_items=${encodeURIComponent(String(maxItems))}`, { timeout: 10000 });
+    }
+
+    /** `{}` while the prompt is still queued or running. */
+    historyOf(promptId) {
+        return this.json(`/history/${encodeURIComponent(promptId)}`, { timeout: 10000 });
+    }
+
+    prompt(body) {
+        return this.json('/prompt', {
+            method: 'POST',
+            body: JSON.stringify(body),
+            timeout: 30000,
+        });
+    }
+
+    interrupt(promptId) {
+        const body = promptId === undefined ? {} : { prompt_id: promptId };
+        return this.request('/interrupt', {
+            method: 'POST',
+            body: JSON.stringify(body),
+            timeout: 8000,
+        }).then(() => undefined);
+    }
+
+    free(body) {
+        return this.request('/free', {
+            method: 'POST',
+            body: JSON.stringify(body ?? { unload_models: true, free_memory: true }),
+            timeout: 15000,
+        }).then(() => undefined);
+    }
+
+    async deleteQueueItems(promptIds) {
+        if (promptIds.length === 0) return;
+        await this.request('/queue', {
+            method: 'POST',
+            body: JSON.stringify({ delete: promptIds }),
+            timeout: 8000,
+        });
+    }
+
+    async clearQueue() {
+        await this.request('/queue', { method: 'POST', body: JSON.stringify({ clear: true }), timeout: 8000 });
+    }
+
+    /** Raw stream for `/view`, forwarding Range so media players can seek. */
+    async openView(query, method = 'GET', range) {
+        const headers = this.headers();
+        if (range !== undefined && range !== null && range !== '') headers.range = range;
+        const response = await fetch(`${this.base()}/view?${query}`, {
+            method,
+            headers,
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => {});
+            throw new BackendError(`${this.id} /view -> HTTP ${response.status}`, response.status);
+        }
+        return {
+            status: response.status,
+            headers: response.headers,
+            body: response.body === null ? null : Readable.fromWeb(response.body),
+        };
+    }
+}
+
+/** One backend, one call, with the health result normalised for the panel. */
+export async function probe(instance, timeout = 4000) {
+    const backend = new Backend(instance);
+    const started = Date.now();
+    try {
+        const stats = await backend.systemStats();
+        const devices = Array.isArray(stats?.devices) ? stats.devices : [];
+        return {
+            id: instance.id,
+            ok: true,
+            latencyMs: Date.now() - started,
+            version: stats?.system?.comfyui_version ?? null,
+            python: stats?.system?.python_version ?? null,
+            argv: Array.isArray(stats?.system?.argv) ? stats.system.argv : [],
+            devices: devices.map((device) => ({
+                name: device.name ?? null,
+                type: device.type ?? null,
+                vramTotal: device.vram_total ?? null,
+                vramFree: device.vram_free ?? null,
+            })),
+            error: null,
+            at: Date.now(),
+        };
+    } catch (error) {
+        return {
+            id: instance.id,
+            ok: false,
+            latencyMs: Date.now() - started,
+            version: null,
+            devices: [],
+            error: error instanceof Error ? error.message : String(error),
+            at: Date.now(),
+        };
+    }
+}