@melaya/runner 1.1.42 → 1.1.45

package/dist/browserBridge.js

@@ -39,6 +39,8 @@ import { SessionManager, SessionError, spaceUserDataDir, } from "./sessionManage
 import { ensureEngine } from "./browserProvisioner.js";
 import { runSandboxedScript } from "./codeWorker.js";
 import { classifyControlEffect, writeGatedInMode } from "./publishGate.js";
+import { applyUploadResize, parseUploadResize, resolveDataUrlSource, resolveHandleSource, resolvePathSource, resolveUrlSource, UploadSourceError, } from "./uploadFetch.js";
+import { unlink } from "node:fs/promises";
 // A wall-clock around a CDP command. Playwright's CDPSession.send has NO default
 // timeout, so a wedged/busy renderer means the promise NEVER settles (not a
 // rejection - no catch fires) and the lease op-chain queues every later op
@@ -1772,14 +1774,136 @@ export async function startBrowserBridge(opts) {
                     };
                 }
                 case "upload_file": {
-                    // Honest refusal, not act_kind_unknown. The tool is advertised and
-                    // the schema validates the handle shape, but NOTHING anywhere
-                    // resolves an approved handle back to bytes — not this bridge, not
-                    // the server, not the extension. Saying "unknown kind" sent the model
-                    // hunting for a different spelling of a tool that cannot work yet.
-                    throw new BridgeError("effect_not_granted", "File upload is not available on this transport: an approved file handle cannot be resolved to " +
-                        "a file yet, on any transport. Ask the USER to attach the file themselves with " +
-                        "browser_ask_user, then continue once they confirm.");
+                    // Attach file(s) to a page <input type=file> via CDP
+                    // DOM.setFileInputFiles. Sources, in precedence order: a staged
+                    // handle ("fh_<hex>_<ext>", from the server's browserUploadMedia
+                    // staging flow), a public image URL (guarded direct download — the
+                    // runner IS the executing side), or a LOCAL-RUNNER-ONLY file path.
+                    // v1 is images only (png/jpg/webp/gif), 10MB, magic-byte verified.
+                    //
+                    // GATE FIRST, download after: selecting a file onto a site is a
+                    // commit-shaped write (same family as submit), so in safe autonomy
+                    // it stages the approval card BEFORE any bytes move. browser.py's
+                    // poll loop re-issues the same act; the approved re-issue is the one
+                    // that downloads and attaches.
+                    await enforcePublishGate(reg, page, kind, "", String(args.ref ?? "file input"), args.hitl_mode, "publish");
+                    const handle = String(args.handle ?? args.value ?? (Array.isArray(args.fileHandles) ? args.fileHandles[0] : "") ?? "").trim();
+                    const srcUrl = String(args.url ?? "").trim();
+                    const srcPath = String(args.path ?? "").trim();
+                    const srcData = String(args.data ?? "").trim();
+                    const attachmentId = String(args.attachment_id ?? "").trim();
+                    let file;
+                    try {
+                        if (attachmentId) {
+                            // Per-turn chat attachments resolve to fh_ handles on the SERVER
+                            // (assistant stream / ext-bridge). A runner-LAUNCHED browser is a
+                            // pipeline transport with no chat turn to hold them, so the id is
+                            // unresolvable here — name the sources that do work.
+                            throw new BridgeError("act_args_invalid", "attachment_id is not available on the runner-launched browser transport — pass the image as " +
+                                "a public `url`, a base64 `data` URL, or a runner-local `path` instead.");
+                        }
+                        if (handle)
+                            file = await resolveHandleSource(String(reg.spec.serverBase || ""), handle);
+                        else if (srcUrl)
+                            file = await resolveUrlSource(srcUrl);
+                        else if (srcData)
+                            file = await resolveDataUrlSource(srcData);
+                        else if (srcPath)
+                            file = await resolvePathSource(srcPath);
+                        else {
+                            throw new BridgeError("act_args_invalid", "upload_file needs a file source: `url` (public http(s) image URL, max 10MB), `data` (a base64 " +
+                                "data URL), a staged `handle` (fh_...), or — on this local runner only — `path` (an image file " +
+                                "on this machine).");
+                        }
+                    }
+                    catch (e) {
+                        if (e instanceof BridgeError)
+                            throw e;
+                        if (e instanceof UploadSourceError)
+                            throw new BridgeError("act_args_invalid", `upload_file: ${e.message}`);
+                        throw new BridgeError("unknown_outcome", `upload_file could not resolve the file source: ${e.message}`);
+                    }
+                    if (file.temp)
+                        reg.uploadTmpFiles.push(file.path);
+                    // Convert-before-attach (width/height/fit/format): a canvas job run
+                    // through the page's JS context — the runner has no image library,
+                    // but it HAS a browser. Pure computation; no DOM mutation.
+                    const resizeSpec = parseUploadResize(args);
+                    if (resizeSpec) {
+                        const cdpForResize = await getCdp(rec, page);
+                        try {
+                            file = await applyUploadResize(file, resizeSpec, async (expression) => {
+                                const r = await cdpRace(cdpForResize.send("Runtime.evaluate", {
+                                    expression, awaitPromise: true, returnByValue: true,
+                                }), "Runtime.evaluate", 60_000);
+                                if (r.exceptionDetails)
+                                    throw new Error(r.exceptionDetails.text || "page threw during the canvas conversion");
+                                return r.result?.value;
+                            });
+                        }
+                        catch (e) {
+                            if (e instanceof UploadSourceError)
+                                throw new BridgeError("act_args_invalid", `upload_file: ${e.message}`);
+                            throw new BridgeError("unknown_outcome", `upload_file could not convert the image: ${e.message}`);
+                        }
+                        if (file.temp)
+                            reg.uploadTmpFiles.push(file.path);
+                    }
+                    // Locate the REAL <input type=file>. The ref may point at the input
+                    // itself, at a styled upload button that HIDES the input, or be
+                    // absent entirely — the common case, since hidden inputs rarely get
+                    // a ref in the tree. Search order: self, descendant, label control,
+                    // the enclosing form's input, the page's first file input.
+                    const FIND_FROM_REF = "function(){ var el = this;" +
+                        " var isFile = function(n){ return n && n.tagName && n.tagName.toLowerCase()==='input' && (n.getAttribute('type')||'').toLowerCase()==='file'; };" +
+                        " if (isFile(el)) return el;" +
+                        " var q = el && el.querySelector ? el.querySelector('input[type=file]') : null; if (q) return q;" +
+                        " if (el && el.tagName && el.tagName.toLowerCase()==='label') {" +
+                        "   var c = el.control || (el.htmlFor ? document.getElementById(el.htmlFor) : null); if (isFile(c)) return c; }" +
+                        " var f = el && el.closest ? el.closest('form') : null;" +
+                        " var q2 = f ? f.querySelector('input[type=file]') : null; if (q2) return q2;" +
+                        " var all = document.querySelectorAll('input[type=file]'); return all.length ? all[0] : null; }";
+                    const FIND_ON_PAGE = "(function(){ var all = Array.prototype.slice.call(document.querySelectorAll('input[type=file]'));" +
+                        " if (!all.length) return null;" +
+                        " var vis = all.filter(function(i){ var r = i.getBoundingClientRect(); return r.width>0 && r.height>0; });" +
+                        " return vis[0] || all[0]; })()";
+                    const cdp = await getCdp(rec, page);
+                    let inputObjectId = null;
+                    if (args.ref) {
+                        const binding = sessions.resolveRef(lease, args.ref);
+                        const resolved = await cdpRace(cdp.send("DOM.resolveNode", { backendNodeId: binding.backendNodeId }), "DOM.resolveNode");
+                        const found = await cdpRace(cdp.send("Runtime.callFunctionOn", {
+                            objectId: resolved.object.objectId,
+                            functionDeclaration: FIND_FROM_REF,
+                        }), "Runtime.callFunctionOn");
+                        inputObjectId = found.result?.objectId && found.result.subtype !== "null" ? found.result.objectId : null;
+                    }
+                    else {
+                        const found = await cdpRace(cdp.send("Runtime.evaluate", {
+                            expression: FIND_ON_PAGE,
+                        }), "Runtime.evaluate");
+                        inputObjectId = found.result?.objectId && found.result.subtype !== "null" ? found.result.objectId : null;
+                    }
+                    if (!inputObjectId) {
+                        throw new BridgeError("act_args_invalid", "no <input type=file> found" + (args.ref ? ` at or near ref '${args.ref}'` : " on this page") + ". " +
+                            "Some uploaders only create the input after their Upload button is clicked — click it first, then " +
+                            "retry upload_file. If the page opens a NATIVE file-picker dialog instead, hand off with browser_ask_user.");
+                    }
+                    // Set the files, then fire the events a real selection fires — CDP's
+                    // DOM.setFileInputFiles changes .files WITHOUT dispatching them, and
+                    // every framework listens on input/change.
+                    await cdpRace(cdp.send("DOM.setFileInputFiles", { files: [file.path], objectId: inputObjectId }), "DOM.setFileInputFiles");
+                    await cdpRace(cdp.send("Runtime.callFunctionOn", {
+                        objectId: inputObjectId,
+                        functionDeclaration: "function(){ this.dispatchEvent(new Event('input',{bubbles:true})); this.dispatchEvent(new Event('change',{bubbles:true})); return this.files ? this.files.length : 0; }",
+                        returnByValue: true,
+                    }), "Runtime.callFunctionOn");
+                    return {
+                        uploaded: true,
+                        files: [file.name],
+                        bytes: file.bytes,
+                        note: "file attached to the input — the page's own submit/save control still commits it",
+                    };
                 }
                 default:
                     throw new BridgeError("act_kind_unknown", `unhandled kind '${kind}'`);
@@ -2423,6 +2547,7 @@ export async function startBrowserBridge(opts) {
             sessionInit: null,
             traces: [],
             externalAttach: false,
+            uploadTmpFiles: [],
         };
         byToken.set(token, reg);
         byRunId.set(spec.runId, reg);
@@ -2451,6 +2576,12 @@ export async function startBrowserBridge(opts) {
         for (const e of reg.enforcement.splice(0)) {
             await e.dispose().catch(() => { });
         }
+        // Delete any upload temp files this run staged. Deferred to teardown on
+        // purpose: the browser reads the file LAZILY when the page's form submits,
+        // which can be several agent turns after the upload_file act.
+        for (const p of reg.uploadTmpFiles.splice(0)) {
+            await unlink(p).catch(() => { });
+        }
         byRunId.delete(runId);
         byToken.delete(reg.token);
         activePageByRunId.delete(runId);