micro-models-agent 0.57.0 → 0.57.2

package/dist/modules/browser/bridge-server.mjs

@@ -1,219 +1,219 @@
-import { createRequire } from "module";
-import readline from "readline";
-
-const require = createRequire(import.meta.url);
-const { chromium } = require("playwright");
-
-const CONSOLE_CAP = 500;
-const NETWORK_CAP = 100;
-let maxLineChars = 400;
-
-let browser = null;
-let context = null;
-let page = null;
-let consoleBuf = [];
-let networkBuf = [];
-let lastUrl = "";
-
-function pushConsole(type, text) {
-  if (consoleBuf.length >= CONSOLE_CAP) return;
-  const clean = String(text).replace(/\s+/g, " ").trim();
-  if (!clean) return;
-  const line = clean.length > maxLineChars ? clean.slice(0, maxLineChars) + "…" : clean;
-  consoleBuf.push({ type, text: line });
-}
-
-function pushNetwork(err) {
-  if (networkBuf.length >= NETWORK_CAP) return;
-  networkBuf.push(err);
-}
-
-function drain() {
-  const consoleEvents = consoleBuf;
-  const networkEvents = networkBuf;
-  consoleBuf = [];
-  networkBuf = [];
-  return { console: consoleEvents, network: networkEvents };
-}
-
-function readInt(v, fallback) {
-  const n = Number(v);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-
-async function handleLaunch(params) {
-  if (browser) return { ok: true };
-  maxLineChars = readInt(params?.maxConsoleLineChars, 400);
-  browser = await chromium.launch({
-    headless: params?.headless !== false,
-    timeout: readInt(params?.timeoutMs, 30000),
-  });
-  context = await browser.newContext({
-    viewport: params?.viewport || { width: 1280, height: 720 },
-  });
-  page = await context.newPage();
-  page.setDefaultTimeout(readInt(params?.timeoutMs, 30000));
-
-  page.on("console", (msg) => pushConsole(msg.type(), msg.text()));
-  page.on("pageerror", (err) => pushConsole("pageerror", `Page error: ${err.message}`));
-  page.on("requestfailed", (req) => {
-    const failure = req.failure();
-    pushNetwork({ method: req.method(), url: req.url(), error: failure?.errorText || "unknown" });
-  });
-
-  return { ok: true };
-}
-
-async function handleGoto(params) {
-  if (!page) return { ok: false, error: "No page open" };
-  const url = String(params?.url || "");
-  const timeoutMs = readInt(params?.timeoutMs, 15000);
-  consoleBuf = [];
-  networkBuf = [];
-  try {
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
-    lastUrl = page.url();
-    return { ok: true, data: { url: lastUrl } };
-  } catch (err) {
-    lastUrl = page.url();
-    return { ok: false, error: err.message, data: { url: lastUrl } };
-  }
-}
-
-async function handleEvaluate(params) {
-  if (!page) return { ok: false, error: "No page open" };
-  const js = String(params?.js || "");
-  try {
-    const result = await page.evaluate(js);
-    return { ok: true, data: { result } };
-  } catch (err) {
-    return { ok: false, error: err.message };
-  }
-}
-
-async function handleClose() {
-  try {
-    if (page) await page.close();
-  } catch {}
-  try {
-    if (context) await context.close();
-  } catch {}
-  try {
-    if (browser) await browser.close();
-  } catch {}
-  page = null;
-  context = null;
-  browser = null;
-  return { ok: true };
-}
-
-const handlers = {
-  ping: async () => ({ ok: true, data: { pong: true, runtime: process.version } }),
-  launch: handleLaunch,
-  goto: handleGoto,
-  evaluate: handleEvaluate,
-  content: async () => ({ ok: true, data: { html: page ? await page.content() : "" } }),
-  title: async () => ({ ok: true, data: { title: page ? await page.title() : "" } }),
-  url: async () => ({ ok: true, data: { url: page ? page.url() : lastUrl } }),
-  waitLoad: async (params) => {
-    if (!page) return { ok: false, error: "No page open" };
-    try {
-      await page.waitForLoadState("domcontentloaded", {
-        timeout: readInt(params?.timeoutMs, 15000),
-      });
-    } catch {}
-    return { ok: true };
-  },
-  screenshot: async () => {
-    if (!page) return { ok: false, error: "No page open" };
-    try {
-      const buf = await page.screenshot({ type: "png", fullPage: false });
-      return { ok: true, data: { base64: buf.toString("base64") } };
-    } catch (err) {
-      return { ok: false, error: err.message };
-    }
-  },
-  cookies: async () => {
-    if (!context) return { ok: true, data: { cookies: [] } };
-    const cookies = await context.cookies();
-    return { ok: true, data: { cookies } };
-  },
-  setCookies: async (params) => {
-    if (!context) return { ok: false, error: "No context" };
-    const cookies = Array.isArray(params?.cookies) ? params.cookies : [];
-    if (cookies.length > 0) {
-      try {
-        await context.addCookies(cookies);
-      } catch (err) {
-        return { ok: false, error: err.message };
-      }
-    }
-    return { ok: true };
-  },
-  back: async (params) => {
-    if (!page) return { ok: false, error: "No page open" };
-    try {
-      await page.goBack({
-        waitUntil: "domcontentloaded",
-        timeout: readInt(params?.timeoutMs, 15000),
-      });
-    } catch {}
-    lastUrl = page.url();
-    return { ok: true, data: { url: lastUrl } };
-  },
-  forward: async (params) => {
-    if (!page) return { ok: false, error: "No page open" };
-    try {
-      await page.goForward({
-        waitUntil: "domcontentloaded",
-        timeout: readInt(params?.timeoutMs, 15000),
-      });
-    } catch {}
-    lastUrl = page.url();
-    return { ok: true, data: { url: lastUrl } };
-  },
-  close: handleClose,
-};
-
-const rl = readline.createInterface({ input: process.stdin });
-rl.on("line", async (line) => {
-  let req;
-  try {
-    req = JSON.parse(line);
-  } catch {
-    return;
-  }
-  const handler = handlers[req.cmd];
-  let resp;
-  if (!handler) {
-    resp = { id: req.id, ok: false, error: `Unknown command: ${req.cmd}`, ...drain() };
-  } else {
-    try {
-      const result = await handler(req.params || {});
-      resp = { id: req.id, ...result, ...drain() };
-    } catch (err) {
-      resp = { id: req.id, ok: false, error: err.message, ...drain() };
-    }
-  }
-  process.stdout.write(JSON.stringify(resp) + "\n");
-});
-
-let shuttingDown = false;
-async function shutdown() {
-  // Idempotent: signals, stdin close and the explicit close command may race.
-  if (shuttingDown) return;
-  shuttingDown = true;
-  try {
-    await handleClose();
-  } catch (err) {
-    // Best-effort cleanup: never block process exit on a broken browser.
-    console.error("[bridge-server] cleanup during shutdown failed:", err);
-  }
-  process.exit(0);
-}
-
-process.on("SIGTERM", () => void shutdown());
-process.on("SIGINT", () => void shutdown());
-// Parent died without sending "close" (crash, kill -9): stdin EOF is the
-// last signal we get — without this the bridge and its Chromium leak.
-rl.on("close", () => void shutdown());
+import { createRequire } from "module";
+import readline from "readline";
+
+const require = createRequire(import.meta.url);
+const { chromium } = require("playwright");
+
+const CONSOLE_CAP = 500;
+const NETWORK_CAP = 100;
+let maxLineChars = 400;
+
+let browser = null;
+let context = null;
+let page = null;
+let consoleBuf = [];
+let networkBuf = [];
+let lastUrl = "";
+
+function pushConsole(type, text) {
+  if (consoleBuf.length >= CONSOLE_CAP) return;
+  const clean = String(text).replace(/\s+/g, " ").trim();
+  if (!clean) return;
+  const line = clean.length > maxLineChars ? clean.slice(0, maxLineChars) + "…" : clean;
+  consoleBuf.push({ type, text: line });
+}
+
+function pushNetwork(err) {
+  if (networkBuf.length >= NETWORK_CAP) return;
+  networkBuf.push(err);
+}
+
+function drain() {
+  const consoleEvents = consoleBuf;
+  const networkEvents = networkBuf;
+  consoleBuf = [];
+  networkBuf = [];
+  return { console: consoleEvents, network: networkEvents };
+}
+
+function readInt(v, fallback) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+async function handleLaunch(params) {
+  if (browser) return { ok: true };
+  maxLineChars = readInt(params?.maxConsoleLineChars, 400);
+  browser = await chromium.launch({
+    headless: params?.headless !== false,
+    timeout: readInt(params?.timeoutMs, 30000),
+  });
+  context = await browser.newContext({
+    viewport: params?.viewport || { width: 1280, height: 720 },
+  });
+  page = await context.newPage();
+  page.setDefaultTimeout(readInt(params?.timeoutMs, 30000));
+
+  page.on("console", (msg) => pushConsole(msg.type(), msg.text()));
+  page.on("pageerror", (err) => pushConsole("pageerror", `Page error: ${err.message}`));
+  page.on("requestfailed", (req) => {
+    const failure = req.failure();
+    pushNetwork({ method: req.method(), url: req.url(), error: failure?.errorText || "unknown" });
+  });
+
+  return { ok: true };
+}
+
+async function handleGoto(params) {
+  if (!page) return { ok: false, error: "No page open" };
+  const url = String(params?.url || "");
+  const timeoutMs = readInt(params?.timeoutMs, 15000);
+  consoleBuf = [];
+  networkBuf = [];
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+    lastUrl = page.url();
+    return { ok: true, data: { url: lastUrl } };
+  } catch (err) {
+    lastUrl = page.url();
+    return { ok: false, error: err.message, data: { url: lastUrl } };
+  }
+}
+
+async function handleEvaluate(params) {
+  if (!page) return { ok: false, error: "No page open" };
+  const js = String(params?.js || "");
+  try {
+    const result = await page.evaluate(js);
+    return { ok: true, data: { result } };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function handleClose() {
+  try {
+    if (page) await page.close();
+  } catch {}
+  try {
+    if (context) await context.close();
+  } catch {}
+  try {
+    if (browser) await browser.close();
+  } catch {}
+  page = null;
+  context = null;
+  browser = null;
+  return { ok: true };
+}
+
+const handlers = {
+  ping: async () => ({ ok: true, data: { pong: true, runtime: process.version } }),
+  launch: handleLaunch,
+  goto: handleGoto,
+  evaluate: handleEvaluate,
+  content: async () => ({ ok: true, data: { html: page ? await page.content() : "" } }),
+  title: async () => ({ ok: true, data: { title: page ? await page.title() : "" } }),
+  url: async () => ({ ok: true, data: { url: page ? page.url() : lastUrl } }),
+  waitLoad: async (params) => {
+    if (!page) return { ok: false, error: "No page open" };
+    try {
+      await page.waitForLoadState("domcontentloaded", {
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
+    } catch {}
+    return { ok: true };
+  },
+  screenshot: async () => {
+    if (!page) return { ok: false, error: "No page open" };
+    try {
+      const buf = await page.screenshot({ type: "png", fullPage: false });
+      return { ok: true, data: { base64: buf.toString("base64") } };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  },
+  cookies: async () => {
+    if (!context) return { ok: true, data: { cookies: [] } };
+    const cookies = await context.cookies();
+    return { ok: true, data: { cookies } };
+  },
+  setCookies: async (params) => {
+    if (!context) return { ok: false, error: "No context" };
+    const cookies = Array.isArray(params?.cookies) ? params.cookies : [];
+    if (cookies.length > 0) {
+      try {
+        await context.addCookies(cookies);
+      } catch (err) {
+        return { ok: false, error: err.message };
+      }
+    }
+    return { ok: true };
+  },
+  back: async (params) => {
+    if (!page) return { ok: false, error: "No page open" };
+    try {
+      await page.goBack({
+        waitUntil: "domcontentloaded",
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
+    } catch {}
+    lastUrl = page.url();
+    return { ok: true, data: { url: lastUrl } };
+  },
+  forward: async (params) => {
+    if (!page) return { ok: false, error: "No page open" };
+    try {
+      await page.goForward({
+        waitUntil: "domcontentloaded",
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
+    } catch {}
+    lastUrl = page.url();
+    return { ok: true, data: { url: lastUrl } };
+  },
+  close: handleClose,
+};
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", async (line) => {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const handler = handlers[req.cmd];
+  let resp;
+  if (!handler) {
+    resp = { id: req.id, ok: false, error: `Unknown command: ${req.cmd}`, ...drain() };
+  } else {
+    try {
+      const result = await handler(req.params || {});
+      resp = { id: req.id, ...result, ...drain() };
+    } catch (err) {
+      resp = { id: req.id, ok: false, error: err.message, ...drain() };
+    }
+  }
+  process.stdout.write(JSON.stringify(resp) + "\n");
+});
+
+let shuttingDown = false;
+async function shutdown() {
+  // Idempotent: signals, stdin close and the explicit close command may race.
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    await handleClose();
+  } catch (err) {
+    // Best-effort cleanup: never block process exit on a broken browser.
+    console.error("[bridge-server] cleanup during shutdown failed:", err);
+  }
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => void shutdown());
+process.on("SIGINT", () => void shutdown());
+// Parent died without sending "close" (crash, kill -9): stdin EOF is the
+// last signal we get — without this the bridge and its Chromium leak.
+rl.on("close", () => void shutdown());

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

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

@@ -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();
+            },
+        };
+    }
+}