runline 0.7.7 → 0.8.0

package/dist/plugins/steel/src/index.js

@@ -0,0 +1,378 @@
+const NAME = "steel";
+const DEFAULT_STEEL_BASE = "https://api.steel.dev";
+// ── Helpers ──────────────────────────────────────────────────────────
+function compactText(value) {
+    return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function clampWait(value, fallback = 9000, max = 45000) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    return Math.min(Math.floor(n), max);
+}
+function getConnectionConfig(ctx) {
+    const cfg = (ctx?.connection?.config ?? {});
+    return {
+        steelApiKey: compactText(cfg.steelApiKey),
+        steelBaseUrl: compactText(cfg.steelBaseUrl || DEFAULT_STEEL_BASE).replace(/\/+$/, ""),
+        steelProxyUrl: compactText(cfg.steelProxyUrl),
+    };
+}
+class SteelClient {
+    apiKey;
+    baseUrl;
+    proxyUrl;
+    constructor(cfg) {
+        if (!cfg.steelApiKey) {
+            throw new Error("Missing STEEL_API_KEY. Configure it before using the steel browser plugin.");
+        }
+        this.apiKey = cfg.steelApiKey;
+        this.baseUrl = cfg.steelBaseUrl || DEFAULT_STEEL_BASE;
+        this.proxyUrl = cfg.steelProxyUrl;
+    }
+    async request(method, pathname, body) {
+        const resp = await fetch(`${this.baseUrl}${pathname}`, {
+            method,
+            headers: { "steel-api-key": this.apiKey, "content-type": "application/json" },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const text = await resp.text();
+        if (!resp.ok) {
+            throw new Error(`Steel ${method} ${pathname} -> ${resp.status}: ${text.slice(0, 300)}`);
+        }
+        return text ? JSON.parse(text) : {};
+    }
+    async createSession({ useProxy = false, timeout = 180000 } = {}) {
+        const body = { timeout };
+        if (useProxy) {
+            if (!this.proxyUrl)
+                throw new Error("useProxy requested but STEEL_PROXY_URL is not configured.");
+            body.proxyUrl = this.proxyUrl;
+        }
+        return this.request("POST", "/v1/sessions", body);
+    }
+    async release(sessionId) {
+        try {
+            return await this.request("POST", `/v1/sessions/${sessionId}/release`);
+        }
+        catch {
+            return { success: false };
+        }
+    }
+    // Steel's hosted screenshot API stores the image on images.steel.dev and
+    // returns a PUBLIC URL (no auth) that renders inline in chat — the bytes
+    // never have to traverse the agent runtime (which strips large base64).
+    async hostedScreenshot({ url, fullPage = false, delay, useProxy = false }) {
+        const body = { url };
+        if (fullPage)
+            body.fullPage = true;
+        if (Number.isFinite(delay) && delay > 0)
+            body.delay = delay;
+        if (useProxy) {
+            if (!this.proxyUrl)
+                throw new Error("useProxy requested but STEEL_PROXY_URL is not configured.");
+            body.proxyUrl = this.proxyUrl;
+        }
+        const res = await this.request("POST", "/v1/screenshot", body);
+        return res?.url || null;
+    }
+}
+class CdpConnection {
+    wsUrl;
+    nextId = 0;
+    pending = new Map();
+    ws = null;
+    constructor(wsUrl) {
+        this.wsUrl = wsUrl;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (typeof WebSocket === "undefined") {
+                reject(new Error("Global WebSocket is not available in this runtime; the steel browser plugin needs Node 22+ / Bun."));
+                return;
+            }
+            const ws = new WebSocket(this.wsUrl);
+            this.ws = ws;
+            const onError = () => reject(new Error("Steel CDP websocket connection failed"));
+            ws.addEventListener("open", () => {
+                ws.removeEventListener("error", onError);
+                resolve();
+            });
+            ws.addEventListener("error", onError);
+            ws.addEventListener("close", () => {
+                for (const [, p] of this.pending)
+                    p.reject(new Error("Steel CDP connection closed"));
+                this.pending.clear();
+            });
+            ws.addEventListener("message", (ev) => {
+                let msg;
+                try {
+                    msg = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+                }
+                catch {
+                    return;
+                }
+                if (msg.id != null && this.pending.has(msg.id)) {
+                    const p = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error)
+                        p.reject(new Error(msg.error.message || "CDP error"));
+                    else
+                        p.resolve(msg.result);
+                }
+            });
+        });
+    }
+    send(method, params = {}, sessionId, timeoutMs = 45000) {
+        const requestId = ++this.nextId;
+        const payload = { id: requestId, method, params };
+        if (sessionId)
+            payload.sessionId = sessionId;
+        return new Promise((resolve, reject) => {
+            this.pending.set(requestId, { resolve, reject });
+            try {
+                this.ws.send(JSON.stringify(payload));
+            }
+            catch (err) {
+                this.pending.delete(requestId);
+                reject(err);
+                return;
+            }
+            setTimeout(() => {
+                if (this.pending.has(requestId)) {
+                    this.pending.delete(requestId);
+                    reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms`));
+                }
+            }, timeoutMs);
+        });
+    }
+    close() {
+        try {
+            this.ws?.close();
+        }
+        catch {
+            /* noop */
+        }
+    }
+}
+class PageDriver {
+    conn;
+    sessionId;
+    constructor(conn, sessionId) {
+        this.conn = conn;
+        this.sessionId = sessionId;
+    }
+    static async attachFirstPage(conn) {
+        const { targetInfos } = await conn.send("Target.getTargets");
+        let target = (targetInfos || []).find((t) => t.type === "page");
+        if (!target) {
+            const created = await conn.send("Target.createTarget", { url: "about:blank" });
+            target = { targetId: created.targetId };
+        }
+        const { sessionId } = await conn.send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
+        const driver = new PageDriver(conn, sessionId);
+        await conn.send("Page.enable", {}, sessionId);
+        await conn.send("Runtime.enable", {}, sessionId);
+        return driver;
+    }
+    async navigate(url) {
+        await this.conn.send("Page.navigate", { url }, this.sessionId);
+    }
+    async eval(expression) {
+        const r = await this.conn.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, this.sessionId);
+        if (r.exceptionDetails) {
+            throw new Error(`page eval failed: ${r.exceptionDetails.text || r.exceptionDetails.exception?.description || "exception"}`);
+        }
+        return r.result?.value;
+    }
+}
+// Render a URL in a Steel browser and run a callback with the live PageDriver.
+async function withRenderedPage(cfg, { url, useProxy = false, waitMs = 9000, waitSelector }, fn) {
+    const steel = new SteelClient(cfg);
+    const session = await steel.createSession({ useProxy });
+    const wsUrl = `${session.websocketUrl}${session.websocketUrl.includes("?") ? "&" : "?"}apiKey=${encodeURIComponent(steel.apiKey)}`;
+    const conn = new CdpConnection(wsUrl);
+    try {
+        await conn.connect();
+        const page = await PageDriver.attachFirstPage(conn);
+        await page.navigate(url);
+        await sleep(Math.min(waitMs, 6000));
+        if (waitSelector) {
+            const deadline = Date.now() + Math.max(0, waitMs - 6000);
+            while (Date.now() < deadline) {
+                const found = await page.eval(`!!document.querySelector(${JSON.stringify(waitSelector)})`);
+                if (found)
+                    break;
+                await sleep(1500);
+            }
+        }
+        else if (waitMs > 6000) {
+            await sleep(waitMs - 6000);
+        }
+        return await fn(page, { sessionId: session.id, viewer: session.sessionViewerUrl });
+    }
+    finally {
+        conn.close();
+        await steel.release(session.id);
+    }
+}
+function robotWallExpr() {
+    return `/are you a human|verify you('| a)re not a robot|not a robot|enable javascript|access denied|unusual traffic/i.test((document.body && document.body.innerText || '').slice(0, 4000))`;
+}
+// ── Plugin registration ──────────────────────────────────────────────
+export default function steel(rl) {
+    rl.setName(NAME);
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        steelApiKey: {
+            type: "string",
+            required: true,
+            env: "STEEL_API_KEY",
+            description: "Steel.dev API key for the cloud browser. Store only in secrets.",
+        },
+        steelBaseUrl: {
+            type: "string",
+            required: false,
+            env: "STEEL_API_BASE",
+            default: DEFAULT_STEEL_BASE,
+            description: "Steel.dev API base URL.",
+        },
+        steelProxyUrl: {
+            type: "string",
+            required: false,
+            env: "STEEL_PROXY_URL",
+            description: "Residential proxy URL, used only when an action passes useProxy:true. Store only in secrets.",
+        },
+    });
+    rl.registerAction("browser.scrape", {
+        description: "Render a URL in a real Steel cloud browser (executes JavaScript, passes 'verify you're not a robot' walls) and return its content. Use this instead of plain fetch for JS-heavy or anti-bot pages. No proxy by default; set useProxy:true only for datacenter-IP-blocked surfaces.",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Absolute URL to render." },
+            format: { type: "string", required: false, default: "text", description: "text (visible innerText), html (rendered outerHTML), or links (anchor list)." },
+            waitMs: { type: "number", required: false, default: 9000, description: "How long to let the page render (ms, max 45000)." },
+            waitSelector: { type: "string", required: false, description: "Optional CSS selector to wait for before extracting." },
+            maxChars: { type: "number", required: false, default: 20000, description: "Cap on returned content length." },
+            useProxy: { type: "boolean", required: false, default: false, description: "Route through the residential proxy. Only needed for datacenter-blocked sites." },
+        },
+        async execute(input, ctx) {
+            const cfg = getConnectionConfig(ctx);
+            const url = compactText(input.url);
+            if (!/^https?:\/\//i.test(url))
+                throw new Error("url must be an absolute http(s) URL");
+            const format = compactText(input.format || "text").toLowerCase();
+            const maxChars = Number(input.maxChars) > 0 ? Math.min(Number(input.maxChars), 200000) : 20000;
+            return withRenderedPage(cfg, { url, useProxy: input.useProxy === true, waitMs: clampWait(input.waitMs), waitSelector: input.waitSelector }, async (page, meta) => {
+                const title = await page.eval("document.title");
+                const finalUrl = await page.eval("location.href");
+                const robotWall = await page.eval(robotWallExpr());
+                let content;
+                if (format === "html")
+                    content = await page.eval("document.documentElement.outerHTML");
+                else if (format === "links")
+                    content = JSON.stringify(await page.eval(`Array.from(document.querySelectorAll('a[href]')).slice(0,300).map(function(a){return {text:(a.innerText||'').replace(/\\s+/g,' ').trim().slice(0,80), href:a.href};})`));
+                else
+                    content = await page.eval("document.body && document.body.innerText || ''");
+                return {
+                    url,
+                    finalUrl,
+                    title,
+                    robotWall,
+                    format,
+                    truncated: String(content).length > maxChars,
+                    content: String(content).slice(0, maxChars),
+                    viewerUrl: meta.viewer,
+                    source: "steel.browser.scrape",
+                };
+            });
+        },
+    });
+    rl.registerAction("browser.extract", {
+        description: "Render a URL in a Steel browser and extract structured data via a map of CSS selectors. Returns the first match (or all matches with all:true) of each selector as text.",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Absolute URL to render." },
+            selectors: { type: "object", required: true, description: "Map of { fieldName: cssSelector }." },
+            all: { type: "boolean", required: false, default: false, description: "Return all matches per selector instead of the first." },
+            waitMs: { type: "number", required: false, default: 9000, description: "Render wait (ms)." },
+            waitSelector: { type: "string", required: false, description: "Optional CSS selector to wait for." },
+            useProxy: { type: "boolean", required: false, default: false, description: "Route through the residential proxy." },
+        },
+        async execute(input, ctx) {
+            const cfg = getConnectionConfig(ctx);
+            const url = compactText(input.url);
+            if (!/^https?:\/\//i.test(url))
+                throw new Error("url must be an absolute http(s) URL");
+            const selectors = input.selectors && typeof input.selectors === "object" ? input.selectors : null;
+            if (!selectors || !Object.keys(selectors).length)
+                throw new Error("selectors must be a non-empty object of { name: cssSelector }");
+            const all = input.all === true;
+            return withRenderedPage(cfg, { url, useProxy: input.useProxy === true, waitMs: clampWait(input.waitMs), waitSelector: input.waitSelector }, async (page, meta) => {
+                const expr = `
+            (function(){
+              var sels = ${JSON.stringify(selectors)};
+              var all = ${all};
+              function txt(el){ return el ? (el.innerText||el.textContent||'').replace(/\\s+/g,' ').trim() : null; }
+              var out = {};
+              for (var k in sels){
+                if (all){ out[k] = Array.from(document.querySelectorAll(sels[k])).slice(0,50).map(txt); }
+                else { out[k] = txt(document.querySelector(sels[k])); }
+              }
+              return out;
+            })()`;
+                return {
+                    url,
+                    finalUrl: await page.eval("location.href"),
+                    title: await page.eval("document.title"),
+                    robotWall: await page.eval(robotWallExpr()),
+                    data: await page.eval(expr),
+                    viewerUrl: meta.viewer,
+                    source: "steel.browser.extract",
+                };
+            });
+        },
+    });
+    rl.registerAction("browser.screenshot", {
+        description: "Capture a screenshot of a URL with the Steel cloud browser and return imageUrl — a PUBLIC, login-free PNG link (https://images.steel.dev/...). To 'send a screenshot', put imageUrl in your reply: WhatsApp/Slack render it inline and anyone can open it without a Steel account. base64 is opt-in and usually pointless (the agent runtime strips large base64 from action results), so prefer imageUrl.",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Absolute URL to capture." },
+            fullPage: { type: "boolean", required: false, default: false, description: "Capture the full scrollable page." },
+            waitMs: { type: "number", required: false, default: 0, description: "Milliseconds to wait before capturing (for JS-heavy pages). 0 = capture as soon as loaded." },
+            useProxy: { type: "boolean", required: false, default: false, description: "Route through the BYO residential proxy (STEEL_PROXY_URL). Only for datacenter-IP-blocked surfaces." },
+            includeBase64: { type: "boolean", required: false, default: false, description: "Also fetch the hosted image and return raw PNG base64. Off by default — share imageUrl instead." },
+        },
+        async execute(input, ctx) {
+            const cfg = getConnectionConfig(ctx);
+            const url = compactText(input.url);
+            if (!/^https?:\/\//i.test(url))
+                throw new Error("url must be an absolute http(s) URL");
+            const steel = new SteelClient(cfg);
+            const imageUrl = await steel.hostedScreenshot({
+                url,
+                fullPage: input.fullPage === true,
+                delay: clampWait(input.waitMs, 0, 30000) || undefined,
+                useProxy: input.useProxy === true,
+            });
+            const out = {
+                url,
+                imageUrl,
+                mimeType: "image/png",
+                note: "Share imageUrl — it's a public, login-free screenshot link that renders inline in chat. Put it in your reply text; don't screenshot-to-base64.",
+                source: "steel.browser.screenshot",
+            };
+            if (input.includeBase64 === true && imageUrl) {
+                try {
+                    const resp = await fetch(imageUrl);
+                    const buf = Buffer.from(await resp.arrayBuffer());
+                    out.byteLength = buf.length;
+                    out.base64 = buf.toString("base64");
+                }
+                catch (e) {
+                    out.base64Error = String(e?.message || e);
+                }
+            }
+            return out;
+        },
+    });
+}

package/dist/plugins/together/src/index.js

@@ -12,6 +12,7 @@
  * fidelity switch to FLUX.1-dev / Ideogram / Qwen-Image and bump
  * `steps` accordingly (20–30 is typical for non-schnell models).
  */
+import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 import { parseSize } from "../../_shared/parseSize.js";
 const ENDPOINT = "https://api.together.xyz/v1/images/generations";
 export default function together(rl) {
@@ -26,13 +27,18 @@ export default function together(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with Together AI (Flux, Ideogram, Qwen-Image, …). Returns base64-encoded PNGs.",
+        description: "Generate an image with Together AI (Flux, Ideogram, Qwen-Image, …). Writes the image(s) to disk and returns their file `path`s — not base64. Deliver each with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
                 required: true,
                 description: "Detailed description of the image",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
             model: {
                 type: "string",
                 required: false,
@@ -83,11 +89,9 @@ export default function together(rl) {
                 throw new Error(`Together API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
-            const images = (data.data ?? []).map((d) => ({
-                base64: d.b64_json,
-                mimeType: "image/png",
-            }));
-            return { provider: "together", model, images };
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => writeImageFile({ base64: d.b64_json, mimeType: "image/png", provider: "together", index: i, saveDir: p.saveDir, stamp }));
+            return { provider: "together", model, images, note: SEND_FILE_NOTE };
         },
     });
 }

package/dist/plugins/xai/src/index.js

@@ -8,6 +8,7 @@
  * text rendering well. Sized via aspect_ratio rather than W×H —
  * the API does the math.
  */
+import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 const ENDPOINT = "https://api.x.ai/v1/images/generations";
 const MODEL = "grok-imagine-image";
 export default function xai(rl) {
@@ -22,13 +23,18 @@ export default function xai(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with xAI Grok Imagine (Aurora). Returns base64-encoded JPEGs and any revised prompt the model produced.",
+        description: "Generate an image with xAI Grok Imagine (Aurora). Writes the JPEG(s) to disk and returns their file `path`s (plus any revised prompt) — not base64. Deliver each with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
                 required: true,
                 description: "Detailed description of the image",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
             aspectRatio: {
                 type: "string",
                 required: false,
@@ -66,12 +72,12 @@ export default function xai(rl) {
                 throw new Error(`xAI API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
-            const images = (data.data ?? []).map((d) => ({
-                base64: d.b64_json,
-                mimeType: "image/jpeg",
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => ({
+                ...writeImageFile({ base64: d.b64_json, mimeType: "image/jpeg", provider: "xai", index: i, saveDir: p.saveDir, stamp }),
                 ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
             }));
-            return { provider: "xai", model: MODEL, images };
+            return { provider: "xai", model: MODEL, images, note: SEND_FILE_NOTE };
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.7.7",
+  "version": "0.8.0",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",