runline 0.9.0 → 0.10.0

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

@@ -0,0 +1,175 @@
+import * as t from "typebox";
+import { SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+const SCRAPE_SCHEMA = {
+    url: t.String({ description: "URL to scrape" }),
+    format: t.Optional(t.Array(t.String(), { description: "Formats: html, cleaned_html, markdown, readability" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+    screenshot: t.Optional(t.Boolean({ description: "Also capture a screenshot URL" })),
+    pdf: t.Optional(t.Boolean({ description: "Also capture a PDF URL" })),
+};
+const SCREENSHOT_SCHEMA = {
+    url: t.String({ description: "URL to screenshot" }),
+    fullPage: t.Optional(t.Boolean({ description: "Capture full scrollable page" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+};
+async function scrape(input, ctx) {
+    return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(input) });
+}
+async function screenshot(input, ctx) {
+    return api(ctx, "/v1/screenshot", { method: "POST", body: compactRecord(input) });
+}
+async function connectMiniCdp(cdpUrl) {
+    const ws = new WebSocket(cdpUrl);
+    let nextId = 0;
+    const pending = new Map();
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("CDP websocket connection timed out")), 30000);
+        ws.addEventListener("open", () => { clearTimeout(timer); resolve(); }, { once: true });
+        ws.addEventListener("error", () => { clearTimeout(timer); reject(new Error("CDP websocket connection failed")); }, { once: true });
+    });
+    ws.addEventListener("message", (event) => {
+        let message;
+        try {
+            message = JSON.parse(String(event.data));
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const wait = pending.get(message.id);
+        if (!wait)
+            return;
+        pending.delete(message.id);
+        if (message.error)
+            wait.reject(new Error(JSON.stringify(message.error)));
+        else
+            wait.resolve(message.result);
+    });
+    const send = (method, params = {}, sessionId) => new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+        setTimeout(() => {
+            if (pending.delete(id))
+                reject(new Error(`CDP ${method} timed out`));
+        }, 30000);
+    });
+    const targets = await send("Target.getTargets");
+    const target = targets.targetInfos?.find((info) => info.type === "page") ?? targets.targetInfos?.[0];
+    if (!target)
+        throw new Error("Steel CDP session has no browser target");
+    const attached = await send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
+    const sid = attached.sessionId;
+    const evaluate = async (expression) => {
+        const result = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, sid);
+        return result.result?.value;
+    };
+    const page = {
+        async goto(url, _options) {
+            await send("Page.navigate", { url }, sid);
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            return null;
+        },
+        title: () => evaluate("document.title"),
+        url: () => evaluate("location.href"),
+        text: () => evaluate("document.body?.innerText ?? ''"),
+        html: () => evaluate("document.documentElement?.outerHTML ?? ''"),
+        evaluate: (expression) => evaluate(`(${expression})()`),
+    };
+    return { page, browser: { close: () => ws.close() }, context: {}, close: () => ws.close() };
+}
+export function registerBrowserActions(rl) {
+    rl.registerAction("scrape", {
+        description: "One-shot Steel scrape. Loads a URL and returns requested formats such as markdown, html, cleaned_html, or readability.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("browser.scrape", {
+        description: "Backward-compatible alias for scrape.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("screenshot", {
+        description: "One-shot Steel screenshot. Returns a hosted PNG URL.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.screenshot", {
+        description: "Backward-compatible alias for screenshot.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.extract", {
+        description: "Fetch a page through Steel scrape and return selected content fields. Use selectors with browser.run for DOM-specific extraction.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to scrape" }),
+            format: t.Optional(t.Array(t.String(), { description: "Formats to request; defaults to markdown and html" })),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            const body = { format: ["markdown", "html"], ...input };
+            return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(body) });
+        },
+    });
+    rl.registerAction("pdf", {
+        description: "One-shot Steel PDF capture. Returns a hosted PDF URL.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to render as PDF" }),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/pdf", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("browser.run", {
+        description: "Create a Steel session, connect with Playwright over CDP, run an async JavaScript script, then release by default. The script receives { page, browser, context, session }. Requires the host app to have playwright installed.",
+        inputSchema: t.Object({
+            script: t.String({ description: "Async JavaScript body. Example: await page.goto('https://example.com'); return { title: await page.title() };" }),
+            release: t.Optional(t.Boolean({ description: "Release the Steel session after the script finishes (default true)" })),
+            ...SESSION_OPTIONS_SCHEMA,
+        }),
+        async execute(input, ctx) {
+            const { script, release, ...sessionOptions } = input;
+            let playwright;
+            try {
+                playwright = await import("playwright");
+            }
+            catch (_error) {
+                throw new Error("steel.browser.run requires the host project to install playwright. Install playwright or use session.create + session.cdpUrl instead.");
+            }
+            const session = await api(ctx, "/v1/sessions", { method: "POST", body: compactRecord(sessionOptions) });
+            const cdpUrl = `wss://connect.steel.dev?apiKey=${encodeURIComponent(apiKey(ctx))}&sessionId=${encodeURIComponent(String(session.id))}`;
+            let browser;
+            try {
+                let context;
+                let page;
+                try {
+                    const playwrightBrowser = await playwright.chromium.connectOverCDP(cdpUrl, { timeout: 30000 });
+                    browser = playwrightBrowser;
+                    context = playwrightBrowser.contexts()[0] ?? await playwrightBrowser.newContext();
+                    page = context.pages()[0] ?? await context.newPage();
+                }
+                catch {
+                    const mini = await connectMiniCdp(cdpUrl);
+                    browser = mini.browser;
+                    context = mini.context;
+                    page = mini.page;
+                }
+                const fn = new Function("page", "browser", "context", "session", `return (async () => {\n${script}\n})();`);
+                const result = await fn(page, browser, context, session);
+                return { session, result };
+            }
+            finally {
+                await browser?.close()?.catch?.(() => { });
+                if (release !== false && session.id) {
+                    await api(ctx, `/v1/sessions/${encodeURIComponent(String(session.id))}/release`, { method: "POST" }).catch(() => { });
+                }
+            }
+        },
+    });
+}

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

@@ -0,0 +1,19 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+export function registerCaptchaActions(rl) {
+    rl.registerAction("captcha.status", {
+        description: "Get CAPTCHA detection/solving status for a Steel session.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) { return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/captchas/status`); },
+    });
+    rl.registerAction("captcha.solve", {
+        description: "Trigger CAPTCHA solving for all detected CAPTCHAs or a specific task/url/page.",
+        inputSchema: t.Object({ sessionId: t.String(), taskId: t.Optional(t.String()), url: t.Optional(t.String()), pageId: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve`, { method: "POST", body: compactRecord(body) }); },
+    });
+    rl.registerAction("captcha.solveImage", {
+        description: "Solve an image CAPTCHA by XPath selectors.",
+        inputSchema: t.Object({ sessionId: t.String(), imageXPath: t.String(), inputXPath: t.String(), url: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve-image`, { method: "POST", body: compactRecord(body) }); },
+    });
+}

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

@@ -0,0 +1,38 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+const CREDENTIAL_KEY_SCHEMA = {
+    origin: t.String({ description: "Credential origin" }),
+    namespace: t.Optional(t.String({ description: "Credential namespace (defaults to Steel default)" })),
+};
+export function registerCredentialActions(rl) {
+    rl.registerAction("credential.list", {
+        description: "List Steel credentials. Filter by origin and/or namespace.",
+        inputSchema: t.Object({ namespace: t.Optional(t.String()), origin: t.Optional(t.String()) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { query: input });
+        },
+    });
+    rl.registerAction("credential.create", {
+        description: "Create a Steel credential for an origin/namespace. Value may include username, password, and totpSecret.",
+        inputSchema: t.Object({ ...CREDENTIAL_KEY_SCHEMA, value: t.Any({ description: "Credential payload" }) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("credential.get", {
+        description: "Retrieve credential metadata by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            const result = await api(ctx, "/v1/credentials", { query: compactRecord(input) });
+            const credentials = result.credentials;
+            return Array.isArray(credentials) ? (credentials[0] ?? null) : null;
+        },
+    });
+    rl.registerAction("credential.delete", {
+        description: "Delete a Steel credential by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "DELETE", body: compactRecord(input) });
+        },
+    });
+}

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

@@ -0,0 +1,46 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function extensionForm(input) {
+    const form = new FormData();
+    if (input.url !== undefined && input.url !== null)
+        form.set("url", String(input.url));
+    return form;
+}
+export function registerExtensionActions(rl) {
+    rl.registerAction("extension.list", {
+        description: "List Steel Chrome extensions installed for the organization.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions");
+        },
+    });
+    rl.registerAction("extension.upload", {
+        description: "Upload an extension from a Chrome Web Store URL. Raw zip/crx uploads should use the API directly.",
+        inputSchema: t.Object({ url: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "POST", body: extensionForm(input) });
+        },
+    });
+    rl.registerAction("extension.update", {
+        description: "Update an extension from a Chrome Web Store URL.",
+        inputSchema: t.Object({ id: t.String(), url: t.String() }),
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(ctx, `/v1/extensions/${encodeURIComponent(String(id))}`, { method: "PUT", body: extensionForm(body) });
+        },
+    });
+    rl.registerAction("extension.delete", {
+        description: "Delete an extension by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/extensions/${encodeURIComponent(input.id)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("extension.deleteAll", {
+        description: "Delete all organization extensions.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "DELETE" });
+        },
+    });
+}

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

@@ -0,0 +1,96 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function fileSchema() {
+    return {
+        file: t.String({ description: "Global/session file path or absolute URL. Raw local file upload is not supported through Runline JSON actions." }),
+        path: t.Optional(t.String({ description: "Destination path" })),
+    };
+}
+function fileForm(input) {
+    const form = new FormData();
+    form.set("file", String(input.file));
+    if (input.path !== undefined && input.path !== null && input.path !== "")
+        form.set("path", String(input.path));
+    return form;
+}
+function normalizeFilePath(path) {
+    return String(path).replace(/^\/files\/+/, "").replace(/^\/+/, "");
+}
+function encodeFilePath(path) {
+    return normalizeFilePath(path).split("/").map(encodeURIComponent).join("/");
+}
+export function registerFileActions(rl) {
+    rl.registerAction("file.list", {
+        description: "List global Steel files.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/files");
+        },
+    });
+    rl.registerAction("file.upload", {
+        description: "Upload a global file from a URL or existing path reference.",
+        inputSchema: t.Object(fileSchema()),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/files", { method: "POST", body: fileForm(input) });
+        },
+    });
+    rl.registerAction("file.download", {
+        description: "Download/read a global file by path. Binary files are returned as text by fetch when possible; use the URL/API directly for raw bytes.",
+        inputSchema: t.Object({ path: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/files/${encodeFilePath(input.path)}`);
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a global Steel file by path.",
+        inputSchema: t.Object({ path: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/files/${encodeFilePath(input.path)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("sessionFile.list", {
+        description: "List files in a Steel session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files`);
+        },
+    });
+    rl.registerAction("sessionFile.upload", {
+        description: "Upload/copy a URL or global file into a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String(), ...fileSchema() }),
+        async execute(input, ctx) {
+            const { sessionId, ...body } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files`, { method: "POST", body: fileForm(body) });
+        },
+    });
+    rl.registerAction("sessionFile.download", {
+        description: "Download/read a session file by path.",
+        inputSchema: t.Object({ sessionId: t.String(), path: t.String() }),
+        async execute(input, ctx) {
+            const { sessionId, path } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files/${encodeFilePath(path)}`);
+        },
+    });
+    rl.registerAction("sessionFile.downloadArchive", {
+        description: "Download/read the zip archive of all files in a session.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files.zip`);
+        },
+    });
+    rl.registerAction("sessionFile.delete", {
+        description: "Delete a file from a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String(), path: t.String() }),
+        async execute(input, ctx) {
+            const { sessionId, path } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/files/${encodeFilePath(path)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("sessionFile.deleteAll", {
+        description: "Delete all files in a session filesystem.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/files`, { method: "DELETE" });
+        },
+    });
+}

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

@@ -1,378 +1,25 @@
-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 ──────────────────────────────────────────────
+import * as t from "typebox";
+import { registerBrowserActions } from "./browser.js";
+import { registerCaptchaActions } from "./captchas.js";
+import { registerCredentialActions } from "./credentials.js";
+import { registerExtensionActions } from "./extensions.js";
+import { registerFileActions } from "./files.js";
+import { registerProfileActions } from "./profiles.js";
+import { registerSessionActions } from "./sessions.js";
 export default function steel(rl) {
-    rl.setName(NAME);
+    rl.setName("steel");
     rl.setVersion("0.1.0");
-    rl.setConnectionSchema({
-        steelApiKey: {
-            type: "string",
-            required: true,
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Steel API key (https://app.steel.dev/settings/api-keys)",
             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;
-        },
-    });
+        }),
+    }));
+    registerSessionActions(rl);
+    registerBrowserActions(rl);
+    registerFileActions(rl);
+    registerCredentialActions(rl);
+    registerProfileActions(rl);
+    registerExtensionActions(rl);
+    registerCaptchaActions(rl);
 }

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

@@ -0,0 +1,55 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function profileForm(input) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        form.set(key, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    return form;
+}
+export function registerProfileActions(rl) {
+    rl.registerAction("profile.list", {
+        description: "List Steel browser profiles.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/profiles");
+        },
+    });
+    rl.registerAction("profile.get", {
+        description: "Get a Steel profile by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/profiles/${encodeURIComponent(input.id)}`);
+        },
+    });
+    rl.registerAction("profile.create", {
+        description: "Create an empty persisted Steel profile by opening and releasing a short-lived session with persistProfile=true. For userDataDir archive imports, use the Steel API directly.",
+        inputSchema: t.Object({
+            timeout: t.Optional(t.Number({ description: "Temporary session timeout in milliseconds" })),
+            inactivityTimeout: t.Optional(t.Number({ description: "Temporary session inactivity timeout in milliseconds" })),
+        }),
+        async execute(input, ctx) {
+            const session = await api(ctx, "/v1/sessions", {
+                method: "POST",
+                body: { timeout: 60000, inactivityTimeout: 30000, ...input, persistProfile: true },
+            });
+            try {
+                await api(ctx, `/v1/sessions/${encodeURIComponent(String(session.id))}/release`, { method: "POST" });
+            }
+            catch {
+                // Profile creation is tied to session release. Return the session metadata even if release cleanup fails.
+            }
+            return { profileId: session.profileId, session };
+        },
+    });
+    rl.registerAction("profile.update", {
+        description: "Update profile metadata/settings used by later sessions.",
+        inputSchema: t.Object({ id: t.String(), userAgent: t.Optional(t.String()), proxy: t.Optional(t.Any()), metadata: t.Optional(t.Any()) }),
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(ctx, `/v1/profiles/${encodeURIComponent(String(id))}`, { method: "PATCH", body: profileForm(body) });
+        },
+    });
+}

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

@@ -0,0 +1,119 @@
+import * as t from "typebox";
+import { LIST_INPUT_SCHEMA, SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+export function registerSessionActions(rl) {
+    rl.registerAction("session.create", {
+        description: "Create a Steel browser session. Returns session id, websocketUrl/CDP URL, debug/viewer URLs, and profile metadata when present.",
+        inputSchema: t.Object(SESSION_OPTIONS_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/sessions", { method: "POST", body: compactRecord((input ?? {})) });
+        },
+    });
+    rl.registerAction("session.list", {
+        description: "List Steel sessions.",
+        inputSchema: t.Object(LIST_INPUT_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/sessions", { query: (input ?? {}) });
+        },
+    });
+    rl.registerAction("session.get", {
+        description: "Get a Steel session by ID.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }) }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.id)}`);
+        },
+    });
+    rl.registerAction("session.release", {
+        description: "Release a Steel session when work is done.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }) }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.id)}/release`, { method: "POST" });
+        },
+    });
+    rl.registerAction("session.releaseAll", {
+        description: "Release all live Steel sessions for the organization by listing sessions and releasing each live session individually.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            const listed = await api(ctx, "/v1/sessions");
+            const sessions = Array.isArray(listed.sessions) ? listed.sessions : [];
+            const live = sessions.filter((session) => session.status === "live" || session.status === "LIVE");
+            const released = [];
+            const failed = [];
+            for (const session of live) {
+                const id = String(session.id);
+                try {
+                    released.push({ id, result: await api(ctx, `/v1/sessions/${encodeURIComponent(id)}/release`, { method: "POST" }) });
+                }
+                catch (error) {
+                    failed.push({ id, error: String(error.message ?? error) });
+                }
+            }
+            return { released, failed, count: released.length };
+        },
+    });
+    rl.registerAction("session.context", {
+        description: "Capture cookies/localStorage context from a live session. Treat output as sensitive auth material.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }) }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.id)}/context`);
+        },
+    });
+    rl.registerAction("session.traces", {
+        description: "Fetch the Agent Traces timeline for a Steel session. Supports optional ISO startTime/endTime filters.",
+        inputSchema: t.Object({
+            id: t.String({ description: "Session ID" }),
+            startTime: t.Optional(t.String({ description: "ISO timestamp lower bound" })),
+            endTime: t.Optional(t.String({ description: "ISO timestamp upper bound" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...query } = input;
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(id))}/agent-traces`, { query });
+        },
+    });
+    rl.registerAction("session.computer", {
+        description: "Execute a Steel computer-use action against a live session. Useful for model-native computer-use loops; pass actions such as take_screenshot, click_mouse, type_text, press_key, scroll, or drag_mouse.",
+        inputSchema: t.Object({
+            id: t.String({ description: "Session ID" }),
+            action: t.String({ description: "Steel computer action, e.g. take_screenshot, click_mouse, type_text, press_key, scroll, drag_mouse" }),
+            button: t.Optional(t.String({ description: "Mouse button for click actions" })),
+            coordinates: t.Optional(t.Array(t.Number(), { description: "[x, y] pixel coordinates" })),
+            text: t.Optional(t.String({ description: "Text for type_text or key for press_key" })),
+            keys: t.Optional(t.Array(t.String(), { description: "Keys for keyboard actions when supported" })),
+            deltaX: t.Optional(t.Number({ description: "Horizontal scroll delta" })),
+            deltaY: t.Optional(t.Number({ description: "Vertical scroll delta" })),
+            path: t.Optional(t.Array(t.Any(), { description: "Drag path points when supported" })),
+            screenshot: t.Optional(t.Boolean({ description: "Return a screenshot after the action" })),
+        }),
+        async execute(input, ctx) {
+            const { id, deltaX, deltaY, ...body } = input;
+            const payload = compactRecord({ ...body, delta_x: deltaX, delta_y: deltaY });
+            return api(ctx, `/v1/sessions/${encodeURIComponent(String(id))}/computer`, { method: "POST", body: payload });
+        },
+    });
+    rl.registerAction("session.events", {
+        description: "Fetch legacy recorded session events for replay tooling.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }) }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.id)}/events`);
+        },
+    });
+    rl.registerAction("session.hls", {
+        description: "Fetch the HLS playlist for a recorded headful Steel session.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }) }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/sessions/${encodeURIComponent(input.id)}/hls`);
+        },
+    });
+    rl.registerAction("session.cdpUrl", {
+        description: "Build a Playwright/Puppeteer CDP URL for a Steel session using the configured API key.",
+        inputSchema: t.Object({ id: t.String({ description: "Session ID" }), websocketUrl: t.Optional(t.String({ description: "Optional websocketUrl returned by session.create. If omitted, uses wss://connect.steel.dev with sessionId." })) }),
+        async execute(input, ctx) {
+            const { id, websocketUrl } = input;
+            const key = encodeURIComponent(apiKey(ctx));
+            if (websocketUrl) {
+                const sep = websocketUrl.includes("?") ? "&" : "?";
+                return { cdpUrl: `${websocketUrl}${sep}apiKey=${key}` };
+            }
+            return { cdpUrl: `wss://connect.steel.dev?apiKey=${key}&sessionId=${encodeURIComponent(id)}` };
+        },
+    });
+}

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

@@ -0,0 +1,72 @@
+import * as t from "typebox";
+const BASE_URL = "https://api.steel.dev";
+export function apiKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export async function api(ctx, path, options = {}) {
+    const url = new URL(path, BASE_URL);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const headers = {
+        "steel-api-key": apiKey(ctx),
+        ...(options.headers ?? {}),
+    };
+    let body;
+    if (options.body !== undefined) {
+        if (options.body instanceof FormData) {
+            body = options.body;
+        }
+        else {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(options.body);
+        }
+    }
+    const res = await fetch(url.toString(), {
+        method: options.method ?? "GET",
+        headers,
+        body,
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`Steel API error ${res.status}: ${text || res.statusText}`);
+    if (!text)
+        return {};
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json") || text.startsWith("{") || text.startsWith("["))
+        return JSON.parse(text);
+    return text;
+}
+export function compactRecord(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null));
+}
+export const LIST_INPUT_SCHEMA = {
+    limit: t.Optional(t.Number({ description: "Maximum number of results when supported" })),
+    cursor: t.Optional(t.String({ description: "Pagination cursor when supported" })),
+};
+export const SESSION_OPTIONS_SCHEMA = {
+    timeout: t.Optional(t.Number({ description: "Session hard timeout in milliseconds" })),
+    inactivityTimeout: t.Optional(t.Number({ description: "Release after this many milliseconds of inactivity" })),
+    useProxy: t.Optional(t.Any({ description: "true for Steel managed proxy, or proxy config object" })),
+    solveCaptcha: t.Optional(t.Boolean({ description: "Enable CAPTCHA detection/solving" })),
+    region: t.Optional(t.String({ description: "Steel region, e.g. lax or iad" })),
+    namespace: t.Optional(t.String({ description: "Credential namespace to use for this session" })),
+    userAgent: t.Optional(t.String({ description: "Custom browser user agent" })),
+    dimensions: t.Optional(t.Any({ description: "Viewport dimensions, e.g. { width: 1280, height: 768 }" })),
+    stealthConfig: t.Optional(t.Any({ description: "Steel stealth configuration, e.g. { autoCaptchaSolving: false }" })),
+    deviceConfig: t.Optional(t.Any({ description: "Device config, e.g. { device: 'mobile' }" })),
+    profileId: t.Optional(t.String({ description: "Profile ID to load" })),
+    persistProfile: t.Optional(t.Boolean({ description: "Persist profile changes on release" })),
+    credentials: t.Optional(t.Any({ description: "Credentials injection options, or {} to enable defaults" })),
+    extensionIds: t.Optional(t.Array(t.String(), { description: "Extension IDs to attach, or ['all_ext']" })),
+    sessionContext: t.Optional(t.Any({ description: "Captured session context to restore" })),
+    isSelenium: t.Optional(t.Boolean({ description: "Provision a Selenium-compatible session" })),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -62,6 +62,14 @@
     "minisearch": "^7.2.0",
     "typescript": "^5.8.0"
   },
+  "peerDependencies": {
+    "playwright": "^1.57.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",