micro-models-agent 0.57.0 → 0.57.1

package/dist/modules/browser/driver.js

@@ -0,0 +1,136 @@
+import { chromium } from "playwright";
+import { ConsoleBuffer } from "./session";
+export const DIRECT_LAUNCH_TIMEOUT_MS = 8000;
+export class PlaywrightDriver {
+    browser = null;
+    context = null;
+    page = null;
+    console = new ConsoleBuffer();
+    network = [];
+    async launch(cfg) {
+        if (this.browser)
+            return;
+        this.browser = await chromium.launch({
+            headless: cfg.headless,
+            timeout: cfg.timeoutMs,
+        });
+        this.context = await this.browser.newContext({ viewport: cfg.viewport });
+        this.page = await this.context.newPage();
+        this.page.setDefaultTimeout(cfg.timeoutMs);
+        this.page.on("console", (msg) => this.console.add(msg.type(), msg.text()));
+        this.page.on("pageerror", (err) => this.console.add("pageerror", `Page error: ${err.message}`));
+        this.page.on("requestfailed", (req) => {
+            const failure = req.failure();
+            this.network.push({
+                method: req.method(),
+                url: req.url(),
+                error: failure?.errorText || "unknown",
+            });
+        });
+    }
+    async goto(url, timeoutMs) {
+        this.requirePage();
+        this.console.clear();
+        this.network = [];
+        await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+    }
+    async evaluate(js) {
+        return this.requirePage().evaluate(js);
+    }
+    async content() {
+        return this.requirePage().content();
+    }
+    async title() {
+        return this.requirePage().title();
+    }
+    url() {
+        return this.page?.url() || "";
+    }
+    async waitForLoad(timeoutMs) {
+        await this.requirePage()
+            .waitForLoadState("domcontentloaded", { timeout: timeoutMs })
+            .catch(() => { });
+    }
+    async screenshot() {
+        return this.requirePage().screenshot({ type: "png", fullPage: false });
+    }
+    async cookies() {
+        if (!this.context)
+            return [];
+        return this.context.cookies();
+    }
+    async addCookies(cookies) {
+        if (!this.context || cookies.length === 0)
+            return;
+        await this.context.addCookies(cookies);
+    }
+    async goBack(timeoutMs) {
+        await this.requirePage()
+            .goBack({ waitUntil: "domcontentloaded", timeout: timeoutMs })
+            .catch(() => { });
+    }
+    async goForward(timeoutMs) {
+        await this.requirePage()
+            .goForward({ waitUntil: "domcontentloaded", timeout: timeoutMs })
+            .catch(() => { });
+    }
+    resetEventLog() {
+        this.console.clear();
+        this.network = [];
+    }
+    getConsole() {
+        return this.console.getAll();
+    }
+    getNetworkErrors() {
+        return this.network.slice(-15);
+    }
+    async close() {
+        if (this.page)
+            await this.page.close().catch(() => { });
+        if (this.context)
+            await this.context.close().catch(() => { });
+        if (this.browser)
+            await this.browser.close().catch(() => { });
+        this.page = null;
+        this.context = null;
+        this.browser = null;
+    }
+    dispose() {
+        this.close().catch(() => { });
+    }
+    requirePage() {
+        if (!this.page)
+            throw new Error("No page open");
+        return this.page;
+    }
+}
+export function createBrowserDriver(config) {
+    const common = {
+        headless: config.headless,
+        viewport: { width: config.viewportWidth, height: config.viewportHeight },
+        timeoutMs: config.navigationTimeout,
+    };
+    return (async () => {
+        // Playwright's pipe/websocket transport is broken under Bun on some
+        // platforms (see oven-sh/bun#31105, #9911). Under Bun we always use the
+        // Node bridge. Under Node we try the direct path first.
+        if (process.versions.bun) {
+            return launchBridge(config, common);
+        }
+        const direct = new PlaywrightDriver();
+        try {
+            await direct.launch({ ...common, timeoutMs: DIRECT_LAUNCH_TIMEOUT_MS });
+            return direct;
+        }
+        catch {
+            direct.dispose();
+        }
+        return launchBridge(config, common);
+    })();
+}
+async function launchBridge(config, common) {
+    const { BridgeDriver } = await import("./bridge-client");
+    const bridge = new BridgeDriver({ maxConsoleLineChars: config.maxConsoleLineChars });
+    await bridge.launch(common);
+    return bridge;
+}

package/dist/modules/browser/index.js

@@ -0,0 +1,7 @@
+export { BrowserModule } from "./module";
+export { BrowserSession, BrowserActionTracker, ConsoleBuffer } from "./session";
+export { CookieStore } from "./cookie-store";
+export { createBrowserDriver, PlaywrightDriver } from "./driver";
+export { BridgeDriver } from "./bridge-client";
+export { extractInteractiveElements, formatSnapshot, truncateText } from "./snapshot";
+export { DEFAULT_BROWSER_CONFIG } from "./types";

package/dist/modules/browser/module.js

@@ -0,0 +1,29 @@
+import { createBrowserTool, closeBrowserSession } from "../../tools/browser";
+export class BrowserModule {
+    name = "browser";
+    getSystemPromptBlock() {
+        return {
+            content: [
+                "You have a headless browser tool. Use it to navigate websites, click links, fill forms, and read page content.",
+                "Workflow: open(url) → read snapshot → click/type on element numbers → read updated snapshot.",
+                'Each snapshot includes a "Content" section with the visible page text, a "Console" section with browser messages, and network errors. Use these to understand the page, detect JS errors, and verify the result of your actions.',
+                'Always start with "open" action. Use element numbers from snapshot for click/type targets.',
+                'Use "screenshot" action only if the model supports vision. Otherwise rely on the text snapshot.',
+            ].join("\n"),
+            priority: "normal",
+            essential: false,
+            estimatedTokens: 80,
+        };
+    }
+    getToolDefinitions() {
+        return [createBrowserTool()];
+    }
+    getPlugin() {
+        return {
+            name: "browser",
+            onSessionEnd: () => {
+                closeBrowserSession();
+            },
+        };
+    }
+}

package/dist/modules/browser/session.js

@@ -0,0 +1,342 @@
+import { createBrowserDriver } from "./driver";
+import { extractInteractiveElements, formatSnapshot } from "./snapshot";
+import { buildClickScript, buildTypeScript, buildScrollScript, buildIndexInjectionScript, buildTextExtractionScript, } from "./actions";
+import { CookieStore } from "./cookie-store";
+import { t } from "../../i18n/index";
+const CONSOLE_MAX_LINE = 400;
+export class ConsoleBuffer {
+    entries = [];
+    maxEntries;
+    constructor(maxEntries = 20) {
+        this.maxEntries = maxEntries;
+    }
+    add(type, text) {
+        const clean = String(text).replace(/\s+/g, " ").trim();
+        if (!clean)
+            return;
+        const line = clean.length > CONSOLE_MAX_LINE ? clean.slice(0, CONSOLE_MAX_LINE) + "…" : clean;
+        this.entries.push({ type, text: line });
+        if (this.entries.length > this.maxEntries) {
+            this.entries.splice(0, this.entries.length - this.maxEntries);
+        }
+    }
+    clear() {
+        this.entries = [];
+    }
+    getAll() {
+        return [...this.entries];
+    }
+    get size() {
+        return this.entries.length;
+    }
+}
+export class BrowserActionTracker {
+    history = [];
+    threshold;
+    constructor(threshold = 3) {
+        this.threshold = threshold;
+    }
+    record(action, args, url) {
+        this.history.push({ action, args, url });
+        if (this.history.length < this.threshold)
+            return null;
+        const recent = this.history.slice(-this.threshold);
+        const allSame = recent.every((h) => h.action === recent[0].action &&
+            h.url === recent[0].url &&
+            JSON.stringify(h.args) === JSON.stringify(recent[0].args));
+        if (allSame) {
+            return t("browser.repeated_action", {
+                action,
+                threshold: this.threshold,
+            });
+        }
+        return null;
+    }
+    reset() {
+        this.history = [];
+    }
+}
+export class BrowserSession {
+    driver = null;
+    config;
+    cookieStore;
+    state = {
+        isOpen: false,
+        url: null,
+        title: null,
+        elementCount: 0,
+    };
+    actionTracker = new BrowserActionTracker(3);
+    constructor(config) {
+        this.config = config;
+        this.cookieStore = new CookieStore(config.cookieDir);
+    }
+    getState() {
+        return { ...this.state };
+    }
+    async execute(action, args) {
+        try {
+            let result;
+            switch (action) {
+                case "open":
+                    result = await this.open(String(args.url || ""));
+                    break;
+                case "click":
+                    result = await this.click(Number(args.target));
+                    break;
+                case "type":
+                    result = await this.type(Number(args.target), String(args.text || ""));
+                    break;
+                case "scroll":
+                    result = await this.scroll(String(args.direction || "down"));
+                    break;
+                case "back":
+                    result = await this.back();
+                    break;
+                case "forward":
+                    result = await this.forward();
+                    break;
+                case "screenshot":
+                    result = await this.screenshot();
+                    break;
+                case "snapshot":
+                    result = await this.snapshot();
+                    break;
+                case "close":
+                    result = await this.close();
+                    break;
+                case "wait":
+                    result = await this.wait(Number(args.ms || 1000));
+                    break;
+                default:
+                    return {
+                        success: false,
+                        output: t("browser.unknown_action", { action }),
+                    };
+            }
+            if (action !== "open") {
+                const warning = this.actionTracker.record(action, args, this.driver?.url() || "");
+                if (warning && result.success) {
+                    result.output = result.output + "\n\n⚠️ " + warning;
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("browser.error", { message: err.message }),
+            };
+        }
+    }
+    async ensureDriver() {
+        if (!this.driver) {
+            return { success: false, output: t("browser.no_page") };
+        }
+        return null;
+    }
+    async launch() {
+        if (this.driver)
+            return;
+        this.driver = await createBrowserDriver(this.config);
+        const savedCookies = await this.cookieStore.load();
+        if (savedCookies.length > 0) {
+            await this.driver.addCookies(savedCookies);
+        }
+    }
+    async saveCookies() {
+        if (!this.driver)
+            return;
+        const cookies = await this.driver.cookies();
+        await this.cookieStore.save(cookies);
+    }
+    async takeSnapshot() {
+        if (!this.driver)
+            return "No page open.";
+        await this.driver.evaluate(buildIndexInjectionScript());
+        const html = await this.driver.content();
+        const url = this.driver.url();
+        const title = await this.driver.title();
+        let content = "";
+        try {
+            content = String(await this.driver.evaluate(buildTextExtractionScript()));
+        }
+        catch {
+            content = "";
+        }
+        const allElements = extractInteractiveElements(html, this.config.maxElements + 5);
+        const truncated = allElements.length > this.config.maxElements;
+        const elements = allElements.slice(0, this.config.maxElements);
+        this.state = {
+            isOpen: true,
+            url,
+            title,
+            elementCount: elements.length,
+        };
+        return formatSnapshot({
+            url,
+            title,
+            elements,
+            content,
+            console: this.driver.getConsole(),
+            networkErrors: this.driver.getNetworkErrors(),
+            truncated,
+        });
+    }
+    async open(url) {
+        if (!url)
+            return { success: false, output: t("browser.url_required") };
+        // Security: block dangerous schemes (file:, chrome:, about:, data:).
+        if (/^(file|chrome|about|data|javascript|view-source):/i.test(url)) {
+            return { success: false, output: `[SECURITY BLOCKED] scheme not allowed: ${url}` };
+        }
+        if (!url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("file://")) {
+            const isLocalhost = /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?$/i.test(url);
+            url = isLocalhost ? "http://" + url : "https://" + url;
+        }
+        await this.launch();
+        if (!this.driver)
+            return { success: false, output: t("browser.create_page_failed") };
+        this.actionTracker.reset();
+        this.driver.resetEventLog();
+        try {
+            await this.driver.goto(url, this.config.navigationTimeout);
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("browser.nav_failed", { message: err.message }),
+            };
+        }
+        const snapshot = await this.takeSnapshot();
+        await this.saveCookies();
+        return { success: true, output: snapshot };
+    }
+    async click(target) {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        if (!target || target < 1) {
+            return { success: false, output: t("browser.invalid_target") };
+        }
+        try {
+            await this.driver.evaluate(buildClickScript(target));
+            await this.driver.waitForLoad(5000);
+            await new Promise((r) => setTimeout(r, 500));
+            const snapshot = await this.takeSnapshot();
+            await this.saveCookies();
+            return { success: true, output: snapshot };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("browser.click_failed", { message: err.message }),
+            };
+        }
+    }
+    async type(target, text) {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        if (!target || target < 1) {
+            return { success: false, output: t("browser.invalid_target_short") };
+        }
+        if (!text) {
+            return { success: false, output: t("browser.text_required") };
+        }
+        try {
+            await this.driver.evaluate(buildTypeScript(target, text));
+            const snapshot = await this.takeSnapshot();
+            return { success: true, output: snapshot };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("browser.type_failed", { message: err.message }),
+            };
+        }
+    }
+    async scroll(direction) {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        const dir = direction;
+        if (!["up", "down", "top", "bottom"].includes(dir)) {
+            return { success: false, output: t("browser.direction_invalid") };
+        }
+        try {
+            await this.driver.evaluate(buildScrollScript(dir));
+            await new Promise((r) => setTimeout(r, 300));
+            const snapshot = await this.takeSnapshot();
+            return { success: true, output: snapshot };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("browser.scroll_failed", { message: err.message }),
+            };
+        }
+    }
+    async back() {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        await this.driver.goBack(this.config.navigationTimeout);
+        await new Promise((r) => setTimeout(r, 300));
+        const snapshot = await this.takeSnapshot();
+        return { success: true, output: snapshot };
+    }
+    async forward() {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        await this.driver.goForward(this.config.navigationTimeout);
+        await new Promise((r) => setTimeout(r, 300));
+        const snapshot = await this.takeSnapshot();
+        return { success: true, output: snapshot };
+    }
+    async screenshot() {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        if (!this.driver)
+            return { success: false, output: "No page" };
+        const buffer = await this.driver.screenshot();
+        const snapshot = await this.takeSnapshot();
+        return { success: true, output: snapshot, screenshot: buffer };
+    }
+    async snapshot() {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        const snap = await this.takeSnapshot();
+        return { success: true, output: snap };
+    }
+    async wait(ms) {
+        const err = await this.ensureDriver();
+        if (err)
+            return err;
+        await new Promise((r) => setTimeout(r, Math.min(ms, 10000)));
+        const snapshot = await this.takeSnapshot();
+        return { success: true, output: snapshot };
+    }
+    async close() {
+        await this.saveCookies();
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
+        }
+        this.state = { isOpen: false, url: null, title: null, elementCount: 0 };
+        return { success: true, output: t("browser.closed") };
+    }
+}

package/dist/modules/browser/snapshot.js

@@ -0,0 +1,148 @@
+import { t } from "../../i18n/index";
+import { DEFAULT_BROWSER_CONFIG } from "./types";
+function inferRole(tag, type) {
+    const t = tag.toLowerCase();
+    if (t === "a")
+        return "link";
+    if (t === "button")
+        return "button";
+    if (t === "input") {
+        const inputType = type?.toLowerCase();
+        if (inputType === "submit" || inputType === "button")
+            return "button";
+        if (inputType === "checkbox")
+            return "checkbox";
+        if (inputType === "radio")
+            return "radio";
+        return "textbox";
+    }
+    if (t === "textarea")
+        return "textbox";
+    if (t === "select")
+        return "combobox";
+    return "widget";
+}
+function getName(tag, attrs, html, matchIndex) {
+    const fromAttr = attrs["aria-label"] ||
+        attrs["placeholder"] ||
+        attrs["title"] ||
+        attrs["alt"] ||
+        attrs["value"] ||
+        attrs["name"] ||
+        "";
+    if (fromAttr)
+        return fromAttr;
+    const afterTag = html.slice(matchIndex);
+    const closeIdx = afterTag.indexOf(">");
+    if (closeIdx === -1)
+        return "";
+    const afterOpen = afterTag.slice(closeIdx + 1);
+    const endTag = `</${tag}>`;
+    const endIdx = afterOpen.indexOf(endTag);
+    if (endIdx === -1)
+        return "";
+    const text = afterOpen
+        .slice(0, endIdx)
+        .replace(/<[^>]+>/g, "")
+        .trim();
+    return text.slice(0, 50);
+}
+export function extractInteractiveElements(html, maxElements = 30) {
+    const elements = [];
+    const tagRegex = /<(a|button|input|textarea|select|div|span)([^>]*)>/gi;
+    let match;
+    while ((match = tagRegex.exec(html)) !== null) {
+        if (elements.length >= maxElements)
+            break;
+        const tag = match[1].toLowerCase();
+        const attrStr = match[2];
+        const attrs = {};
+        const attrRegex = /(\w[\w-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+        let attrMatch;
+        while ((attrMatch = attrRegex.exec(attrStr)) !== null) {
+            attrs[attrMatch[1].toLowerCase()] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+        }
+        if (attrs["style"]?.includes("display:none") || attrs["style"]?.includes("display: none"))
+            continue;
+        if (attrs["hidden"] !== undefined)
+            continue;
+        if (attrs["aria-hidden"] === "true")
+            continue;
+        if (tag === "input" && attrs["type"] === "hidden")
+            continue;
+        const role = attrs["role"] || inferRole(tag, attrs["type"]);
+        const isInteractive = ["a", "button", "input", "textarea", "select"].includes(tag) || attrs["role"] !== undefined;
+        if (!isInteractive)
+            continue;
+        if (tag === "a" && !attrs["href"])
+            continue;
+        const name = getName(tag, attrs, html, match.index);
+        elements.push({
+            index: elements.length + 1,
+            tag,
+            role,
+            name,
+            value: attrs["value"],
+            href: attrs["href"],
+            visible: true,
+        });
+    }
+    return elements;
+}
+export function truncateText(text, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (text.length <= maxChars)
+        return text;
+    const cut = text.slice(0, maxChars);
+    const lastNewline = cut.lastIndexOf("\n");
+    const safe = lastNewline > maxChars * 0.6 ? cut.slice(0, lastNewline) : cut;
+    return `${safe}\n${t("browser.truncated")}`;
+}
+export function formatSnapshot(snapshot, maxContentChars = DEFAULT_BROWSER_CONFIG.maxContentChars) {
+    const lines = [];
+    lines.push(`Page: "${snapshot.title}"`);
+    lines.push(`URL: ${snapshot.url}`);
+    lines.push("");
+    if (snapshot.elements.length === 0 && !snapshot.truncated) {
+        lines.push(t("browser.no_elements"));
+    }
+    else {
+        for (const el of snapshot.elements) {
+            let line = `[${el.index}] ${el.role}`;
+            if (el.name)
+                line += ` "${el.name}"`;
+            if (el.href)
+                line += ` → ${el.href}`;
+            if (el.value)
+                line += ` = "${el.value}"`;
+            lines.push(line);
+        }
+        if (snapshot.truncated) {
+            lines.push("");
+            lines.push(t("browser.more_elements"));
+        }
+    }
+    if (snapshot.content) {
+        lines.push("");
+        lines.push(t("browser.content_header"));
+        for (const line of truncateText(snapshot.content, maxContentChars).split("\n")) {
+            lines.push(`- ${line}`);
+        }
+    }
+    if (snapshot.console.length > 0) {
+        lines.push("");
+        lines.push(t("browser.console_header"));
+        for (const entry of snapshot.console) {
+            lines.push(`[${entry.type}] ${entry.text}`);
+        }
+    }
+    if (snapshot.networkErrors.length > 0) {
+        lines.push("");
+        lines.push(t("browser.network_errors_header"));
+        for (const err of snapshot.networkErrors) {
+            lines.push(`${err.method} ${err.url} → ${err.error}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/modules/browser/types.js

@@ -0,0 +1,12 @@
+export const DEFAULT_BROWSER_CONFIG = {
+    headless: true,
+    maxElements: 30,
+    maxContentChars: 2500,
+    maxConsoleEntries: 40,
+    maxConsoleLineChars: 400,
+    screenshotMaxWidth: 1280,
+    cookieDir: "",
+    viewportWidth: 1280,
+    viewportHeight: 720,
+    navigationTimeout: 15000,
+};