@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/media/fetch.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
 import { detectMime, extensionForMime } from "./mime.js";
 export class MediaFetchError extends Error {
     code;
@@ -12,8 +13,9 @@ function stripQuotes(value) {
     return value.replace(/^["']|["']$/g, "");
 }
 function parseContentDispositionFileName(header) {
-    if (!header)
+    if (!header) {
         return undefined;
+    }
     const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
     if (starMatch?.[1]) {
         const cleaned = stripQuotes(starMatch[1].trim());
@@ -26,20 +28,24 @@ function parseContentDispositionFileName(header) {
         }
     }
     const match = /filename\s*=\s*([^;]+)/i.exec(header);
-    if (match?.[1])
+    if (match?.[1]) {
         return path.basename(stripQuotes(match[1].trim()));
+    }
     return undefined;
 }
 async function readErrorBodySnippet(res, maxChars = 200) {
     try {
         const text = await res.text();
-        if (!text)
+        if (!text) {
             return undefined;
+        }
         const collapsed = text.replace(/\s+/g, " ").trim();
-        if (!collapsed)
+        if (!collapsed) {
             return undefined;
-        if (collapsed.length <= maxChars)
+        }
+        if (collapsed.length <= maxChars) {
             return collapsed;
+        }
         return `${collapsed.slice(0, maxChars)}…`;
     }
     catch {
@@ -47,69 +53,85 @@ async function readErrorBodySnippet(res, maxChars = 200) {
     }
 }
 export async function fetchRemoteMedia(options) {
-    const { url, fetchImpl, filePathHint, maxBytes } = options;
-    const fetcher = fetchImpl ?? globalThis.fetch;
-    if (!fetcher) {
-        throw new Error("fetch is not available");
-    }
+    const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
     let res;
+    let finalUrl = url;
+    let release = null;
     try {
-        res = await fetcher(url);
+        const result = await fetchWithSsrFGuard({
+            url,
+            fetchImpl,
+            maxRedirects,
+            policy: ssrfPolicy,
+            lookupFn,
+        });
+        res = result.response;
+        finalUrl = result.finalUrl;
+        release = result.release;
     }
     catch (err) {
         throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
     }
-    if (!res.ok) {
-        const statusText = res.statusText ? ` ${res.statusText}` : "";
-        const redirected = res.url && res.url !== url ? ` (redirected to ${res.url})` : "";
-        let detail = `HTTP ${res.status}${statusText}`;
-        if (!res.body) {
-            detail = `HTTP ${res.status}${statusText}; empty response body`;
+    try {
+        if (!res.ok) {
+            const statusText = res.statusText ? ` ${res.statusText}` : "";
+            const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
+            let detail = `HTTP ${res.status}${statusText}`;
+            if (!res.body) {
+                detail = `HTTP ${res.status}${statusText}; empty response body`;
+            }
+            else {
+                const snippet = await readErrorBodySnippet(res);
+                if (snippet) {
+                    detail += `; body: ${snippet}`;
+                }
+            }
+            throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
         }
-        else {
-            const snippet = await readErrorBodySnippet(res);
-            if (snippet)
-                detail += `; body: ${snippet}`;
+        const contentLength = res.headers.get("content-length");
+        if (maxBytes && contentLength) {
+            const length = Number(contentLength);
+            if (Number.isFinite(length) && length > maxBytes) {
+                throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+            }
         }
-        throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
-    }
-    const contentLength = res.headers.get("content-length");
-    if (maxBytes && contentLength) {
-        const length = Number(contentLength);
-        if (Number.isFinite(length) && length > maxBytes) {
-            throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+        const buffer = maxBytes
+            ? await readResponseWithLimit(res, maxBytes)
+            : Buffer.from(await res.arrayBuffer());
+        let fileNameFromUrl;
+        try {
+            const parsed = new URL(finalUrl);
+            const base = path.basename(parsed.pathname);
+            fileNameFromUrl = base || undefined;
         }
+        catch {
+            // ignore parse errors; leave undefined
+        }
+        const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+        let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : undefined);
+        const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : (filePathHint ?? finalUrl);
+        const contentType = await detectMime({
+            buffer,
+            headerMime: res.headers.get("content-type"),
+            filePath: filePathForMime,
+        });
+        if (fileName && !path.extname(fileName) && contentType) {
+            const ext = extensionForMime(contentType);
+            if (ext) {
+                fileName = `${fileName}${ext}`;
+            }
+        }
+        return {
+            buffer,
+            contentType: contentType ?? undefined,
+            fileName,
+        };
     }
-    const buffer = maxBytes
-        ? await readResponseWithLimit(res, maxBytes)
-        : Buffer.from(await res.arrayBuffer());
-    let fileNameFromUrl;
-    try {
-        const parsed = new URL(url);
-        const base = path.basename(parsed.pathname);
-        fileNameFromUrl = base || undefined;
-    }
-    catch {
-        // ignore parse errors; leave undefined
-    }
-    const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
-    let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : undefined);
-    const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : (filePathHint ?? url);
-    const contentType = await detectMime({
-        buffer,
-        headerMime: res.headers.get("content-type"),
-        filePath: filePathForMime,
-    });
-    if (fileName && !path.extname(fileName) && contentType) {
-        const ext = extensionForMime(contentType);
-        if (ext)
-            fileName = `${fileName}${ext}`;
+    finally {
+        if (release) {
+            await release();
+        }
     }
-    return {
-        buffer,
-        contentType: contentType ?? undefined,
-        fileName,
-    };
 }
 async function readResponseWithLimit(res, maxBytes) {
     const body = res.body;
@@ -126,8 +148,9 @@ async function readResponseWithLimit(res, maxBytes) {
     try {
         while (true) {
             const { done, value } = await reader.read();
-            if (done)
+            if (done) {
                 break;
+            }
             if (value?.length) {
                 total += value.length;
                 if (total > maxBytes) {

package/dist/media/input-files.js

@@ -78,7 +78,7 @@ export async function fetchWithGuard(params) {
             try {
                 const response = await fetch(parsedUrl, {
                     signal: controller.signal,
-                    headers: { "User-Agent": "Moltbot-Gateway/1.0" },
+                    headers: { "User-Agent": "Poolbot-Gateway/1.0" },
                     redirect: "manual",
                     dispatcher,
                 });

package/dist/media/mime.js

@@ -11,7 +11,10 @@ const EXT_BY_MIME = {
     "image/gif": ".gif",
     "audio/ogg": ".ogg",
     "audio/mpeg": ".mp3",
+    "audio/x-m4a": ".m4a",
+    "audio/mp4": ".m4a",
     "video/mp4": ".mp4",
+    "video/quicktime": ".mov",
     "application/pdf": ".pdf",
     "application/json": ".json",
     "application/zip": ".zip",
@@ -43,6 +46,7 @@ const AUDIO_FILE_EXTENSIONS = new Set([
     ".ogg",
     ".opus",
     ".wav",
+    ".caf",
 ]);
 function normalizeHeaderMime(mime) {
     if (!mime)

package/dist/media/png-encode.js

@@ -0,0 +1,74 @@
+/**
+ * Minimal PNG encoder for generating simple RGBA images without native dependencies.
+ * Used for QR codes, live probes, and other programmatic image generation.
+ */
+import { deflateSync } from "node:zlib";
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let c = i;
+        for (let k = 0; k < 8; k += 1) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[i] = c >>> 0;
+    }
+    return table;
+})();
+/** Compute CRC32 checksum for a buffer (used in PNG chunk encoding). */
+export function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i += 1) {
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** Create a PNG chunk with type, data, and CRC. */
+export function pngChunk(type, data) {
+    const typeBuf = Buffer.from(type, "ascii");
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length, 0);
+    const crc = crc32(Buffer.concat([typeBuf, data]));
+    const crcBuf = Buffer.alloc(4);
+    crcBuf.writeUInt32BE(crc, 0);
+    return Buffer.concat([len, typeBuf, data, crcBuf]);
+}
+/** Write a pixel to an RGBA buffer. Ignores out-of-bounds writes. */
+export function fillPixel(buf, x, y, width, r, g, b, a = 255) {
+    if (x < 0 || y < 0 || x >= width) {
+        return;
+    }
+    const idx = (y * width + x) * 4;
+    if (idx < 0 || idx + 3 >= buf.length) {
+        return;
+    }
+    buf[idx] = r;
+    buf[idx + 1] = g;
+    buf[idx + 2] = b;
+    buf[idx + 3] = a;
+}
+/** Encode an RGBA buffer as a PNG image. */
+export function encodePngRgba(buffer, width, height) {
+    const stride = width * 4;
+    const raw = Buffer.alloc((stride + 1) * height);
+    for (let row = 0; row < height; row += 1) {
+        const rawOffset = row * (stride + 1);
+        raw[rawOffset] = 0; // filter: none
+        buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
+    }
+    const compressed = deflateSync(raw);
+    const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // color type RGBA
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    return Buffer.concat([
+        signature,
+        pngChunk("IHDR", ihdr),
+        pngChunk("IDAT", compressed),
+        pngChunk("IEND", Buffer.alloc(0)),
+    ]);
+}