micro-models-agent 0.43.3 → 0.45.0

package/dist/modules/browser/actions.js

@@ -1,46 +0,0 @@
-export function buildClickScript(elementIndex) {
-    return `
-    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
-    if (!el) throw new Error('Element not found: ${elementIndex}');
-    el.click();
-  `;
-}
-export function buildTypeScript(elementIndex, text) {
-    const escaped = JSON.stringify(text);
-    return `
-    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
-    if (!el) throw new Error('Element not found: ${elementIndex}');
-    const text = JSON.parse(${JSON.stringify(escaped)});
-    el.focus();
-    el.value = text;
-    el.dispatchEvent(new Event('input', { bubbles: true }));
-    el.dispatchEvent(new Event('change', { bubbles: true }));
-  `;
-}
-export function buildScrollScript(direction) {
-    switch (direction) {
-        case 'down':
-            return `window.scrollBy({ top: 600, behavior: 'smooth' })`;
-        case 'up':
-            return `window.scrollBy({ top: -600, behavior: 'smooth' })`;
-        case 'top':
-            return `window.scrollTo({ top: 0, behavior: 'smooth' })`;
-        case 'bottom':
-            return `window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' })`;
-    }
-}
-export function buildWaitScript(timeoutMs) {
-    return `await new Promise(r => setTimeout(r, ${timeoutMs}))`;
-}
-export function buildIndexInjectionScript() {
-    return `
-    const selectors = 'a[href], button, input, textarea, select, [role="button"], [role="link"], [role="textbox"], [role="checkbox"], [role="radio"], [contenteditable="true"]';
-    const elements = document.querySelectorAll(selectors);
-    let idx = 1;
-    elements.forEach(el => {
-      const style = window.getComputedStyle(el);
-      if (style.display === 'none' || style.visibility === 'hidden') return;
-      el.setAttribute('data-browser-index', String(idx++));
-    });
-  `;
-}

package/dist/modules/browser/cookie-store.js

@@ -1,24 +0,0 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { join } from 'path';
-export class CookieStore {
-    filePath;
-    constructor(cookieDir) {
-        this.filePath = join(cookieDir, 'cookies.json');
-    }
-    async save(cookies) {
-        await mkdir(join(this.filePath, '..'), { recursive: true });
-        await writeFile(this.filePath, JSON.stringify(cookies, null, 2), 'utf-8');
-    }
-    async load() {
-        try {
-            const data = await readFile(this.filePath, 'utf-8');
-            return JSON.parse(data);
-        }
-        catch {
-            return [];
-        }
-    }
-    async clear() {
-        await this.save([]);
-    }
-}

package/dist/modules/browser/index.js

@@ -1,5 +0,0 @@
-export { BrowserModule } from './module';
-export { BrowserSession, BrowserActionTracker } from './session';
-export { CookieStore } from './cookie-store';
-export { extractInteractiveElements, formatSnapshot } from './snapshot';
-export { DEFAULT_BROWSER_CONFIG } from './types';

package/dist/modules/browser/module.js

@@ -1,28 +0,0 @@
-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.',
-                '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

@@ -1,335 +0,0 @@
-import { chromium, } from "playwright";
-import { extractInteractiveElements, formatSnapshot } from "./snapshot";
-import { buildClickScript, buildTypeScript, buildScrollScript, buildIndexInjectionScript, } from "./actions";
-import { CookieStore } from "./cookie-store";
-import { t } from "../../i18n/index";
-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 {
-    browser = null;
-    context = null;
-    page = 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.page?.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 ensurePage() {
-        if (!this.page) {
-            return { success: false, output: t("browser.no_page") };
-        }
-        return null;
-    }
-    async launch() {
-        if (this.browser)
-            return;
-        this.browser = await chromium.launch({ headless: this.config.headless });
-        this.context = await this.browser.newContext({
-            viewport: {
-                width: this.config.viewportWidth,
-                height: this.config.viewportHeight,
-            },
-        });
-        const savedCookies = await this.cookieStore.load();
-        if (savedCookies.length > 0) {
-            await this.context.addCookies(savedCookies.map((c) => ({
-                ...c,
-                sameSite: c.sameSite,
-            })));
-        }
-        this.page = await this.context.newPage();
-        this.page.setDefaultTimeout(this.config.navigationTimeout);
-    }
-    async saveCookies() {
-        if (!this.context)
-            return;
-        const cookies = await this.context.cookies();
-        await this.cookieStore.save(cookies);
-    }
-    async takeSnapshot() {
-        if (!this.page)
-            return "No page open.";
-        await this.page.evaluate(buildIndexInjectionScript());
-        const html = await this.page.content();
-        const url = this.page.url();
-        const title = await this.page.title();
-        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, truncated });
-    }
-    async open(url) {
-        if (!url)
-            return { success: false, output: t("browser.url_required") };
-        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.page)
-            return { success: false, output: t("browser.create_page_failed") };
-        this.actionTracker.reset();
-        try {
-            await this.page.goto(url, {
-                waitUntil: "domcontentloaded",
-                timeout: 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.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: "No page" };
-        if (!target || target < 1) {
-            return { success: false, output: t("browser.invalid_target") };
-        }
-        try {
-            const script = buildClickScript(target);
-            await this.page.evaluate(script);
-            await this.page
-                .waitForLoadState("domcontentloaded", { timeout: 5000 })
-                .catch(() => { });
-            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.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            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 {
-            const script = buildTypeScript(target, text);
-            await this.page.evaluate(script);
-            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.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            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.page.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.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: "No page" };
-        await this.page
-            .goBack({
-            waitUntil: "domcontentloaded",
-            timeout: this.config.navigationTimeout,
-        })
-            .catch(() => { });
-        await new Promise((r) => setTimeout(r, 300));
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot };
-    }
-    async forward() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: "No page" };
-        await this.page
-            .goForward({
-            waitUntil: "domcontentloaded",
-            timeout: this.config.navigationTimeout,
-        })
-            .catch(() => { });
-        await new Promise((r) => setTimeout(r, 300));
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot };
-    }
-    async screenshot() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: "No page" };
-        const buffer = await this.page.screenshot({ type: "png", fullPage: false });
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot, screenshot: buffer };
-    }
-    async snapshot() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        const snap = await this.takeSnapshot();
-        return { success: true, output: snap };
-    }
-    async wait(ms) {
-        const err = await this.ensurePage();
-        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.page) {
-            await this.page.close().catch(() => { });
-            this.page = null;
-        }
-        if (this.context) {
-            await this.context.close().catch(() => { });
-            this.context = null;
-        }
-        if (this.browser) {
-            await this.browser.close().catch(() => { });
-            this.browser = null;
-        }
-        this.state = { isOpen: false, url: null, title: null, elementCount: 0 };
-        return { success: true, output: t("browser.closed") };
-    }
-}

package/dist/modules/browser/snapshot.js

@@ -1,114 +0,0 @@
-import { t } from '../../i18n/index';
-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 formatSnapshot(snapshot) {
-    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'));
-        return lines.join('\n');
-    }
-    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'));
-    }
-    return lines.join('\n');
-}

package/dist/modules/browser/types.js

@@ -1,9 +0,0 @@
-export const DEFAULT_BROWSER_CONFIG = {
-    headless: true,
-    maxElements: 30,
-    screenshotMaxWidth: 1280,
-    cookieDir: '',
-    viewportWidth: 1280,
-    viewportHeight: 720,
-    navigationTimeout: 15000,
-};