@melaya/runner 1.1.42 → 1.1.45

package/dist/uploadFetch.js

@@ -0,0 +1,393 @@
+// File-source resolution for the runner bridge's `upload_file` act.
+//
+// The runner machine is the EXECUTING side, so it is the one that turns a file
+// source into real bytes on disk before CDP's DOM.setFileInputFiles can attach
+// them to a page's <input type=file>. Three sources:
+//
+//   handle "fh_<hex>_<ext>"  — minted by the server's staging flow
+//                              (services/browser/browserUploadMedia.ts);
+//                              fetched from GET <serverBase>/browser-media/
+//                              <hex>.<ext> (public capability URL, short TTL).
+//   url (http/https)         — downloaded directly by the runner. The URL was
+//                              chosen by a model, and this code runs on the
+//                              USER'S machine, so private/loopback/link-local
+//                              addresses are blocked (a mirror of the server's
+//                              safeFetch guard, self-contained here): the
+//                              user's LAN must not be reachable through it.
+//   path (local file)        — LOCAL-RUNNER-ONLY convenience for pipeline
+//                              artifacts already on this machine. Never
+//                              reachable from the cloud action schema (it has
+//                              no path field); the loose local-bridge contract
+//                              is the only door, and it is image-gated below.
+//
+// v1 is IMAGES ONLY (png/jpg/webp/gif), 10MB cap, magic-byte verified — the
+// same allowlist the server's stager enforces, re-checked here because this
+// path can bypass the server entirely (direct url / local path).
+import { lookup as dnsLookup } from "node:dns";
+import * as http from "node:http";
+import * as https from "node:https";
+import { randomBytes } from "node:crypto";
+import { writeFile, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+export const UPLOAD_MAX_BYTES = 10 * 1024 * 1024;
+const CT_BY_EXT = {
+    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp",
+    gif: "image/gif",
+};
+export class UploadSourceError extends Error {
+}
+function extForContentType(ct) {
+    const base = (ct || "").split(";")[0].trim().toLowerCase();
+    switch (base) {
+        case "image/png": return "png";
+        case "image/jpeg":
+        case "image/jpg": return "jpg";
+        case "image/webp": return "webp";
+        case "image/gif": return "gif";
+        default: return null;
+    }
+}
+function extOfName(name) {
+    const m = /\.([a-z0-9]{2,4})(?:[?#]|$)/i.exec(name || "");
+    const ext = m ? m[1].toLowerCase() : "";
+    return ext in CT_BY_EXT ? ext : null;
+}
+function imageSniffOk(buf, ext) {
+    if (buf.length < 12)
+        return false;
+    if (ext === "png")
+        return buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47;
+    if (ext === "jpg" || ext === "jpeg")
+        return buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff;
+    if (ext === "webp")
+        return buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP";
+    if (ext === "gif")
+        return buf.toString("ascii", 0, 3) === "GIF";
+    return false;
+}
+// ── Private-address guard (mirror of server safeFetch's block ranges) ────────
+function ipv4ToInt(ip) {
+    const m = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (!m)
+        return null;
+    const o = m.slice(1).map(Number);
+    if (o.some((x) => x > 255))
+        return null;
+    return (((o[0] << 24) >>> 0) + (o[1] << 16) + (o[2] << 8) + o[3]) >>> 0;
+}
+function isBlockedV4(ip) {
+    const n = ipv4ToInt(ip);
+    if (n === null)
+        return true; // unparseable -> block (fail closed)
+    const inRange = (base, bits) => {
+        const b = ipv4ToInt(base);
+        if (b === null)
+            return false;
+        const mask = bits === 0 ? 0 : (~0 << (32 - bits)) >>> 0;
+        return (n & mask) === (b & mask);
+    };
+    return inRange("0.0.0.0", 8) || inRange("10.0.0.0", 8) || inRange("100.64.0.0", 10) ||
+        inRange("127.0.0.0", 8) || inRange("169.254.0.0", 16) || inRange("172.16.0.0", 12) ||
+        inRange("192.0.0.0", 24) || inRange("192.168.0.0", 16) || inRange("198.18.0.0", 15) ||
+        inRange("224.0.0.0", 4) || inRange("240.0.0.0", 4);
+}
+function parseV6(addr) {
+    let a = addr.trim().toLowerCase().replace(/^\[|\]$/g, "").replace(/%.*$/, "");
+    if (!a.includes(":"))
+        return null;
+    const dotted = a.match(/(.*:)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+    if (dotted) {
+        const v4 = ipv4ToInt(dotted[2]);
+        if (v4 === null)
+            return null;
+        a = dotted[1] + (((v4 >>> 16) & 0xffff).toString(16)) + ":" + ((v4 & 0xffff).toString(16));
+    }
+    const halves = a.split("::");
+    if (halves.length > 2)
+        return null;
+    const head = halves[0] ? halves[0].split(":") : [];
+    const tail = halves.length === 2 ? (halves[1] ? halves[1].split(":") : []) : null;
+    const toWords = (parts) => {
+        const out = [];
+        for (const p of parts) {
+            if (!/^[0-9a-f]{1,4}$/.test(p))
+                return null;
+            out.push(parseInt(p, 16));
+        }
+        return out;
+    };
+    const h = toWords(head);
+    if (h === null)
+        return null;
+    if (tail === null)
+        return h.length === 8 ? h : null;
+    const t = toWords(tail);
+    if (t === null)
+        return null;
+    const fill = 8 - h.length - t.length;
+    if (fill < 0)
+        return null;
+    return [...h, ...Array(fill).fill(0), ...t];
+}
+function isBlockedIp(addr) {
+    const a = addr.trim().toLowerCase().replace(/^\[|\]$/g, "").replace(/%.*$/, "");
+    if (!a.includes(":"))
+        return isBlockedV4(a);
+    const w = parseV6(a);
+    if (w === null)
+        return true;
+    if (w[0] === 0 && w[1] === 0 && w[2] === 0 && w[3] === 0 && w[4] === 0 && w[5] === 0xffff) {
+        const v4 = `${(w[6] >> 8) & 0xff}.${w[6] & 0xff}.${(w[7] >> 8) & 0xff}.${w[7] & 0xff}`;
+        return isBlockedV4(v4);
+    }
+    return (w[0] & 0xe000) !== 0x2000; // only global unicast 2000::/3
+}
+/** Validating + pinning lookup: the socket connects to exactly the vetted
+ *  address, so there is no DNS-rebinding TOCTOU window. */
+function validatingLookup(hostname, options, callback) {
+    const all = !!(options && typeof options === "object" && options.all);
+    dnsLookup(hostname, { all: true, verbatim: true }, (err, addresses) => {
+        if (err || !addresses || (Array.isArray(addresses) && addresses.length === 0)) {
+            callback(Object.assign(new Error("upload_url_unresolvable"), { code: "ENOTFOUND" }), "");
+            return;
+        }
+        const recs = addresses;
+        for (const r of recs) {
+            if (isBlockedIp(r.address)) {
+                callback(Object.assign(new Error("upload_url_blocked_ip"), { code: "EACCES" }), "");
+                return;
+            }
+        }
+        if (all)
+            callback(null, recs);
+        else
+            callback(null, recs[0].address, recs[0].family);
+    });
+}
+/** One guarded GET, following up to 5 redirects (each hop re-validated). */
+async function guardedGet(urlStr, opts) {
+    let current = urlStr;
+    for (let hop = 0; hop <= 5; hop++) {
+        let u;
+        try {
+            u = new URL(current);
+        }
+        catch {
+            throw new UploadSourceError(`invalid URL: ${current}`);
+        }
+        if (u.protocol !== "http:" && u.protocol !== "https:")
+            throw new UploadSourceError(`unsupported scheme '${u.protocol}' — only http(s) URLs can be uploaded`);
+        if (opts.guardPrivate && u.port && u.port !== "80" && u.port !== "443")
+            throw new UploadSourceError("non-standard ports are blocked for upload URLs");
+        if (opts.guardPrivate) {
+            const bare = u.hostname.replace(/^\[|\]$/g, "");
+            if ((ipv4ToInt(bare) !== null || bare.includes(":")) && isBlockedIp(bare)) {
+                throw new UploadSourceError("that URL points at a private/loopback address, which is blocked");
+            }
+        }
+        const r = await new Promise((resolve, reject) => {
+            const mod = u.protocol === "https:" ? https : http;
+            const req = mod.request(u, {
+                method: "GET",
+                ...(opts.guardPrivate ? { lookup: validatingLookup } : {}),
+                headers: { Accept: "image/*,*/*;q=0.5", "User-Agent": "MelayaRunner/1.0 (browser_upload)" },
+            }, (res) => {
+                const status = res.statusCode || 0;
+                const contentType = String(res.headers["content-type"] || "");
+                if (status >= 300 && status < 400 && res.headers.location) {
+                    res.resume();
+                    resolve({ status, contentType, location: String(res.headers.location), body: Buffer.alloc(0) });
+                    return;
+                }
+                const chunks = [];
+                let received = 0;
+                res.on("data", (c) => {
+                    received += c.length;
+                    if (received > opts.maxBytes) {
+                        req.destroy();
+                        reject(new UploadSourceError(`the file exceeds the ${Math.round(opts.maxBytes / 1024 / 1024)}MB upload cap`));
+                        return;
+                    }
+                    chunks.push(c);
+                });
+                res.on("end", () => resolve({ status, contentType, body: Buffer.concat(chunks) }));
+                res.on("error", (e) => reject(e));
+            });
+            req.on("error", (e) => reject(e));
+            req.setTimeout(opts.timeoutMs, () => { req.destroy(); reject(new UploadSourceError("timed out downloading the file")); });
+            req.end();
+        });
+        if (r.status >= 300 && r.status < 400 && r.location) {
+            current = new URL(r.location, current).toString();
+            continue;
+        }
+        if (r.status < 200 || r.status >= 300)
+            throw new UploadSourceError(`download failed with HTTP ${r.status}`);
+        return { body: r.body, contentType: r.contentType, finalUrl: current };
+    }
+    throw new UploadSourceError("too many redirects");
+}
+function validateImage(buf, extHint, label) {
+    if (!buf.length)
+        throw new UploadSourceError(`${label} is empty`);
+    if (buf.length > UPLOAD_MAX_BYTES)
+        throw new UploadSourceError(`${label} exceeds the ${Math.round(UPLOAD_MAX_BYTES / 1024 / 1024)}MB upload cap`);
+    // Sniff first, trust headers/extensions second: the bytes are the authority.
+    for (const ext of extHint ? [extHint] : []) {
+        if (imageSniffOk(buf, ext))
+            return ext;
+    }
+    for (const ext of Object.keys(CT_BY_EXT)) {
+        if (imageSniffOk(buf, ext))
+            return ext;
+    }
+    throw new UploadSourceError(`${label} is not a supported image — v1 uploads accept png, jpg, webp or gif only`);
+}
+async function toTemp(buf, ext) {
+    const name = `melaya-upload-${randomBytes(6).toString("hex")}.${ext}`;
+    const p = join(tmpdir(), name);
+    await writeFile(p, buf, { mode: 0o600 });
+    return { path: p, name: `upload.${ext}`, bytes: buf.length, temp: true };
+}
+/** Loose act args (flat width/height/fit/format from browser.py, or a strict
+ *  `resize` object) → a normalized UploadResize, or null when none asked. */
+export function parseUploadResize(args) {
+    const src = (args.resize && typeof args.resize === "object" ? args.resize : args);
+    const w = Math.trunc(Number(src.width));
+    const h = Math.trunc(Number(src.height));
+    const fit = String(src.fit ?? "").trim().toLowerCase();
+    const format = String(src.format ?? "").trim().toLowerCase().replace(/^jpg$/, "jpeg");
+    const out = {
+        ...(Number.isFinite(w) && w >= 1 && w <= 10_000 ? { width: w } : {}),
+        ...(Number.isFinite(h) && h >= 1 && h <= 10_000 ? { height: h } : {}),
+        ...(fit === "contain" || fit === "cover" ? { fit: fit } : {}),
+        ...(format === "png" || format === "jpeg" || format === "webp" ? { format: format } : {}),
+    };
+    return out.width || out.height || out.format ? out : null;
+}
+const MIME_BY_EXT = {
+    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif",
+};
+/** Apply a resize/convert to a resolved file by running a canvas job through
+ *  the supplied JS evaluator (an async-IIFE expression whose awaited value is
+ *  the transformed image as base64). Returns a NEW temp file; throws
+ *  UploadSourceError with an actionable message when the page cannot do it. */
+export async function applyUploadResize(file, resize, evaluate) {
+    const srcExt = (file.path.split(".").pop() || "png").toLowerCase();
+    const srcMime = MIME_BY_EXT[srcExt] || "image/png";
+    const outExt = resize.format === "jpeg" ? "jpg" : (resize.format || (srcExt === "gif" ? "png" : srcExt));
+    const outMime = MIME_BY_EXT[outExt] || srcMime;
+    const raw = await readFile(file.path);
+    const w = resize.width || 0;
+    const h = resize.height || 0;
+    const fit = resize.fit === "cover" ? "cover" : "contain";
+    // Everything interpolated below is numeric or JSON-quoted — nothing from a
+    // page, nothing free-form; the base64 alphabet cannot break the string out.
+    const expression = `(async function(){
+    var bin = atob(${JSON.stringify(raw.toString("base64"))});
+    var bytes = new Uint8Array(bin.length);
+    for (var i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    var bmp = await createImageBitmap(new Blob([bytes], { type: ${JSON.stringify(srcMime)} }));
+    var sw = bmp.width, sh = bmp.height;
+    var w = ${w}, h = ${h};
+    var W, H, dx, dy, dw, dh;
+    if (w && h) {
+      W = w; H = h;
+      var s = ${JSON.stringify(fit)} === "cover" ? Math.max(w / sw, h / sh) : Math.min(w / sw, h / sh);
+      dw = sw * s; dh = sh * s; dx = (W - dw) / 2; dy = (H - dh) / 2;
+    } else if (w) { W = w; H = Math.max(1, Math.round(sh * w / sw)); dx = 0; dy = 0; dw = W; dh = H; }
+    else if (h) { H = h; W = Math.max(1, Math.round(sw * h / sh)); dx = 0; dy = 0; dw = W; dh = H; }
+    else { W = sw; H = sh; dx = 0; dy = 0; dw = sw; dh = sh; }
+    var canvas = new OffscreenCanvas(W, H);
+    var g = canvas.getContext("2d");
+    if (${JSON.stringify(outMime)} === "image/jpeg") { g.fillStyle = "#fff"; g.fillRect(0, 0, W, H); }
+    g.imageSmoothingQuality = "high";
+    g.drawImage(bmp, dx, dy, dw, dh);
+    var blob = await canvas.convertToBlob({ type: ${JSON.stringify(outMime)}, quality: 0.92 });
+    var out = new Uint8Array(await blob.arrayBuffer());
+    var s2 = ""; var CH = 32768;
+    for (var j = 0; j < out.length; j += CH) s2 += String.fromCharCode.apply(null, Array.prototype.slice.call(out.subarray(j, j + CH)));
+    return btoa(s2);
+  })()`;
+    let outB64;
+    try {
+        outB64 = await evaluate(expression);
+    }
+    catch (e) {
+        throw new UploadSourceError(`could not convert the image in the browser (${e.message}). ` +
+            "Retry without width/height/format, or convert the file before uploading.");
+    }
+    if (typeof outB64 !== "string" || !outB64) {
+        throw new UploadSourceError("the in-browser image conversion returned nothing — retry without width/height/format, or convert the file before uploading.");
+    }
+    const buf = Buffer.from(outB64, "base64");
+    if (!buf.length)
+        throw new UploadSourceError("the in-browser image conversion produced an empty file.");
+    if (buf.length > UPLOAD_MAX_BYTES)
+        throw new UploadSourceError(`the converted image exceeds the ${Math.round(UPLOAD_MAX_BYTES / 1024 / 1024)}MB upload cap.`);
+    return toTemp(buf, outExt);
+}
+/** Staged-handle source: fetch <serverBase>/browser-media/<hex>.<ext>. */
+export async function resolveHandleSource(serverBase, handle) {
+    const m = /^fh_([a-f0-9]{32})_([a-z0-9]{2,4})$/.exec((handle || "").trim());
+    if (!m || !(m[2].toLowerCase() in CT_BY_EXT)) {
+        throw new UploadSourceError(`'${String(handle).slice(0, 60)}' is not a staged file handle (expected "fh_<hex>_<ext>"). ` +
+            "Use browser_upload with a public image `url` — it stages the file and mints the handle for you.");
+    }
+    const base = (serverBase || "").replace(/\/+$/, "");
+    if (!base)
+        throw new UploadSourceError("this run has no server base configured, so a staged handle cannot be resolved — pass a public image `url` instead");
+    const { body } = await guardedGet(`${base}/browser-media/${m[1]}.${m[2].toLowerCase()}`, {
+        maxBytes: UPLOAD_MAX_BYTES, timeoutMs: 30_000, guardPrivate: false, // the user's own server base may be private in dev
+    });
+    const ext = validateImage(body, m[2].toLowerCase(), "the staged file");
+    return toTemp(body, ext);
+}
+/** URL source: guarded direct download from the runner machine. */
+export async function resolveUrlSource(url) {
+    const { body, contentType, finalUrl } = await guardedGet(url, {
+        maxBytes: UPLOAD_MAX_BYTES, timeoutMs: 30_000, guardPrivate: true,
+    });
+    const hint = extForContentType(contentType) ?? extOfName(new URL(finalUrl).pathname);
+    const ext = validateImage(body, hint, `the file at ${url}`);
+    return toTemp(body, ext);
+}
+/** Base64 data-URL source: decoded locally (no network). Same image-only
+ *  allowlist, sniff and cap. NOTE the local bridge's request body cap bounds
+ *  how much base64 can arrive this way; large files should come as a staged
+ *  handle or a url. */
+export async function resolveDataUrlSource(dataUrl) {
+    const m = /^data:([a-z0-9.+/-]+)(?:;[a-z0-9=.-]+)*;base64,([A-Za-z0-9+/=\s]+)$/i.exec((dataUrl || "").trim());
+    if (!m)
+        throw new UploadSourceError('expected a base64 data URL like "data:image/png;base64,..."');
+    const b64 = m[2].replace(/\s+/g, "");
+    if (b64.length > Math.ceil((UPLOAD_MAX_BYTES * 4) / 3) + 8) {
+        throw new UploadSourceError(`the file exceeds the ${Math.round(UPLOAD_MAX_BYTES / 1024 / 1024)}MB upload cap`);
+    }
+    const buf = Buffer.from(b64, "base64");
+    const ext = validateImage(buf, extForContentType(m[1]), "the data URL payload");
+    return toTemp(buf, ext);
+}
+/** Local-path source (LOCAL RUNNER ONLY): an image file already on this
+ *  machine. Image-gated by magic bytes, so this cannot be used to lift an
+ *  arbitrary local file (keys, configs, code) onto a website. */
+export async function resolvePathSource(path) {
+    const p = (path || "").trim();
+    if (!p)
+        throw new UploadSourceError("empty path");
+    let size;
+    try {
+        size = (await stat(p)).size;
+    }
+    catch {
+        throw new UploadSourceError(`no file at '${p}' on the runner machine`);
+    }
+    if (size > UPLOAD_MAX_BYTES)
+        throw new UploadSourceError(`the file exceeds the ${Math.round(UPLOAD_MAX_BYTES / 1024 / 1024)}MB upload cap`);
+    const buf = await readFile(p);
+    const ext = validateImage(buf, extOfName(p), `the file at ${p}`);
+    // The file already exists locally with the right bytes — attach it in place
+    // (no temp copy) so nothing else has to be cleaned up.
+    return { path: p, name: `upload.${ext}`, bytes: buf.length, temp: false };
+}