micro-models-agent 0.57.0 → 0.57.1

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

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

@@ -0,0 +1,10 @@
+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/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([]);
+    }
+}