micro-models-agent 0.39.0 → 0.40.0

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

@@ -1,110 +1,110 @@
-import { createRequire } from 'module'
-import readline from 'readline'
+import { createRequire } from "module";
+import readline from "readline";
 
-const require = createRequire(import.meta.url)
-const { chromium } = require('playwright')
+const require = createRequire(import.meta.url);
+const { chromium } = require("playwright");
 
-const CONSOLE_CAP = 500
-const NETWORK_CAP = 100
-let maxLineChars = 400
+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 = ''
+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 })
+  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)
+  if (networkBuf.length >= NETWORK_CAP) return;
+  networkBuf.push(err);
 }
 
 function drain() {
-  const consoleEvents = consoleBuf
-  const networkEvents = networkBuf
-  consoleBuf = []
-  networkBuf = []
-  return { console: consoleEvents, network: networkEvents }
+  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
+  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)
+  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 }
+  });
+  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 = []
+  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 } }
+    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 } }
+    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 || '')
+  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 } }
+    const result = await page.evaluate(js);
+    return { ok: true, data: { result } };
   } catch (err) {
-    return { ok: false, error: err.message }
+    return { ok: false, error: err.message };
   }
 }
 
 async function handleClose() {
   try {
-    if (page) await page.close()
+    if (page) await page.close();
   } catch {}
   try {
-    if (context) await context.close()
+    if (context) await context.close();
   } catch {}
   try {
-    if (browser) await browser.close()
+    if (browser) await browser.close();
   } catch {}
-  page = null
-  context = null
-  browser = null
-  return { ok: true }
+  page = null;
+  context = null;
+  browser = null;
+  return { ok: true };
 }
 
 const handlers = {
@@ -112,83 +112,91 @@ const handlers = {
   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() : '' } }),
+  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' }
+    if (!page) return { ok: false, error: "No page open" };
     try {
-      await page.waitForLoadState('domcontentloaded', { timeout: readInt(params?.timeoutMs, 15000) })
+      await page.waitForLoadState("domcontentloaded", {
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
     } catch {}
-    return { ok: true }
+    return { ok: true };
   },
   screenshot: async () => {
-    if (!page) return { ok: false, error: 'No page open' }
+    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') } }
+      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 }
+      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 } }
+    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 (!context) return { ok: false, error: "No context" };
+    const cookies = Array.isArray(params?.cookies) ? params.cookies : [];
     if (cookies.length > 0) {
       try {
-        await context.addCookies(cookies)
+        await context.addCookies(cookies);
       } catch (err) {
-        return { ok: false, error: err.message }
+        return { ok: false, error: err.message };
       }
     }
-    return { ok: true }
+    return { ok: true };
   },
   back: async (params) => {
-    if (!page) return { ok: false, error: 'No page open' }
+    if (!page) return { ok: false, error: "No page open" };
     try {
-      await page.goBack({ waitUntil: 'domcontentloaded', timeout: readInt(params?.timeoutMs, 15000) })
+      await page.goBack({
+        waitUntil: "domcontentloaded",
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
     } catch {}
-    lastUrl = page.url()
-    return { ok: true, data: { url: lastUrl } }
+    lastUrl = page.url();
+    return { ok: true, data: { url: lastUrl } };
   },
   forward: async (params) => {
-    if (!page) return { ok: false, error: 'No page open' }
+    if (!page) return { ok: false, error: "No page open" };
     try {
-      await page.goForward({ waitUntil: 'domcontentloaded', timeout: readInt(params?.timeoutMs, 15000) })
+      await page.goForward({
+        waitUntil: "domcontentloaded",
+        timeout: readInt(params?.timeoutMs, 15000),
+      });
     } catch {}
-    lastUrl = page.url()
-    return { ok: true, data: { url: lastUrl } }
+    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
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", async (line) => {
+  let req;
   try {
-    req = JSON.parse(line)
+    req = JSON.parse(line);
   } catch {
-    return
+    return;
   }
-  const handler = handlers[req.cmd]
-  let resp
+  const handler = handlers[req.cmd];
+  let resp;
   if (!handler) {
-    resp = { id: req.id, ok: false, error: `Unknown command: ${req.cmd}`, ...drain() }
+    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() }
+      const result = await handler(req.params || {});
+      resp = { id: req.id, ...result, ...drain() };
     } catch (err) {
-      resp = { id: req.id, ok: false, error: err.message, ...drain() }
+      resp = { id: req.id, ok: false, error: err.message, ...drain() };
     }
   }
-  process.stdout.write(JSON.stringify(resp) + '\n')
-})
+  process.stdout.write(JSON.stringify(resp) + "\n");
+});
 
-process.on('SIGTERM', () => process.exit(0))
-process.on('SIGINT', () => process.exit(0))
+process.on("SIGTERM", () => process.exit(0));
+process.on("SIGINT", () => process.exit(0));

package/dist/modules/browser/session.js

@@ -1,8 +1,8 @@
-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';
+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;
@@ -14,11 +14,14 @@ export class BrowserActionTracker {
         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 &&
+        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 t("browser.repeated_action", {
+                action,
+                threshold: this.threshold,
+            });
         }
         return null;
     }
@@ -32,7 +35,12 @@ export class BrowserSession {
     page = null;
     config;
     cookieStore;
-    state = { isOpen: false, url: null, title: null, elementCount: 0 };
+    state = {
+        isOpen: false,
+        url: null,
+        title: null,
+        elementCount: 0,
+    };
     actionTracker = new BrowserActionTracker(3);
     constructor(config) {
         this.config = config;
@@ -45,53 +53,60 @@ export class BrowserSession {
         try {
             let result;
             switch (action) {
-                case 'open':
-                    result = await this.open(String(args.url || ''));
+                case "open":
+                    result = await this.open(String(args.url || ""));
                     break;
-                case 'click':
+                case "click":
                     result = await this.click(Number(args.target));
                     break;
-                case 'type':
-                    result = await this.type(Number(args.target), String(args.text || ''));
+                case "type":
+                    result = await this.type(Number(args.target), String(args.text || ""));
                     break;
-                case 'scroll':
-                    result = await this.scroll(String(args.direction || 'down'));
+                case "scroll":
+                    result = await this.scroll(String(args.direction || "down"));
                     break;
-                case 'back':
+                case "back":
                     result = await this.back();
                     break;
-                case 'forward':
+                case "forward":
                     result = await this.forward();
                     break;
-                case 'screenshot':
+                case "screenshot":
                     result = await this.screenshot();
                     break;
-                case 'snapshot':
+                case "snapshot":
                     result = await this.snapshot();
                     break;
-                case 'close':
+                case "close":
                     result = await this.close();
                     break;
-                case 'wait':
+                case "wait":
                     result = await this.wait(Number(args.ms || 1000));
                     break;
-                default: return { success: false, output: t('browser.unknown_action', { action }) };
+                default:
+                    return {
+                        success: false,
+                        output: t("browser.unknown_action", { action }),
+                    };
             }
-            if (action !== 'open') {
-                const warning = this.actionTracker.record(action, args, this.page?.url() || '');
+            if (action !== "open") {
+                const warning = this.actionTracker.record(action, args, this.page?.url() || "");
                 if (warning && result.success) {
-                    result.output = result.output + '\n\n⚠️ ' + warning;
+                    result.output = result.output + "\n\n⚠️ " + warning;
                 }
             }
             return result;
         }
         catch (err) {
-            return { success: false, output: t('browser.error', { message: err.message }) };
+            return {
+                success: false,
+                output: t("browser.error", { message: err.message }),
+            };
         }
     }
     async ensurePage() {
         if (!this.page) {
-            return { success: false, output: t('browser.no_page') };
+            return { success: false, output: t("browser.no_page") };
         }
         return null;
     }
@@ -100,11 +115,14 @@ export class BrowserSession {
             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 },
+            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 => ({
+            await this.context.addCookies(savedCookies.map((c) => ({
                 ...c,
                 sameSite: c.sameSite,
             })));
@@ -120,7 +138,7 @@ export class BrowserSession {
     }
     async takeSnapshot() {
         if (!this.page)
-            return 'No page open.';
+            return "No page open.";
         await this.page.evaluate(buildIndexInjectionScript());
         const html = await this.page.content();
         const url = this.page.url();
@@ -138,19 +156,28 @@ export class BrowserSession {
     }
     async open(url) {
         if (!url)
-            return { success: false, output: t('browser.url_required') };
-        if (!url.startsWith('http://') && !url.startsWith('https://')) {
-            url = 'https://' + 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') };
+            return { success: false, output: t("browser.create_page_failed") };
         this.actionTracker.reset();
         try {
-            await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: this.config.navigationTimeout });
+            await this.page.goto(url, {
+                waitUntil: "domcontentloaded",
+                timeout: this.config.navigationTimeout,
+            });
         }
         catch (err) {
-            return { success: false, output: t('browser.nav_failed', { message: err.message }) };
+            return {
+                success: false,
+                output: t("browser.nav_failed", { message: err.message }),
+            };
         }
         const snapshot = await this.takeSnapshot();
         await this.saveCookies();
@@ -161,21 +188,26 @@ export class BrowserSession {
         if (err)
             return err;
         if (!this.page)
-            return { success: false, output: 'No page' };
+            return { success: false, output: "No page" };
         if (!target || target < 1) {
-            return { success: false, output: t('browser.invalid_target') };
+            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));
+            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 }) };
+            return {
+                success: false,
+                output: t("browser.click_failed", { message: err.message }),
+            };
         }
     }
     async type(target, text) {
@@ -183,12 +215,12 @@ export class BrowserSession {
         if (err)
             return err;
         if (!this.page)
-            return { success: false, output: 'No page' };
+            return { success: false, output: "No page" };
         if (!target || target < 1) {
-            return { success: false, output: t('browser.invalid_target_short') };
+            return { success: false, output: t("browser.invalid_target_short") };
         }
         if (!text) {
-            return { success: false, output: t('browser.text_required') };
+            return { success: false, output: t("browser.text_required") };
         }
         try {
             const script = buildTypeScript(target, text);
@@ -197,7 +229,10 @@ export class BrowserSession {
             return { success: true, output: snapshot };
         }
         catch (err) {
-            return { success: false, output: t('browser.type_failed', { message: err.message }) };
+            return {
+                success: false,
+                output: t("browser.type_failed", { message: err.message }),
+            };
         }
     }
     async scroll(direction) {
@@ -205,19 +240,22 @@ export class BrowserSession {
         if (err)
             return err;
         if (!this.page)
-            return { success: false, output: 'No 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') };
+        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));
+            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 }) };
+            return {
+                success: false,
+                output: t("browser.scroll_failed", { message: err.message }),
+            };
         }
     }
     async back() {
@@ -225,9 +263,14 @@ export class BrowserSession {
         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));
+            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 };
     }
@@ -236,9 +279,14 @@ export class BrowserSession {
         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));
+            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 };
     }
@@ -247,8 +295,8 @@ export class BrowserSession {
         if (err)
             return err;
         if (!this.page)
-            return { success: false, output: 'No page' };
-        const buffer = await this.page.screenshot({ type: 'png', fullPage: false });
+            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 };
     }
@@ -263,7 +311,7 @@ export class BrowserSession {
         const err = await this.ensurePage();
         if (err)
             return err;
-        await new Promise(r => setTimeout(r, Math.min(ms, 10000)));
+        await new Promise((r) => setTimeout(r, Math.min(ms, 10000)));
         const snapshot = await this.takeSnapshot();
         return { success: true, output: snapshot };
     }
@@ -282,6 +330,6 @@ export class BrowserSession {
             this.browser = null;
         }
         this.state = { isOpen: false, url: null, title: null, elementCount: 0 };
-        return { success: true, output: t('browser.closed') };
+        return { success: true, output: t("browser.closed") };
     }
 }