dsh-multimodal-node 0.0.0-stage → 0.2.2

package/lib/http.js

@@ -0,0 +1,119 @@
+/** Tiny HTTP helpers shared by the gateway listener and the panel routes. */
+export function sendJson(response, status, value) {
+    const body = JSON.stringify(value ?? {});
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': String(Buffer.byteLength(body)),
+        'cache-control': 'no-store',
+    });
+    response.end(body);
+}
+
+export function errorMessage(error) {
+    if (error instanceof Error) return error.message;
+    return String(error);
+}
+
+/**
+ * Pipe a stream into an HTTP response without letting its late `error` kill the
+ * host process.
+ *
+ * `Readable.fromWeb(response.body)` is a live view of a `fetch()` that carries
+ * `AbortSignal.timeout(...)`. When that timer fires after the client has already
+ * gone (browser cancelled a thumbnail, navigated away on save, closed the tab),
+ * the readable emits `'error'` — and a bare `source.pipe(response)` has **no**
+ * `'error'` listener on the source, so Node turns it into an `uncaughtException`.
+ * The desktop host installs fail-loud handlers, so one abandoned `/media` request
+ * makes the whole DSH exit ~60 s later with "dsh desktop host exited with 1".
+ *
+ * Guarding both directions keeps a dead client and a stalled upstream local to the
+ * request: destroy the source when the response is gone, destroy the response when
+ * the source fails.
+ */
+export function pipeGuarded(source, response) {
+    let settled = false;
+    const stop = () => {
+        if (settled) return;
+        settled = true;
+        source.destroy?.();
+    };
+    const fail = () => {
+        if (settled) return;
+        settled = true;
+        source.destroy?.();
+        if (!response.writableEnded && !response.destroyed) response.destroy();
+    };
+    source.on?.('error', fail);
+    response.on('error', stop);
+    response.on('close', () => {
+        if (!response.writableEnded) stop();
+    });
+    source.pipe(response);
+}
+
+/** Read a JSON body with a hard size cap; throws on malformed JSON. */
+export async function readJson(request, limitBytes = 32 * 1024 * 1024) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of request) {
+        total += chunk.length;
+        if (total > limitBytes) throw new Error(`请求体超过 ${Math.round(limitBytes / 1048576)} MB`);
+        chunks.push(chunk);
+    }
+    if (chunks.length === 0) return {};
+    const text = Buffer.concat(chunks).toString('utf8');
+    return JSON.parse(text);
+}
+
+/** POST guard for the panel routes: same origin only. */
+export function sameOrigin(request) {
+    const origin = request.headers.origin;
+    if (typeof origin !== 'string' || origin === '') return true;
+    const host = request.headers.host;
+    if (typeof host !== 'string') return false;
+    try {
+        return new URL(origin).host === host;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 关掉一个 HTTP server，并**保证端口立刻释放**。
+ *
+ * `server.close()` 只是「不再接受新连接」，它要等所有现有连接（包括 keep-alive
+ * 空闲连接）自然结束才回调。浏览器保持长连接、手机锁屏挂着的页面、甚至一次
+ * 刚结束的 fetch 都会留下这种连接——于是 close 的回调迟迟不来，端口一直占着，
+ * 紧接着的重新 listen 就撞 EADDRINUSE。
+ *
+ * 实测症状（本机）：插件重载后日志只有一行 `address already in use`，
+ * 而「是不是刚有人在用网页」完全看不出来。
+ *
+ * `closeAllConnections()` 是 Node 18.2+ 提供的：强制断开所有连接，
+ * 配合 close 就把端口真正还回去了。老版本没有就退回 closeIdleConnections。
+ */
+export function closeServer(server) {
+    if (server === null || server === undefined) return Promise.resolve();
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+            if (settled) return;
+            settled = true;
+            resolve();
+        };
+        // 兜底：close 的回调在某些平台上可能因为残留 socket 迟到，不能无限等。
+        const timer = setTimeout(done, 2000);
+        if (typeof timer.unref === 'function') timer.unref();
+        try {
+            server.close(() => {
+                clearTimeout(timer);
+                done();
+            });
+            if (typeof server.closeAllConnections === 'function') server.closeAllConnections();
+            else if (typeof server.closeIdleConnections === 'function') server.closeIdleConnections();
+        } catch {
+            clearTimeout(timer);
+            done();
+        }
+    });
+}

package/lib/imagesize.js

@@ -0,0 +1,92 @@
+/**
+ * Pixel dimensions from the first bytes of a file.
+ *
+ * The console shows each asset's size, and ComfyUI's history does not carry it:
+ * `outputs` names the file, nothing more. Reading the header is cheap (a few
+ * hundred bytes), works for every format this plugin can produce, and avoids
+ * decoding the image on either side.
+ */
+import { Readable } from 'node:stream';
+
+/** Bytes needed to describe any format we support. */
+export const HEADER_BYTES = 65536;
+
+/**
+ * @param {Buffer} buffer at least the first ~32 bytes of the file
+ * @returns {{ width: number, height: number } | null}
+ */
+export function imageSize(buffer) {
+    if (buffer === null || buffer === undefined || buffer.length < 8) return null;
+
+    // PNG: 8-byte signature, then an IHDR chunk whose width/height are big-endian.
+    if (buffer.length >= 24 && buffer.readUInt32BE(0) === 0x89504e47 && buffer.readUInt32BE(4) === 0x0d0a1a0a) {
+        return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+    }
+
+    // GIF: "GIF87a" / "GIF89a", then little-endian width/height.
+    const head6 = buffer.subarray(0, 6).toString('latin1');
+    if ((head6 === 'GIF87a' || head6 === 'GIF89a') && buffer.length >= 10) {
+        return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+    }
+
+    // WebP: RIFF....WEBP, then a VP8/VP8L/VP8X chunk.
+    if (buffer.length >= 30 && buffer.subarray(0, 4).toString('latin1') === 'RIFF' && buffer.subarray(8, 12).toString('latin1') === 'WEBP') {
+        const kind = buffer.subarray(12, 16).toString('latin1');
+        if (kind === 'VP8 ') {
+            return { width: buffer.readUInt16LE(26) & 0x3fff, height: buffer.readUInt16LE(28) & 0x3fff };
+        }
+        if (kind === 'VP8L') {
+            const bits = buffer.readUInt32LE(21);
+            return { width: (bits & 0x3fff) + 1, height: ((bits >> 14) & 0x3fff) + 1 };
+        }
+        if (kind === 'VP8X') {
+            return { width: buffer.readUIntLE(24, 3) + 1, height: buffer.readUIntLE(27, 3) + 1 };
+        }
+        return null;
+    }
+
+    // JPEG: walk the segment chain to the first SOF marker.
+    if (buffer[0] === 0xff && buffer[1] === 0xd8) {
+        let offset = 2;
+        while (offset + 9 < buffer.length) {
+            if (buffer[offset] !== 0xff) {
+                offset += 1;
+                continue;
+            }
+            const marker = buffer[offset + 1];
+            // SOF0..SOF15, excluding DHT (C4), JPG (C8) and DAC (CC).
+            if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                return { width: buffer.readUInt16BE(offset + 7), height: buffer.readUInt16BE(offset + 5) };
+            }
+            const length = buffer.readUInt16BE(offset + 2);
+            if (length < 2) return null;
+            offset += 2 + length;
+        }
+        return null;
+    }
+
+    return null;
+}
+
+/**
+ * Read just the header of a file through one instance's `/view` and report its
+ * pixel size. Failure is `null`, never a throw: a missing size must not stop a
+ * run from being recorded.
+ */
+export async function probeSize(backend, query) {
+    try {
+        const stream = await backend.openView(query, 'GET', `bytes=0-${HEADER_BYTES - 1}`);
+        const chunks = [];
+        let total = 0;
+        // The body is a Readable; take what we need and drop the rest so the
+        // connection is not held open by a response nobody reads to the end.
+        for await (const chunk of stream.body ?? Readable.from([])) {
+            chunks.push(chunk);
+            total += chunk.length;
+            if (total >= HEADER_BYTES) break;
+        }
+        return imageSize(Buffer.concat(chunks));
+    } catch {
+        return null;
+    }
+}