micro-models-agent 0.52.0 → 0.52.1

package/dist/modules/browser/bridge-client.js

@@ -1,199 +0,0 @@
-import { spawn } from "child_process";
-import { createInterface } from "readline";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { ConsoleBuffer } from "./session";
-import { pickExistingPath } from "./bridge-path";
-const BRIDGE_REQUEST_TIMEOUT_MS = 30000;
-function bridgeScriptPath() {
-    // Resolve the bridge script for BOTH layouts (rule #12 — read from disk):
-    //   src/modules/browser/bridge-server.mjs          (bun run src/…)
-    //   dist/modules/browser/bridge-server.mjs         (bundle at dist/main.js +
-    //                                                   assets copied by copy-assets.ts)
-    // The single-candidate version looked next to the bundle (dist/bridge-server.mjs),
-    // which copy-assets.ts never produces — so the browser tool died with ENOENT
-    // in the released npm package (observed: v0.37.0).
-    const dir = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        join(dir, "bridge-server.mjs"),
-        join(dir, "modules", "browser", "bridge-server.mjs"),
-    ];
-    return pickExistingPath(candidates);
-}
-export class BridgeDriver {
-    proc = null;
-    rl = null;
-    pending = new Map();
-    lastStderr = [];
-    nextId = 1;
-    lastUrl = "";
-    console = new ConsoleBuffer(500);
-    network = [];
-    maxConsoleLineChars;
-    constructor(opts = {}) {
-        this.maxConsoleLineChars = opts.maxConsoleLineChars ?? 400;
-    }
-    async send(cmd, params = {}, retried = false) {
-        if (!this.proc || !this.rl) {
-            if (retried || cmd === "close")
-                throw new Error("Bridge is not running");
-            this.spawnBridge();
-            return this.send(cmd, params, true);
-        }
-        const id = this.nextId++;
-        const response = await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Bridge timeout waiting for "${cmd}"`));
-            }, BRIDGE_REQUEST_TIMEOUT_MS);
-            this.pending.set(id, (resp) => {
-                clearTimeout(timer);
-                resolve(resp);
-            });
-            this.proc.stdin.write(JSON.stringify({ id, cmd, params }) + "\n");
-        });
-        this.drainEvents(response);
-        if (!response.ok)
-            throw new Error(response.error || `Bridge command failed: ${cmd}`);
-        return response;
-    }
-    drainEvents(resp) {
-        if (Array.isArray(resp.console)) {
-            for (const entry of resp.console) {
-                this.console.add(entry.type, entry.text);
-            }
-        }
-        if (Array.isArray(resp.network)) {
-            for (const err of resp.network)
-                this.network.push(err);
-        }
-        if (resp.data && typeof resp.data.url === "string") {
-            this.lastUrl = resp.data.url;
-        }
-    }
-    async launch(cfg) {
-        this.spawnBridge();
-        await this.send("launch", {
-            headless: cfg.headless,
-            viewport: cfg.viewport,
-            timeoutMs: cfg.timeoutMs,
-            maxConsoleLineChars: this.maxConsoleLineChars,
-        });
-    }
-    spawnBridge() {
-        const script = bridgeScriptPath();
-        const proc = spawn("node", [script], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-        this.proc = proc;
-        this.lastStderr = [];
-        proc.stderr.on("data", (chunk) => {
-            this.lastStderr = [...this.lastStderr.slice(-4), chunk.toString()];
-        });
-        const rl = createInterface({ input: proc.stdout });
-        this.rl = rl;
-        rl.on("line", (line) => {
-            let resp;
-            try {
-                resp = JSON.parse(line);
-            }
-            catch {
-                return;
-            }
-            const resolver = this.pending.get(resp.id);
-            if (resolver) {
-                this.pending.delete(resp.id);
-                resolver(resp);
-            }
-        });
-        proc.on("error", (err) => {
-            if (this.proc !== proc)
-                return; // stale child — a newer bridge is alive
-            this.failPending(`Bridge process failed to start: ${err.message}`);
-            this.proc = null;
-            this.rl = null;
-        });
-        proc.on("exit", (code) => {
-            if (this.proc !== proc)
-                return; // stale child — a newer bridge is alive
-            const stderrTail = this.lastStderr.join("").trim();
-            this.failPending(stderrTail
-                ? `Bridge process exited (code ${code}): ${stderrTail.slice(0, 300)}`
-                : `Bridge process exited (code ${code})`);
-            this.proc = null;
-            this.rl = null;
-        });
-    }
-    failPending(error) {
-        for (const [, resolver] of this.pending) {
-            resolver({ id: -1, ok: false, error });
-        }
-        this.pending.clear();
-    }
-    async goto(url, timeoutMs) {
-        await this.send("goto", { url, timeoutMs });
-    }
-    async evaluate(js) {
-        const resp = await this.send("evaluate", { js });
-        return resp.data?.result;
-    }
-    async content() {
-        const resp = await this.send("content");
-        return String(resp.data?.html ?? "");
-    }
-    async title() {
-        const resp = await this.send("title");
-        return String(resp.data?.title ?? "");
-    }
-    url() {
-        return this.lastUrl;
-    }
-    async waitForLoad(timeoutMs) {
-        await this.send("waitLoad", { timeoutMs });
-    }
-    async screenshot() {
-        const resp = await this.send("screenshot");
-        return Buffer.from(String(resp.data?.base64 ?? ""), "base64");
-    }
-    async cookies() {
-        const resp = await this.send("cookies");
-        return (resp.data?.cookies ?? []);
-    }
-    async addCookies(cookies) {
-        await this.send("setCookies", { cookies });
-    }
-    async goBack(timeoutMs) {
-        await this.send("back", { timeoutMs });
-    }
-    async goForward(timeoutMs) {
-        await this.send("forward", { timeoutMs });
-    }
-    resetEventLog() {
-        this.console.clear();
-        this.network = [];
-    }
-    getConsole() {
-        return this.console.getAll();
-    }
-    getNetworkErrors() {
-        return this.network.slice(-15);
-    }
-    async close() {
-        try {
-            if (this.proc)
-                await this.send("close");
-        }
-        catch {
-            // ignore — we're shutting down
-        }
-        this.dispose();
-    }
-    dispose() {
-        if (this.proc) {
-            this.proc.kill();
-            this.proc = null;
-        }
-        if (this.rl) {
-            this.rl.close();
-            this.rl = null;
-        }
-    }
-}

package/dist/modules/browser/bridge-path.js

@@ -1,10 +0,0 @@
-import { existsSync } from "fs";
-/**
- * Pick the first existing candidate path, falling back to the first candidate.
- * Split out of bridge-client.ts so the source-vs-dist layout resolution is
- * unit-testable without spawning a node bridge (rule #12: build-time values
- * are resolved from disk at runtime, never inlined).
- */
-export function pickExistingPath(candidates, fallback = candidates[0]) {
-    return candidates.find((p) => existsSync(p)) ?? fallback;
-}

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/driver.js

@@ -1,136 +0,0 @@
-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

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

@@ -1,29 +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.",
-                '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();
-            },
-        };
-    }
-}