@assrt-ai/assrt 0.3.3

package/chunk-PZ5LLIRQ.mjs

@@ -0,0 +1,2256 @@
+// src/core/keychain.ts
+import { execSync } from "child_process";
+var KEYCHAIN_SERVICE = "Claude Code-credentials";
+function getCredential() {
+  if (process.platform !== "darwin") {
+    throw new Error(
+      "Assrt CLI currently requires macOS with Claude Code installed.\nLog in to Claude Code (`claude` in terminal) to store credentials in Keychain."
+    );
+  }
+  try {
+    const raw = execSync(
+      `security find-generic-password -s "${KEYCHAIN_SERVICE}" -w`,
+      { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const parsed = JSON.parse(raw);
+    const token = parsed?.claudeAiOauth?.accessToken;
+    if (token) {
+      console.error("[auth] Using Claude Code OAuth token from macOS Keychain");
+      return { token, type: "oauth" };
+    }
+  } catch {
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey) {
+    console.error("[auth] Using ANTHROPIC_API_KEY env var");
+    return { token: apiKey, type: "apiKey" };
+  }
+  throw new Error(
+    "No credentials found. Either:\n  - Log in to Claude Code (`claude` in terminal) to store credentials in Keychain, or\n  - Set the ANTHROPIC_API_KEY environment variable."
+  );
+}
+
+// src/core/freestyle.ts
+import { Agent, fetch as undiciFetch } from "undici";
+import crypto from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function flog(level, data) {
+  const line = "[freestyle] " + JSON.stringify({ ...data, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  console[level](line);
+}
+var freestyleModule = null;
+async function getFreestyle() {
+  if (!freestyleModule) {
+    freestyleModule = await import("freestyle-sandboxes");
+  }
+  return freestyleModule;
+}
+var dispatcher = new Agent({
+  headersTimeout: 15 * 60 * 1e3,
+  bodyTimeout: 15 * 60 * 1e3
+});
+async function buildClient() {
+  const { Freestyle } = await getFreestyle();
+  const apiKey = process.env.FREESTYLE_API_KEY;
+  if (!apiKey) throw new Error("FREESTYLE_API_KEY not configured");
+  return new Freestyle({
+    apiKey,
+    fetch: (url, opts = {}) => (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      undiciFetch(url, { ...opts, dispatcher })
+    )
+  });
+}
+var proxyScript = `
+const http = require('http');
+const WS = require('ws');
+
+const MCP_PORT = 3001;
+const CDP_PORT = 9222;
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const FRAMES_DIR = '/tmp/video/frames';
+const VIDEO_FILE = '/tmp/video/recording.webm';
+
+// Ensure frames directory exists
+try { fs.mkdirSync(FRAMES_DIR, { recursive: true }); } catch {}
+
+// Global frame counter for saving screencast JPEGs
+let frameIndex = 0;
+
+const server = http.createServer((req, res) => {
+  // POST /video/encode \u2014 combine saved screencast frames into mp4 via ffmpeg
+  if (req.url === '/video/encode' && req.method === 'POST') {
+    try {
+      const files = fs.readdirSync(FRAMES_DIR).filter((f) => f.endsWith('.jpg')).sort();
+      if (files.length === 0) { res.writeHead(404); res.end('no frames captured'); return; }
+      console.log('[proxy] encoding ' + files.length + ' frames to webm');
+      execSync(
+        'ffmpeg -y -framerate 15 -i ' + FRAMES_DIR + '/frame%06d.jpg ' +
+        '-c:v libvpx -b:v 1M -pix_fmt yuv420p ' +
+        VIDEO_FILE,
+        { timeout: 60000, stdio: 'pipe' }
+      );
+      const stat = fs.statSync(VIDEO_FILE);
+      console.log('[proxy] video encoded: ' + stat.size + ' bytes');
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, frames: files.length, sizeBytes: stat.size }));
+    } catch (e) {
+      console.error('[proxy] encode error:', e.message);
+      res.writeHead(500); res.end(e.message);
+    }
+    return;
+  }
+  // GET /video \u2014 serve the encoded mp4
+  if (req.url === '/video' && req.method === 'GET') {
+    try {
+      if (!fs.existsSync(VIDEO_FILE)) { res.writeHead(404); res.end('no video'); return; }
+      const stat = fs.statSync(VIDEO_FILE);
+      res.writeHead(200, { 'Content-Type': 'video/webm', 'Content-Length': stat.size });
+      fs.createReadStream(VIDEO_FILE).pipe(res);
+    } catch (e) { res.writeHead(500); res.end(e.message); }
+    return;
+  }
+  const proxy = http.request(
+    { hostname: '127.0.0.1', port: MCP_PORT, path: req.url, method: req.method, headers: req.headers },
+    (pRes) => { res.writeHead(pRes.statusCode, pRes.headers); pRes.pipe(res); }
+  );
+  req.pipe(proxy);
+  proxy.on('error', () => { try { res.writeHead(502); res.end(); } catch {} });
+});
+
+const wss = new WS.WebSocketServer({ noServer: true });
+
+server.on('upgrade', (req, socket, head) => {
+  if (req.url === '/screencast') {
+    wss.handleUpgrade(req, socket, head, (ws) => startRelay(ws));
+  } else if (req.url === '/input') {
+    wss.handleUpgrade(req, socket, head, (ws) => startInputRelay(ws));
+  } else if (req.url === '/vnc') {
+    // WS-to-WS proxy: accept incoming WebSocket, connect to local websockify, pipe binary data
+    wss.handleUpgrade(req, socket, head, (clientWs) => {
+      const upstream = new WS('ws://127.0.0.1:5901', ['binary']);
+      upstream.binaryType = 'arraybuffer';
+      clientWs.binaryType = 'arraybuffer';
+
+      upstream.on('open', () => {
+        console.log('[proxy] VNC WebSocket relay connected');
+      });
+
+      upstream.on('message', (data) => {
+        if (clientWs.readyState === 1) clientWs.send(data);
+      });
+
+      clientWs.on('message', (data) => {
+        if (upstream.readyState === 1) upstream.send(data);
+      });
+
+      upstream.on('close', () => { if (clientWs.readyState === 1) clientWs.close(); });
+      upstream.on('error', () => { if (clientWs.readyState === 1) clientWs.close(); });
+      clientWs.on('close', () => { if (upstream.readyState === 1) upstream.close(); });
+      clientWs.on('error', () => { if (upstream.readyState === 1) upstream.close(); });
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+function startRelay(clientWs) {
+  http.get('http://127.0.0.1:' + CDP_PORT + '/json', (res) => {
+    let data = '';
+    res.on('data', (c) => data += c);
+    res.on('end', () => {
+      try {
+        const targets = JSON.parse(data);
+        const page = targets.find((t) => t.type === 'page');
+        if (!page || !page.webSocketDebuggerUrl) { clientWs.close(1011, 'no page target'); return; }
+        connectCdp(clientWs, page.webSocketDebuggerUrl);
+      } catch (e) { clientWs.close(1011, 'json parse error'); }
+    });
+  }).on('error', () => clientWs.close(1011, 'cdp unreachable'));
+}
+
+function connectCdp(clientWs, wsUrl) {
+  const cdp = new WS(wsUrl);
+  let id = 0;
+  let lastFrame = 0;
+
+  cdp.on('open', () => {
+    cdp.send(JSON.stringify({ id: ++id, method: 'Page.enable' }));
+    cdp.send(JSON.stringify({
+      id: ++id, method: 'Page.startScreencast',
+      params: { format: 'jpeg', quality: 60, maxWidth: 1600, maxHeight: 900, everyNthFrame: 2 }
+    }));
+    console.log('[proxy] CDP screencast started');
+  });
+
+  cdp.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.method === 'Page.screencastFrame') {
+        cdp.send(JSON.stringify({ id: ++id, method: 'Page.screencastFrameAck', params: { sessionId: msg.params.sessionId } }));
+        const now = Date.now();
+        if (now - lastFrame < 66) return;
+        lastFrame = now;
+        // Save frame to disk for video encoding
+        const buf = Buffer.from(msg.params.data, 'base64');
+        const fname = 'frame' + String(frameIndex++).padStart(6, '0') + '.jpg';
+        fs.writeFile(path.join(FRAMES_DIR, fname), buf, () => {});
+        // Forward to WebSocket client
+        if (clientWs.readyState === 1) {
+          clientWs.send(buf);
+        }
+      }
+    } catch {}
+  });
+
+  cdp.on('close', () => { if (clientWs.readyState === 1) clientWs.close(); });
+  cdp.on('error', () => { if (clientWs.readyState === 1) clientWs.close(); });
+  clientWs.on('close', () => { try { cdp.send(JSON.stringify({ id: ++id, method: 'Page.stopScreencast' })); } catch {} cdp.close(); });
+}
+
+function startInputRelay(clientWs) {
+  http.get('http://127.0.0.1:' + CDP_PORT + '/json', (res) => {
+    let data = '';
+    res.on('data', (c) => data += c);
+    res.on('end', () => {
+      try {
+        const targets = JSON.parse(data);
+        const page = targets.find((t) => t.type === 'page');
+        if (!page || !page.webSocketDebuggerUrl) { clientWs.close(1011, 'no page target'); return; }
+        connectInputCdp(clientWs, page.webSocketDebuggerUrl);
+      } catch (e) { clientWs.close(1011, 'json parse error'); }
+    });
+  }).on('error', () => clientWs.close(1011, 'cdp unreachable'));
+}
+
+function connectInputCdp(clientWs, wsUrl) {
+  const cdp = new WS(wsUrl);
+  let id = 1000;
+
+  cdp.on('open', () => {
+    cdp.send(JSON.stringify({ id: ++id, method: 'DOM.enable' }));
+    cdp.send(JSON.stringify({ id: ++id, method: 'Overlay.enable' }));
+    console.log('[proxy] CDP input relay connected');
+  });
+
+  cdp.on('error', (err) => {
+    console.log('[proxy] CDP input error: ' + err.message);
+  });
+
+  cdp.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.method === 'Overlay.inspectNodeRequested') {
+        clientWs.send(JSON.stringify({ type: 'inspectNode', backendNodeId: msg.params.backendNodeId }));
+      }
+    } catch {}
+  });
+
+  clientWs.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.type === 'mouse') {
+        cdp.send(JSON.stringify({
+          id: ++id, method: 'Input.dispatchMouseEvent',
+          params: { type: msg.action, x: msg.x, y: msg.y, button: msg.button || 'left', clickCount: msg.clickCount || 1 }
+        }));
+      } else if (msg.type === 'navigate') {
+        cdp.send(JSON.stringify({ id: ++id, method: 'Page.navigate', params: { url: msg.url } }));
+      } else if (msg.type === 'key') {
+        cdp.send(JSON.stringify({
+          id: ++id, method: 'Input.dispatchKeyEvent',
+          params: { type: msg.action, key: msg.key, code: msg.code, text: msg.text || '', windowsVirtualKeyCode: msg.keyCode || 0, nativeVirtualKeyCode: msg.keyCode || 0 }
+        }));
+      } else if (msg.type === 'scroll') {
+        cdp.send(JSON.stringify({
+          id: ++id, method: 'Input.dispatchMouseEvent',
+          params: { type: 'mouseWheel', x: msg.x, y: msg.y, deltaX: msg.deltaX || 0, deltaY: msg.deltaY || 0 }
+        }));
+      } else if (msg.type === 'highlight') {
+        if (msg.action === 'inspect') {
+          cdp.send(JSON.stringify({
+            id: ++id, method: 'Overlay.setInspectMode',
+            params: { mode: msg.enabled ? 'searchForNode' : 'none', highlightConfig: { showInfo: true, showStyles: true, showExtensionLines: false, contentColor: { r: 111, g: 168, b: 220, a: 0.66 }, paddingColor: { r: 147, g: 196, b: 125, a: 0.55 }, marginColor: { r: 246, g: 178, b: 107, a: 0.66 } } }
+          }));
+        } else if (msg.action === 'node' && msg.backendNodeId) {
+          cdp.send(JSON.stringify({
+            id: ++id, method: 'Overlay.highlightNode',
+            params: { backendNodeId: msg.backendNodeId, highlightConfig: { showInfo: true, showStyles: true, contentColor: { r: 111, g: 168, b: 220, a: 0.66 }, paddingColor: { r: 147, g: 196, b: 125, a: 0.55 }, marginColor: { r: 246, g: 178, b: 107, a: 0.66 } } }
+          }));
+        } else if (msg.action === 'hide') {
+          cdp.send(JSON.stringify({ id: ++id, method: 'Overlay.hideHighlight' }));
+        }
+      }
+    } catch {}
+  });
+
+  cdp.on('close', () => { if (clientWs.readyState === 1) clientWs.close(); });
+  cdp.on('error', () => { if (clientWs.readyState === 1) clientWs.close(); });
+  clientWs.on('close', () => { cdp.close(); });
+}
+
+server.listen(3000, '0.0.0.0', () => console.log('[proxy] listening on 3000'));
+`.trim();
+var startupScript = [
+  "#!/bin/bash",
+  "set -e",
+  "",
+  "# Start Xvfb virtual display",
+  "Xvfb :99 -screen 0 1600x900x24 -ac &",
+  "sleep 1",
+  "export DISPLAY=:99",
+  "",
+  "# Start Chromium on the virtual display with remote debugging",
+  "chromium --no-sandbox --disable-gpu --disable-software-rasterizer \\",
+  "  --window-size=1600,900 --remote-debugging-address=0.0.0.0 --remote-debugging-port=9222 &",
+  "",
+  "# Wait for CDP to be ready (up to 30s)",
+  "for i in $(seq 1 30); do",
+  "  if timeout 1 bash -c '</dev/tcp/127.0.0.1/9222' 2>/dev/null; then",
+  '    echo "[startup] CDP ready on port 9222"',
+  "    break",
+  "  fi",
+  "  sleep 1",
+  "done",
+  "",
+  "# Start x11vnc on the Xvfb display (no password, listen on port 5900)",
+  "x11vnc -display :99 -nopw -forever -shared -rfbport 5900 -q &",
+  "",
+  "# Start websockify to expose VNC over WebSocket on port 5901",
+  "websockify 0.0.0.0:5901 localhost:5900 &",
+  "",
+  "# Start MCP on port 3001 (behind the proxy)",
+  "npx @playwright/mcp --cdp-endpoint http://127.0.0.1:9222 \\",
+  "  --port 3001 --host 0.0.0.0 --allowed-hosts '*' &",
+  "",
+  "# Wait for MCP to be ready",
+  "for i in $(seq 1 30); do",
+  "  if timeout 1 bash -c '</dev/tcp/127.0.0.1/3001' 2>/dev/null; then",
+  '    echo "[startup] MCP ready on port 3001"',
+  "    break",
+  "  fi",
+  "  sleep 1",
+  "done",
+  "",
+  "# Start the proxy on port 3000 (the externally exposed port)",
+  "exec node /opt/proxy.js"
+].join("\n");
+function buildVmSpec() {
+  const { VmSpec, VmBaseImage } = freestyleModule;
+  return new VmSpec().baseImage(
+    new VmBaseImage("FROM debian:bookworm-slim").runCommands(
+      "apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends ca-certificates nodejs npm chromium fonts-liberation libgbm1 libnss3 libxss1 ffmpeg xvfb x11vnc websockify && npm install -g @playwright/mcp@0.0.70 ws && node --version && npm --version && which chromium",
+      `printf '%s' '${startupScript.replace(/'/g, "'\\''")}' > /opt/startup.sh && chmod +x /opt/startup.sh`,
+      `echo '${Buffer.from(proxyScript).toString("base64")}' | base64 -d > /opt/proxy.js`
+    )
+  ).idleTimeoutSeconds(600).systemdService({
+    name: "playwright-mcp",
+    mode: "service",
+    exec: ["/opt/startup.sh"],
+    env: {
+      PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH: "/usr/bin/chromium",
+      NODE_PATH: "/usr/lib/node_modules:/usr/local/lib/node_modules"
+    }
+  });
+}
+var cachedSnapshotId = null;
+var cachedSpecHash = null;
+function computeSpecHash() {
+  return crypto.createHash("sha256").update(startupScript + proxyScript).digest("hex").slice(0, 16);
+}
+function getSnapshotCachePath() {
+  const dir = join(homedir(), ".assrt");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, "snapshots.json");
+}
+function readSnapshotCache() {
+  const cachePath = getSnapshotCachePath();
+  try {
+    if (existsSync(cachePath)) {
+      return JSON.parse(readFileSync(cachePath, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writeSnapshotCache(cache) {
+  try {
+    writeFileSync(getSnapshotCachePath(), JSON.stringify(cache, null, 2));
+  } catch (err) {
+    flog("warn", { event: "freestyle.snapshot.cache_write_error", error: err.message });
+  }
+}
+async function readSnapshotFromStore(specHash) {
+  try {
+    const cache = readSnapshotCache();
+    if (cache[specHash]) {
+      flog("log", { event: "freestyle.snapshot.cache_hit", specHash, snapshotId: cache[specHash].snapshotId, source: "file" });
+      return cache[specHash].snapshotId;
+    }
+  } catch (err) {
+    flog("warn", { event: "freestyle.snapshot.store_read_error", specHash, error: err.message });
+  }
+  return null;
+}
+async function writeSnapshotToStore(specHash, snapshotId) {
+  try {
+    const cache = readSnapshotCache();
+    cache[specHash] = { snapshotId, created_at: (/* @__PURE__ */ new Date()).toISOString() };
+    writeSnapshotCache(cache);
+    flog("log", { event: "freestyle.snapshot.store_written", specHash, snapshotId });
+  } catch (err) {
+    flog("warn", { event: "freestyle.snapshot.store_write_error", specHash, error: err.message });
+  }
+}
+async function waitForProxy(vm, vmId, timeoutS) {
+  const tWait = Date.now();
+  for (let i = 0; i < timeoutS; i++) {
+    try {
+      const r = await vm.exec("timeout 1 bash -c '</dev/tcp/127.0.0.1/3000' && echo UP || echo DOWN");
+      if (r.stdout && r.stdout.includes("UP")) {
+        flog("log", { event: "freestyle.proxy.ready", vmId, durationMs: Date.now() - tWait });
+        return true;
+      }
+      if (i > 0 && i % 10 === 0) {
+        const ports = await vm.exec(
+          "timeout 1 bash -c '</dev/tcp/127.0.0.1/9222' 2>/dev/null && echo 'cdp=UP' || echo 'cdp=DOWN'; timeout 1 bash -c '</dev/tcp/127.0.0.1/3001' 2>/dev/null && echo 'mcp=UP' || echo 'mcp=DOWN'"
+        );
+        flog("log", { event: "freestyle.proxy.waiting", vmId, elapsedS: i, ports: (ports.stdout || "").trim() });
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  flog("warn", { event: "freestyle.proxy.timeout", vmId, durationMs: Date.now() - tWait });
+  return false;
+}
+async function buildLiveSnapshot() {
+  await getFreestyle();
+  const freestyle = await buildClient();
+  const spec = buildVmSpec();
+  flog("log", { event: "freestyle.snapshot.build_start" });
+  const t0 = Date.now();
+  const { vmId, vm } = await freestyle.vms.create(spec);
+  flog("log", { event: "freestyle.snapshot.vm_created", vmId, durationMs: Date.now() - t0 });
+  const ready = await waitForProxy(vm, vmId, 90);
+  if (!ready) {
+    await freestyle.vms.delete({ vmId }).catch(() => {
+    });
+    throw new Error("Snapshot source VM proxy never became ready");
+  }
+  const tSnap = Date.now();
+  const snapResult = await vm.snapshot({ name: "assrt-chromium-mcp-ready" });
+  const snapshotId = snapResult.snapshotId;
+  flog("log", { event: "freestyle.snapshot.created", snapshotId, snapshotDurationMs: Date.now() - tSnap, totalDurationMs: Date.now() - t0 });
+  await freestyle.vms.delete({ vmId }).catch(() => {
+  });
+  return snapshotId;
+}
+async function ensureLiveSnapshot() {
+  const specHash = computeSpecHash();
+  if (cachedSnapshotId && cachedSpecHash === specHash) {
+    flog("log", { event: "freestyle.snapshot.cache_hit", specHash, snapshotId: cachedSnapshotId, source: "memory" });
+    return cachedSnapshotId;
+  }
+  const storedId = await readSnapshotFromStore(specHash);
+  if (storedId) {
+    cachedSnapshotId = storedId;
+    cachedSpecHash = specHash;
+    return storedId;
+  }
+  flog("log", { event: "freestyle.snapshot.cache_miss", specHash });
+  const snapshotId = await buildLiveSnapshot();
+  cachedSnapshotId = snapshotId;
+  cachedSpecHash = specHash;
+  await writeSnapshotToStore(specHash, snapshotId);
+  return snapshotId;
+}
+async function invalidateSnapshotCache(reason) {
+  const specHash = computeSpecHash();
+  flog("warn", { event: "freestyle.snapshot.invalidated", specHash, reason, oldSnapshotId: cachedSnapshotId });
+  cachedSnapshotId = null;
+  cachedSpecHash = null;
+  try {
+    const cache = readSnapshotCache();
+    delete cache[specHash];
+    writeSnapshotCache(cache);
+  } catch (err) {
+    flog("warn", { event: "freestyle.snapshot.invalidate_store_error", error: err.message });
+  }
+}
+async function createVmFromSnapshot(freestyle, snapshotId) {
+  const client = freestyle;
+  const originalPost = client._apiClient.post.bind(client._apiClient);
+  let rawCreate = null;
+  client._apiClient.post = async (path, ...args) => {
+    const r = await originalPost(path, ...args);
+    if (path === "/v1/vms") rawCreate = r;
+    return r;
+  };
+  const t0 = Date.now();
+  flog("log", { event: "freestyle.vm.create_start", snapshotId });
+  const { vmId, vm } = await freestyle.vms.create({
+    snapshotId,
+    ports: [{ port: 443, targetPort: 3e3 }]
+  });
+  const host = rawCreate?.domains?.[0];
+  const vmCreateMs = Date.now() - t0;
+  flog("log", { event: "freestyle.vm.created", vmId, host, durationMs: vmCreateMs, fromSnapshot: true });
+  if (!host) {
+    try {
+      await freestyle.vms.delete({ vmId });
+    } catch {
+    }
+    throw new Error("Freestyle did not return a built-in .vm.freestyle.sh domain");
+  }
+  await waitForProxy(vm, vmId, 30);
+  try {
+    const cdpCheck = await vm.exec("timeout 1 bash -c '</dev/tcp/127.0.0.1/9222' && echo UP || echo DOWN");
+    flog("log", { event: "freestyle.cdp.check", vmId, status: cdpCheck.stdout?.trim() || "unknown" });
+  } catch {
+    flog("warn", { event: "freestyle.cdp.check", vmId, status: "failed" });
+  }
+  return {
+    vmId,
+    host,
+    sseUrl: `https://${host}/sse`,
+    screencastUrl: `wss://${host}/screencast`,
+    inputUrl: `wss://${host}/input`,
+    vncUrl: `wss://${host}/vnc`,
+    vm
+  };
+}
+async function createTestVm() {
+  await getFreestyle();
+  const freestyle = await buildClient();
+  const snapshotId = await ensureLiveSnapshot();
+  try {
+    return await createVmFromSnapshot(freestyle, snapshotId);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("RESUMED_VM_NON_RESPONSIVE") || msg.includes("not responsive") || msg.includes("INTERNAL_ERROR")) {
+      flog("warn", { event: "freestyle.vm.snapshot_stale", snapshotId, error: msg });
+      await invalidateSnapshotCache(msg);
+      const freshSnapshotId = await ensureLiveSnapshot();
+      flog("log", { event: "freestyle.vm.retry_with_fresh_snapshot", freshSnapshotId });
+      return await createVmFromSnapshot(freestyle, freshSnapshotId);
+    }
+    throw err;
+  }
+}
+async function destroyTestVm(vmId) {
+  try {
+    const freestyle = await buildClient();
+    await freestyle.vms.delete({ vmId });
+    flog("log", { event: "freestyle.vm.deleted", vmId });
+  } catch (err) {
+    flog("error", { event: "freestyle.vm.delete_failed", vmId, error: err.message });
+  }
+}
+function isFreestyleConfigured() {
+  return !!process.env.FREESTYLE_API_KEY;
+}
+
+// src/core/screencast-remote.ts
+import WebSocket from "ws";
+var CONNECT_TIMEOUT_MS = 3e4;
+var RemoteScreencastSession = class {
+  /**
+   * @param screencastUrl — WebSocket URL, e.g. `wss://abc.vm.freestyle.sh/screencast`
+   * @param onFrame — Callback receiving JPEG buffers for each screencast frame
+   */
+  constructor(screencastUrl, onFrame) {
+    this.ws = null;
+    this.running = false;
+    this.screencastUrl = screencastUrl;
+    this.onFrame = onFrame;
+  }
+  /** Connect to the proxy's screencast WebSocket and start receiving frames. */
+  async start() {
+    if (this.running) return;
+    console.log(`[screencast] connecting to ${this.screencastUrl} ...`);
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Screencast connection timed out after ${CONNECT_TIMEOUT_MS / 1e3}s`));
+        ws.close();
+      }, CONNECT_TIMEOUT_MS);
+      const ws = new WebSocket(this.screencastUrl, {
+        rejectUnauthorized: false
+      });
+      ws.on("open", () => {
+        this.ws = ws;
+        this.running = true;
+        clearTimeout(timeout);
+        console.log("[screencast] connected, waiting for frames...");
+        resolve();
+      });
+      ws.on("message", (data) => {
+        if (Buffer.isBuffer(data)) {
+          this.onFrame(data);
+        } else if (data instanceof ArrayBuffer) {
+          this.onFrame(Buffer.from(data));
+        }
+      });
+      ws.on("error", (err) => {
+        console.error("[screencast] WebSocket error:", err.message);
+        if (!this.ws) {
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+      ws.on("close", (code, reason) => {
+        this.running = false;
+        this.ws = null;
+        if (!this.running) {
+          console.log(`[screencast] connection closed (code=${code}, reason=${reason})`);
+        }
+      });
+    });
+  }
+  /** Stop streaming and close the WebSocket. */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
+
+// src/core/browser.ts
+var CURSOR_INJECT_SCRIPT = `
+if (!window.__pias_cursor_injected) {
+  window.__pias_cursor_injected = true;
+
+  const heartbeat = document.createElement('div');
+  heartbeat.id = '__pias_heartbeat';
+  Object.assign(heartbeat.style, {
+    position: 'fixed', bottom: '8px', right: '8px', width: '6px', height: '6px',
+    borderRadius: '50%', background: 'rgba(34,197,94,0.6)', zIndex: '2147483647',
+    pointerEvents: 'none',
+  });
+  heartbeat.animate(
+    [{ opacity: 0.2, transform: 'scale(0.8)' }, { opacity: 0.8, transform: 'scale(1.2)' }],
+    { duration: 800, iterations: Infinity, direction: 'alternate', easing: 'ease-in-out' }
+  );
+  document.body.appendChild(heartbeat);
+
+  const cursor = document.createElement('div');
+  cursor.id = '__pias_cursor';
+  Object.assign(cursor.style, {
+    position: 'fixed', width: '20px', height: '20px', borderRadius: '50%',
+    background: 'rgba(239,68,68,0.85)', border: '2px solid white',
+    boxShadow: '0 0 8px rgba(239,68,68,0.5)', zIndex: '2147483647',
+    pointerEvents: 'none', transition: 'left 0.3s ease, top 0.3s ease',
+    left: '-40px', top: '-40px', transform: 'translate(-50%,-50%)',
+  });
+  document.body.appendChild(cursor);
+
+  const ripple = document.createElement('div');
+  ripple.id = '__pias_ripple';
+  Object.assign(ripple.style, {
+    position: 'fixed', width: '40px', height: '40px', borderRadius: '50%',
+    border: '2px solid rgba(239,68,68,0.6)', zIndex: '2147483646',
+    pointerEvents: 'none', opacity: '0', transform: 'translate(-50%,-50%) scale(0.5)',
+    left: '-40px', top: '-40px',
+  });
+  document.body.appendChild(ripple);
+
+  const toast = document.createElement('div');
+  toast.id = '__pias_toast';
+  Object.assign(toast.style, {
+    position: 'fixed', bottom: '20px', left: '50%', transform: 'translateX(-50%)',
+    background: 'rgba(0,0,0,0.85)', color: '#22c55e', padding: '8px 16px',
+    borderRadius: '8px', fontFamily: 'monospace', fontSize: '14px',
+    zIndex: '2147483647', pointerEvents: 'none', opacity: '0',
+    transition: 'opacity 0.2s', maxWidth: '80%', whiteSpace: 'nowrap',
+    overflow: 'hidden', textOverflow: 'ellipsis', border: '1px solid rgba(34,197,94,0.3)',
+  });
+  document.body.appendChild(toast);
+
+  window.__pias_moveCursor = (x, y) => {
+    cursor.style.left = x + 'px'; cursor.style.top = y + 'px';
+  };
+  window.__pias_showClick = (x, y) => {
+    cursor.style.left = x + 'px'; cursor.style.top = y + 'px';
+    ripple.style.left = x + 'px'; ripple.style.top = y + 'px';
+    ripple.style.opacity = '1'; ripple.style.transform = 'translate(-50%,-50%) scale(0.5)';
+    setTimeout(() => { ripple.style.transform = 'translate(-50%,-50%) scale(2)'; ripple.style.opacity = '0'; }, 50);
+  };
+  window.__pias_showToast = (msg) => {
+    toast.textContent = msg; toast.style.opacity = '1';
+    clearTimeout(window.__pias_toastTimer);
+    window.__pias_toastTimer = setTimeout(() => { toast.style.opacity = '0'; }, 2500);
+  };
+}
+`;
+var McpBrowserManager = class {
+  constructor() {
+    this.client = null;
+    this.vm = null;
+    this.screencast = null;
+    // Track cursor position server-side so it persists across navigations
+    this.cursorX = 640;
+    // Start roughly center-screen
+    this.cursorY = 400;
+    /** Directory where Playwright saves the video recording (set by launchLocal). */
+    this.videoDir = null;
+  }
+  /** Get the screencast WebSocket URL for direct client connection. */
+  get screencastUrl() {
+    return this.vm?.screencastUrl ?? null;
+  }
+  /** Get the input WebSocket URL for user input injection. */
+  get inputUrl() {
+    return this.vm?.inputUrl ?? null;
+  }
+  /** Get the VNC WebSocket URL for noVNC connection. */
+  get vncUrl() {
+    return this.vm?.vncUrl ?? null;
+  }
+  /** Get the Freestyle VM ID for external lifecycle management. */
+  get vmId() {
+    return this.vm?.vmId ?? null;
+  }
+  /** Launch browser in a remote Freestyle VM (production). */
+  async launch() {
+    const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+    this.vm = await createTestVm();
+    console.log(JSON.stringify({ event: "browser.mcp.connect_start", vmId: this.vm.vmId, sseUrl: this.vm.sseUrl, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+    const tConn = Date.now();
+    const transport = new SSEClientTransport(new URL(this.vm.sseUrl));
+    this.client = new Client(
+      { name: "assrt", version: "1.0.0" },
+      { capabilities: {} }
+    );
+    await this.client.connect(transport);
+    console.log(JSON.stringify({ event: "browser.mcp.connected", vmId: this.vm.vmId, durationMs: Date.now() - tConn, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+  }
+  /** Launch browser locally via Playwright MCP over stdio (CLI mode).
+   *  @param videoDir — Optional directory for Playwright video recording. If provided, a config
+   *  file is written with recordVideo enabled and passed to the MCP server via --config. */
+  async launchLocal(videoDir) {
+    const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+    const { dirname, join: join2 } = await import("path");
+    const { tmpdir } = await import("os");
+    const { createRequire } = await import("module");
+    const require_ = createRequire(import.meta.url);
+    const pkgDir = dirname(require_.resolve("@playwright/mcp/package.json"));
+    const cliPath = join2(pkgDir, "cli.js");
+    console.log("[browser] spawning local Playwright MCP via stdio");
+    const tConn = Date.now();
+    const userDataDir = join2(tmpdir(), `assrt-browser-${Date.now()}`);
+    const args = [cliPath, "--headless", "--viewport-size", "1600x900", "--user-data-dir", userDataDir];
+    if (videoDir) {
+      const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
+      mkdirSync2(videoDir, { recursive: true });
+      const config = {
+        browser: {
+          contextOptions: {
+            recordVideo: {
+              dir: videoDir,
+              size: { width: 1600, height: 900 }
+            }
+          }
+        }
+      };
+      const configPath = join2(tmpdir(), `assrt-pw-config-${Date.now()}.json`);
+      writeFileSync2(configPath, JSON.stringify(config));
+      args.push("--config", configPath);
+      this.videoDir = videoDir;
+      console.log(`[browser] video recording enabled \u2192 ${videoDir}`);
+    }
+    const transport = new StdioClientTransport({
+      command: process.execPath,
+      args,
+      stderr: "pipe"
+    });
+    this.client = new Client(
+      { name: "assrt", version: "1.0.0" },
+      { capabilities: {} }
+    );
+    await this.client.connect(transport);
+    console.log(
+      `[browser] local MCP connected in ${((Date.now() - tConn) / 1e3).toFixed(1)}s`
+    );
+  }
+  // ── CDP Screencast lifecycle ──
+  /**
+   * Start streaming JPEG frames from the remote browser via CDP screencast.
+   * Connects to the in-VM proxy's /screencast WebSocket endpoint on port 443.
+   * Should be called after the first navigation so a page target exists.
+   */
+  async startScreencast(onFrame) {
+    if (this.screencast || !this.vm) return;
+    this.screencast = new RemoteScreencastSession(this.vm.screencastUrl, onFrame);
+    try {
+      await this.screencast.start();
+    } catch (err) {
+      console.warn("[browser] screencast start failed, falling back to SSE screenshots:", err.message);
+      this.screencast = null;
+    }
+  }
+  /** Stop the screencast stream. */
+  async stopScreencast() {
+    if (this.screencast) {
+      await this.screencast.stop();
+      this.screencast = null;
+    }
+  }
+  /** Whether the screencast is currently active. */
+  get isScreencasting() {
+    return this.screencast !== null;
+  }
+  /** Call a Playwright MCP tool by name. */
+  async callTool(name, args = {}) {
+    if (!this.client) throw new Error("MCP client not connected");
+    const t = Date.now();
+    const argSummary = name === "browser_navigate" ? ` url=${args.url}` : name === "browser_type" ? ` text=${JSON.stringify(args.text).slice(0, 40)}` : name === "browser_click" ? ` el=${JSON.stringify(args.element).slice(0, 40)}` : "";
+    try {
+      const result = await this.client.callTool({
+        name,
+        arguments: args
+      });
+      const dt = Date.now() - t;
+      const err = result.isError ? " ERROR" : "";
+      console.log(`[mcp] ${name}${argSummary} (${dt}ms)${err}`);
+      return result;
+    } catch (e) {
+      console.log(
+        `[mcp] ${name}${argSummary} THREW after ${Date.now() - t}ms: ${e.message}`
+      );
+      throw e;
+    }
+  }
+  // ── Visual overlay helpers ──
+  /** Inject cursor + toast overlays into the page (safe to call multiple times).
+   *  After injection, restores cursor to its last known position instantly
+   *  (no transition) so it doesn't animate from off-screen. */
+  async injectOverlay() {
+    try {
+      await this.callTool("browser_evaluate", {
+        "function": `() => {
+          ${CURSOR_INJECT_SCRIPT}
+          // Restore cursor to last known position without animation
+          const c = document.getElementById('__pias_cursor');
+          if (c) {
+            c.style.transition = 'none';
+            c.style.left = '${this.cursorX}px';
+            c.style.top = '${this.cursorY}px';
+            // Re-enable smooth transition after a tick
+            setTimeout(() => { c.style.transition = 'left 0.3s ease, top 0.3s ease'; }, 50);
+          }
+        }`
+      });
+    } catch {
+    }
+  }
+  /** Move cursor smoothly to an element and show click ripple.
+   *  The cursor glides from its previous position via CSS transition.
+   *  Updates the tracked position so it persists across navigations. */
+  async showClickAt(element, ref) {
+    try {
+      await this.injectOverlay();
+      const sel = JSON.stringify(element);
+      const result = await this.callTool("browser_evaluate", {
+        "function": `() => {
+          const sel = ${sel};
+          const selLower = sel.toLowerCase();
+          let el = null;
+          try { el = document.querySelector(sel); } catch {}
+          if (!el) {
+            const candidates = document.querySelectorAll('a, button, input, [role="button"], select, textarea, label, [onclick], [href]');
+            const words = selLower.split(/\\s+/).filter(w => w.length > 2);
+            let bestScore = 0;
+            for (const e of candidates) {
+              const txt = (e.textContent || '').trim().toLowerCase();
+              if (!txt) continue;
+              if (txt === selLower) { el = e; break; }
+              let score = 0;
+              if (txt.includes(selLower)) score = 3;
+              else if (selLower.includes(txt) && txt.length > 2) score = 2;
+              else {
+                const matched = words.filter(w => txt.includes(w)).length;
+                if (matched > 0) score = matched / words.length;
+              }
+              if (score > bestScore) { bestScore = score; el = e; }
+            }
+          }
+          if (el) {
+            const r = el.getBoundingClientRect();
+            const x = r.left + r.width / 2;
+            const y = r.top + r.height / 2;
+            window.__pias_showClick?.(x, y);
+            return JSON.stringify({ x, y });
+          }
+          return null;
+        }`
+      });
+      const text = extractText(result);
+      if (text) {
+        try {
+          const parsed = JSON.parse(text.replace(/^.*?(\{.*\}).*$/, "$1"));
+          if (parsed && typeof parsed.x === "number") {
+            this.cursorX = Math.round(parsed.x);
+            this.cursorY = Math.round(parsed.y);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /** Show a keystroke toast at the bottom of the page. */
+  async showKeystroke(label) {
+    try {
+      await this.injectOverlay();
+      await this.callTool("browser_evaluate", {
+        "function": `() => { window.__pias_showToast?.(${JSON.stringify(label)}); }`
+      });
+    } catch {
+    }
+  }
+  // ── Convenience methods mapping to Playwright MCP tools ──
+  async navigate(url) {
+    const result = await this.callTool("browser_navigate", { url });
+    await this.injectOverlay();
+    return extractText(result);
+  }
+  async snapshot() {
+    const result = await this.callTool("browser_snapshot");
+    return extractText(result);
+  }
+  async click(element, ref) {
+    await this.showClickAt(element, ref);
+    await new Promise((r) => setTimeout(r, 400));
+    const args = { element };
+    if (ref) args.ref = ref;
+    const result = await this.callTool("browser_click", args);
+    return extractText(result);
+  }
+  async type(element, text, ref) {
+    await this.showClickAt(element, ref);
+    await new Promise((r) => setTimeout(r, 400));
+    await this.showKeystroke(`\u2328 typing: "${text.slice(0, 40)}${text.length > 40 ? "\u2026" : ""}"`);
+    const args = { element, text };
+    if (ref) args.ref = ref;
+    const result = await this.callTool("browser_type", args);
+    return extractText(result);
+  }
+  async selectOption(element, values) {
+    await this.showClickAt(element);
+    await new Promise((r) => setTimeout(r, 400));
+    const result = await this.callTool("browser_select_option", {
+      element,
+      values
+    });
+    return extractText(result);
+  }
+  async screenshot() {
+    const result = await this.callTool("browser_take_screenshot", { type: "jpeg", quality: 50 });
+    for (const content of result.content || []) {
+      if (content.type === "image") return content.data || null;
+    }
+    return null;
+  }
+  async pressKey(key) {
+    await this.showKeystroke(`\u2328 key: ${key}`);
+    const result = await this.callTool("browser_press_key", { key });
+    return extractText(result);
+  }
+  async scroll(x, y) {
+    const result = await this.callTool("browser_scroll", { x, y });
+    return extractText(result);
+  }
+  async waitForText(text, timeout) {
+    const args = { text };
+    if (timeout) args.timeout = timeout;
+    const result = await this.callTool("browser_wait_for", args);
+    return extractText(result);
+  }
+  async evaluate(expression) {
+    const fn = expression.includes("=>") ? expression : `() => (${expression})`;
+    const result = await this.callTool("browser_evaluate", { "function": fn });
+    return extractText(result);
+  }
+  /** Trigger ffmpeg encoding of captured screencast frames on the VM. */
+  async encodeVideo() {
+    if (!this.vm) return false;
+    const host = this.vm.sseUrl.replace(/\/sse$/, "").replace(/^https?:\/\//, "");
+    const encodeUrl = `https://${host}/video/encode`;
+    console.log(`[browser] triggering video encode at ${encodeUrl}`);
+    try {
+      const resp = await fetch(encodeUrl, { method: "POST" });
+      if (!resp.ok) {
+        const text = await resp.text();
+        console.log(`[browser] video encode failed: ${resp.status} ${text}`);
+        return false;
+      }
+      const result = await resp.json();
+      console.log(`[browser] video encoded: ${result.frames} frames, ${result.sizeBytes} bytes`);
+      return true;
+    } catch (err) {
+      console.error(`[browser] video encode error:`, err);
+      return false;
+    }
+  }
+  /** Download the encoded video from the remote VM. Call encodeVideo() first. */
+  async getVideoBuffer() {
+    if (!this.vm) return null;
+    const host = this.vm.sseUrl.replace(/\/sse$/, "").replace(/^https?:\/\//, "");
+    const videoUrl = `https://${host}/video`;
+    console.log(`[browser] downloading video from ${videoUrl}`);
+    try {
+      const resp = await fetch(videoUrl);
+      if (!resp.ok) {
+        console.log(`[browser] video download failed: ${resp.status}`);
+        return null;
+      }
+      const arrayBuf = await resp.arrayBuffer();
+      console.log(`[browser] video downloaded: ${arrayBuf.byteLength} bytes`);
+      return Buffer.from(arrayBuf);
+    } catch (err) {
+      console.error(`[browser] video download error:`, err);
+      return null;
+    }
+  }
+  async close(opts) {
+    await this.stopScreencast();
+    if (this.client) {
+      try {
+        await this.callTool("browser_close");
+      } catch {
+      }
+      try {
+        await this.client.close();
+      } catch {
+      }
+      this.client = null;
+    }
+    if (this.vm && !opts?.skipVmDestroy) {
+      const vmId = this.vm.vmId;
+      this.vm = null;
+      console.log(`[browser] close() \u2192 destroying VM ${vmId}`);
+      destroyTestVm(vmId).catch(
+        (err) => console.error(`[browser] failed to destroy VM ${vmId}:`, err)
+      );
+    }
+  }
+  /** Destroy the VM. Call after getVideoBuffer() if you used skipVmDestroy. */
+  async destroyVm() {
+    if (this.vm) {
+      const vmId = this.vm.vmId;
+      this.vm = null;
+      console.log(`[browser] destroyVm() \u2192 destroying VM ${vmId}`);
+      destroyTestVm(vmId).catch(
+        (err) => console.error(`[browser] failed to destroy VM ${vmId}:`, err)
+      );
+    }
+  }
+};
+function extractText(result) {
+  return (result.content || []).filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+}
+
+// src/core/agent.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { GoogleGenAI, Type } from "@google/genai";
+
+// src/core/email.ts
+var BASE = "https://api.internal.temp-mail.io/api/v3";
+async function fetchJson(url, options) {
+  const res = await fetch(url, { ...options, signal: AbortSignal.timeout(15e3) });
+  const text = await res.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`API returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+  }
+}
+var DisposableEmail = class _DisposableEmail {
+  constructor(address, token) {
+    this.address = address;
+    this.token = token;
+  }
+  /** Create a new random disposable email address */
+  static async create() {
+    const data = await fetchJson(
+      `${BASE}/email/new`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ min_name_length: 10, max_name_length: 10 })
+      }
+    );
+    if (!data.email || !data.token) {
+      throw new Error(`Invalid response: ${JSON.stringify(data)}`);
+    }
+    return new _DisposableEmail(data.email, data.token);
+  }
+  /** Check inbox for messages */
+  async getMessages() {
+    return fetchJson(`${BASE}/email/${this.address}/messages`);
+  }
+  /**
+   * Wait for a new email to arrive.
+   * Polls every `intervalMs` for up to `timeoutMs`.
+   */
+  async waitForEmail(timeoutMs = 6e4, intervalMs = 3e3) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const messages = await this.getMessages();
+      if (messages.length > 0) {
+        return messages[messages.length - 1];
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    return null;
+  }
+  /**
+   * Wait for a verification email and extract the code from it.
+   */
+  async waitForVerificationCode(timeoutMs = 6e4, intervalMs = 3e3) {
+    const email = await this.waitForEmail(timeoutMs, intervalMs);
+    if (!email) return null;
+    let plainText = email.body_text || "";
+    if (!plainText && email.body_html) {
+      plainText = email.body_html.replace(/<[^>]*>/g, " ").replace(/&nbsp;/g, " ").replace(/&#?\w+;/g, " ").replace(/\s+/g, " ").trim();
+    }
+    const patterns = [
+      /(?:code|Code|CODE)[:\s]+(\d{4,8})/,
+      /(?:verification|Verification)[:\s]+(\d{4,8})/,
+      /(?:OTP|otp)[:\s]+(\d{4,8})/,
+      /(?:pin|PIN|Pin)[:\s]+(\d{4,8})/,
+      /\b(\d{6})\b/,
+      // 6-digit (most common)
+      /\b(\d{4})\b/,
+      // 4-digit
+      /\b(\d{8})\b/
+      // 8-digit
+    ];
+    for (const pattern of patterns) {
+      const match = plainText.match(pattern);
+      if (match) {
+        return {
+          code: match[1],
+          from: email.from,
+          subject: email.subject,
+          body: plainText.slice(0, 500)
+        };
+      }
+    }
+    return {
+      code: "",
+      from: email.from,
+      subject: email.subject,
+      body: plainText.slice(0, 500)
+    };
+  }
+};
+
+// src/core/agent.ts
+var MAX_STEPS_PER_SCENARIO = 60;
+var MAX_CONVERSATION_TURNS = Infinity;
+var DEFAULT_ANTHROPIC_MODEL = "claude-haiku-4-5-20251001";
+var DEFAULT_GEMINI_MODEL = "gemini-3.1-pro-preview";
+var TOOLS = [
+  {
+    name: "navigate",
+    description: "Navigate to a URL.",
+    input_schema: {
+      type: "object",
+      properties: { url: { type: "string", description: "URL to navigate to" } },
+      required: ["url"]
+    }
+  },
+  {
+    name: "snapshot",
+    description: "Get the accessibility tree of the current page. Returns elements with [ref=eN] references you can use for click/type. ALWAYS call this before interacting with elements.",
+    input_schema: { type: "object", properties: {} }
+  },
+  {
+    name: "click",
+    description: "Click an element. Use the element description from the snapshot and optionally the ref ID.",
+    input_schema: {
+      type: "object",
+      properties: {
+        element: { type: "string", description: "Human-readable element description, e.g. 'Submit button' or 'Sign In link'" },
+        ref: { type: "string", description: "Exact ref from snapshot, e.g. 'e5'. Preferred when available." }
+      },
+      required: ["element"]
+    }
+  },
+  {
+    name: "type_text",
+    description: "Type text into an input field. Clears existing content first.",
+    input_schema: {
+      type: "object",
+      properties: {
+        element: { type: "string", description: "Human-readable element description" },
+        text: { type: "string", description: "Text to type" },
+        ref: { type: "string", description: "Exact ref from snapshot" }
+      },
+      required: ["element", "text"]
+    }
+  },
+  {
+    name: "select_option",
+    description: "Select an option from a dropdown.",
+    input_schema: {
+      type: "object",
+      properties: {
+        element: { type: "string", description: "Element description" },
+        values: { type: "array", items: { type: "string" }, description: "Values to select" }
+      },
+      required: ["element", "values"]
+    }
+  },
+  {
+    name: "scroll",
+    description: "Scroll the page. Positive y scrolls down, negative scrolls up.",
+    input_schema: {
+      type: "object",
+      properties: {
+        x: { type: "number", description: "Horizontal scroll pixels (default: 0)" },
+        y: { type: "number", description: "Vertical scroll pixels (default: 400 for down, -400 for up)" }
+      },
+      required: ["y"]
+    }
+  },
+  {
+    name: "press_key",
+    description: "Press a keyboard key. E.g. Enter, Tab, Escape.",
+    input_schema: {
+      type: "object",
+      properties: { key: { type: "string", description: "Key to press" } },
+      required: ["key"]
+    }
+  },
+  {
+    name: "wait",
+    description: "Wait for text to appear on the page, or wait a fixed duration.",
+    input_schema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to wait for (preferred)" },
+        ms: { type: "number", description: "Milliseconds to wait (fallback, max 10000)" }
+      }
+    }
+  },
+  {
+    name: "screenshot",
+    description: "Take a screenshot of the current page.",
+    input_schema: { type: "object", properties: {} }
+  },
+  {
+    name: "evaluate",
+    description: "Run JavaScript in the browser and return the result.",
+    input_schema: {
+      type: "object",
+      properties: { expression: { type: "string", description: "JavaScript expression to evaluate" } },
+      required: ["expression"]
+    }
+  },
+  {
+    name: "create_temp_email",
+    description: "Create a disposable email address. Use BEFORE filling signup forms.",
+    input_schema: { type: "object", properties: {} }
+  },
+  {
+    name: "wait_for_verification_code",
+    description: "Wait for a verification/OTP code at the disposable email. Polls up to 60s.",
+    input_schema: {
+      type: "object",
+      properties: { timeout_seconds: { type: "number", description: "Max seconds to wait (default 60)" } }
+    }
+  },
+  {
+    name: "check_email_inbox",
+    description: "Check the disposable email inbox.",
+    input_schema: { type: "object", properties: {} }
+  },
+  {
+    name: "assert",
+    description: "Make a test assertion about the current page state.",
+    input_schema: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: "What you are asserting" },
+        passed: { type: "boolean", description: "Whether the assertion passed" },
+        evidence: { type: "string", description: "Evidence for the result" }
+      },
+      required: ["description", "passed", "evidence"]
+    }
+  },
+  {
+    name: "complete_scenario",
+    description: "Mark the current test scenario as complete.",
+    input_schema: {
+      type: "object",
+      properties: {
+        summary: { type: "string", description: "Summary of what was tested" },
+        passed: { type: "boolean", description: "Whether the scenario passed overall" }
+      },
+      required: ["summary", "passed"]
+    }
+  },
+  {
+    name: "suggest_improvement",
+    description: "Report an obvious bug or UX issue in the application.",
+    input_schema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short title" },
+        severity: { type: "string", description: "critical, major, or minor" },
+        description: { type: "string", description: "What is wrong" },
+        suggestion: { type: "string", description: "How to fix it" }
+      },
+      required: ["title", "severity", "description", "suggestion"]
+    }
+  },
+  {
+    name: "http_request",
+    description: "Make an HTTP request to an external API. Use for verifying webhooks, polling APIs (Telegram, Slack, GitHub), or any external service interaction.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Full URL to request" },
+        method: { type: "string", description: "HTTP method: GET, POST, PUT, DELETE (default: GET)" },
+        headers: { type: "object", description: "Request headers as key-value pairs" },
+        body: { type: "string", description: "Request body (JSON string for POST/PUT)" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "wait_for_stable",
+    description: "Wait until the page content stops changing (no new DOM mutations for the specified stable period). Use after triggering async actions like chat AI responses, loading states, or search results populating.",
+    input_schema: {
+      type: "object",
+      properties: {
+        timeout_seconds: { type: "number", description: "Max seconds to wait (default 30)" },
+        stable_seconds: { type: "number", description: "Seconds of no DOM changes to consider stable (default 2)" }
+      }
+    }
+  }
+];
+var SYSTEM_PROMPT = `You are an automated web testing agent called Assrt. Your job is to systematically test web applications by executing test scenarios.
+
+## How You Work
+1. You receive test scenario(s) to execute on a web application
+2. You interact with the page using the provided tools
+3. You verify expected behavior using assertions
+4. You report results clearly
+
+## CRITICAL Rules
+- ALWAYS call snapshot FIRST to get the accessibility tree with element refs
+- Use the ref IDs from snapshots (e.g. ref="e5") when clicking or typing. This is faster and more reliable than text matching.
+- After each action, call snapshot again to see the updated page state
+- Make assertions to verify expected behavior (use the assert tool)
+- Call complete_scenario when done
+
+## Selector Strategy (Playwright MCP refs)
+1. Call snapshot to get the accessibility tree
+2. Find the element you want to interact with in the tree
+3. Use its ref value (e.g. "e5") in the ref parameter of click/type_text
+4. Also provide a human-readable element description for logging
+5. If a ref is stale (action fails), call snapshot again to get fresh refs
+
+## Error Recovery
+When an action fails:
+1. Call snapshot to see what is currently on the page
+2. The page may have changed (modal appeared, navigation happened)
+3. Try using a different ref or approach
+4. If stuck after 3 attempts, scroll and retry
+5. If truly stuck, mark as failed with evidence and call complete_scenario
+
+## Email Verification Strategy
+When you encounter a login/signup form that requires an email:
+1. FIRST call create_temp_email to get a disposable email
+2. Use THAT email in the signup form
+3. After submitting, call wait_for_verification_code for the OTP
+4. Enter the verification code into the form
+   - If the code input is split across multiple single-character fields (common OTP pattern), do NOT type into each field individually. Instead, find the parent container of the input fields in the snapshot (the generic element that wraps all the textboxes), then use evaluate on that container to dispatch a paste event:
+     \`(el) => { const dt = new DataTransfer(); dt.setData('text/plain', 'CODE_HERE'); el.dispatchEvent(new ClipboardEvent('paste', {clipboardData: dt, bubbles: true, cancelable: true})); return 'pasted'; }\`
+     Pass the container's ref to evaluate so it receives the element. Replace CODE_HERE with the actual code. Then call snapshot to verify all digits filled correctly. This is MUCH faster than typing into 6 fields one at a time.
+
+## Scenario Continuity
+- Scenarios run in the SAME browser session
+- Cookies, auth state carry over between scenarios
+- Take advantage of existing state rather than starting from scratch
+
+## External API Verification
+When testing integrations (Telegram, Slack, GitHub, etc.):
+1. Use http_request to call external APIs (e.g. poll Telegram Bot API for messages)
+2. This lets you verify that actions in the web app produced the expected external effect
+3. Example: after connecting Telegram in a web app, use http_request to call https://api.telegram.org/bot<token>/getUpdates to verify messages arrived
+
+## Waiting for Async Content
+When the page has loading states, streaming AI responses, or async content:
+1. Use wait_for_stable to wait until the DOM stops changing
+2. This is better than wait with a fixed time because it adapts to actual load speed
+3. Use it after submitting forms, sending chat messages, or triggering any async operation
+4. Then call snapshot to see the final state`;
+var DISCOVERY_SYSTEM_PROMPT = `You are a QA engineer generating quick test cases for an AI browser agent that just landed on a new page. The agent can click, type, scroll, and verify visible text.
+
+## Output Format
+#Case 1: [short name]
+[1-2 lines: what to click/type and what to verify]
+
+## Rules
+- Generate only 1-2 cases
+- Each case must be completable in 3-4 actions max
+- Reference ACTUAL buttons/links/inputs visible on the page
+- Do NOT generate login/signup cases
+- Do NOT generate cases about CSS, responsive layout, or performance`;
+var MAX_CONCURRENT_DISCOVERIES = 3;
+var MAX_DISCOVERED_PAGES = 20;
+var SKIP_URL_PATTERNS = [/\/logout/i, /\/api\//i, /^javascript:/i, /^about:blank/i, /^data:/i, /^chrome/i];
+var GEMINI_FUNCTION_DECLARATIONS = TOOLS.map((t) => ({
+  name: t.name,
+  description: t.description,
+  parameters: {
+    type: Type.OBJECT,
+    properties: Object.fromEntries(
+      Object.entries(t.input_schema.properties || {}).map(
+        ([k, v]) => {
+          const vTyped = v;
+          let gType;
+          if (vTyped.type === "boolean") gType = Type.BOOLEAN;
+          else if (vTyped.type === "number") gType = Type.NUMBER;
+          else if (vTyped.type === "array") gType = Type.ARRAY;
+          else gType = Type.STRING;
+          const entry = { type: gType, description: vTyped.description || "" };
+          if (vTyped.type === "array" && vTyped.items) {
+            entry.items = { type: Type.STRING };
+          }
+          return [k, entry];
+        }
+      )
+    ),
+    required: t.input_schema.required || []
+  }
+}));
+var TestAgent = class {
+  constructor(apiKey, emit, model, provider, broadcastFrame, mode, authType, videoDir) {
+    this.anthropic = null;
+    this.gemini = null;
+    this.tempEmail = null;
+    this.discoveredUrls = /* @__PURE__ */ new Set();
+    this.activeDiscoveries = 0;
+    this.browserBusy = false;
+    this.pendingDiscoveryUrls = [];
+    this.broadcastFrame = null;
+    /**
+     * @param broadcastFrame — Optional callback for CDP screencast frames.
+     *   When provided, replaces the old 1.5s screenshot polling with continuous
+     *   ~15fps streaming. When absent (e.g., plan generation), falls back to
+     *   SSE screenshot emits.
+     * @param mode — "local" spawns a local Playwright MCP over stdio,
+     *   "remote" (default) uses a Freestyle VM.
+     */
+    /**
+     * @param authType — "apiKey" for regular API keys (X-Api-Key header),
+     *   "oauth" for Claude Code OAuth tokens (Authorization: Bearer + beta header).
+     */
+    /** Directory for video recording output. Only used in local mode. */
+    this.videoDir = null;
+    this.provider = provider === "gemini" ? "gemini" : "anthropic";
+    this.browser = new McpBrowserManager();
+    this.emit = emit;
+    this.broadcastFrame = broadcastFrame || null;
+    this.mode = mode || "remote";
+    this.videoDir = videoDir || null;
+    if (this.provider === "gemini") {
+      this.gemini = new GoogleGenAI({ apiKey });
+      this.model = model || process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL;
+    } else {
+      if (authType === "oauth") {
+        this.anthropic = new Anthropic({
+          authToken: apiKey,
+          defaultHeaders: { "anthropic-beta": "oauth-2025-04-20" }
+        });
+      } else {
+        this.anthropic = new Anthropic({ apiKey });
+      }
+      this.model = model || process.env.ANTHROPIC_MODEL || DEFAULT_ANTHROPIC_MODEL;
+    }
+  }
+  async run(url, scenariosText) {
+    const startTime = Date.now();
+    console.log(JSON.stringify({ event: "agent.run.start", url, mode: this.mode, model: this.model, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+    if (this.mode === "local") {
+      this.emit("status", { message: "Launching local browser..." });
+      await this.browser.launchLocal(this.videoDir || void 0);
+    } else {
+      this.emit("status", { message: "Provisioning cloud browser VM..." });
+      await this.browser.launch();
+    }
+    const launchMs = Date.now() - startTime;
+    console.log(JSON.stringify({ event: "agent.browser.launched", durationMs: launchMs, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+    this.emit("status", { message: "Browser launched via Playwright MCP" });
+    const screencastUrl = this.browser.screencastUrl;
+    if (screencastUrl) {
+      this.emit("screencast_url", { url: screencastUrl });
+    }
+    const inputUrl = this.browser.inputUrl;
+    if (inputUrl) {
+      this.emit("input_url", { url: inputUrl });
+    }
+    const vncUrl = this.browser.vncUrl;
+    if (vncUrl) {
+      this.emit("vnc_url", { url: vncUrl });
+    }
+    const vmId = this.browser.vmId;
+    if (vmId) {
+      this.emit("vm_id", { vmId });
+    }
+    const tNav = Date.now();
+    await this.browser.navigate(url);
+    console.log(JSON.stringify({ event: "agent.navigate.done", url, durationMs: Date.now() - tNav, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+    this.emit("status", { message: `Navigated to ${url}` });
+    this.queueDiscoverPage(url);
+    const scenarios = this.parseScenarios(scenariosText);
+    const results = [];
+    try {
+      for (let i = 0; i < scenarios.length; i++) {
+        const scenario = scenarios[i];
+        this.emit("scenario_start", { index: i, name: scenario.name, total: scenarios.length });
+        try {
+          const result = await this.runScenario(
+            url,
+            scenario.name,
+            scenario.steps,
+            i === 0,
+            results.map((r) => `${r.name}: ${r.passed ? "PASSED" : "FAILED"} \u2014 ${r.summary}`)
+          );
+          results.push(result);
+          this.emit("scenario_complete", { index: i, name: scenario.name, passed: result.passed, summary: result.summary });
+          await this.flushDiscovery().catch(() => {
+          });
+        } catch (scenarioErr) {
+          const errMsg = scenarioErr instanceof Error ? scenarioErr.message : String(scenarioErr);
+          this.emit("reasoning", { text: `Scenario "${scenario.name}" crashed: ${errMsg}. Moving to next scenario.` });
+          const failedResult = {
+            name: scenario.name,
+            passed: false,
+            steps: [],
+            assertions: [],
+            summary: `Error: ${errMsg.slice(0, 200)}`,
+            duration: 0
+          };
+          results.push(failedResult);
+          this.emit("scenario_complete", { index: i, name: scenario.name, passed: false, summary: failedResult.summary });
+        }
+      }
+    } finally {
+    }
+    const report = {
+      url,
+      scenarios: results,
+      totalDuration: Date.now() - startTime,
+      passedCount: results.filter((r) => r.passed).length,
+      failedCount: results.filter((r) => !r.passed).length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("report", report);
+    return report;
+  }
+  /** Encode and download the screencast recording from the VM.
+   *  Does NOT destroy the VM (it stays alive for user takeover). */
+  async finalizeVideo() {
+    try {
+      const encoded = await this.browser.encodeVideo();
+      if (!encoded) return null;
+      return await this.browser.getVideoBuffer();
+    } catch (err) {
+      console.error("[agent] finalizeVideo error:", err);
+      return null;
+    }
+  }
+  /** Close the browser. For local mode this finalizes the video recording. */
+  async close() {
+    try {
+      await this.browser.close();
+    } catch {
+    }
+  }
+  /* ── Continuous page discovery ── */
+  normalizeUrl(url) {
+    try {
+      const u = new URL(url);
+      return `${u.origin}${u.pathname}`.replace(/\/$/, "");
+    } catch {
+      return url;
+    }
+  }
+  shouldSkipUrl(url) {
+    return SKIP_URL_PATTERNS.some((p) => p.test(url));
+  }
+  queueDiscoverPage(url) {
+    const normalized = this.normalizeUrl(url);
+    if (this.discoveredUrls.has(normalized)) return;
+    if (this.discoveredUrls.size >= MAX_DISCOVERED_PAGES) return;
+    if (this.shouldSkipUrl(url)) return;
+    this.discoveredUrls.add(normalized);
+    this.pendingDiscoveryUrls.push(normalized);
+  }
+  async flushDiscovery() {
+    if (this.browserBusy || this.pendingDiscoveryUrls.length === 0) return;
+    if (this.activeDiscoveries >= MAX_CONCURRENT_DISCOVERIES) return;
+    const urls = this.pendingDiscoveryUrls.splice(0);
+    for (const normalized of urls) {
+      try {
+        const snapshotText = await this.browser.snapshot();
+        const screenshotData = await this.browser.screenshot();
+        this.emit("page_discovered", { url: normalized, title: "", screenshot: screenshotData });
+        this.activeDiscoveries++;
+        this.generateDiscoveryCases(normalized, snapshotText, screenshotData).catch(() => {
+        }).finally(() => {
+          this.activeDiscoveries--;
+        });
+        break;
+      } catch {
+      }
+    }
+  }
+  async generateDiscoveryCases(url, snapshotText, screenshot) {
+    const prompt = `Analyze this page and generate test cases.
+
+URL: ${url}
+
+Accessibility Tree:
+${snapshotText.slice(0, 4e3)}`;
+    let fullText = "";
+    if (this.provider === "gemini" && this.gemini) {
+      const parts = [];
+      if (screenshot) parts.push({ inlineData: { mimeType: "image/jpeg", data: screenshot } });
+      parts.push({ text: prompt });
+      const response = await this.gemini.models.generateContentStream({
+        model: this.model,
+        contents: [{ role: "user", parts }],
+        config: { systemInstruction: DISCOVERY_SYSTEM_PROMPT }
+      });
+      for await (const chunk of response) {
+        const text = chunk.text || "";
+        if (text) {
+          fullText += text;
+          this.emit("discovered_cases_chunk", { url, text: fullText });
+        }
+      }
+    } else if (this.anthropic) {
+      const content = [];
+      if (screenshot) content.push({ type: "image", source: { type: "base64", media_type: "image/jpeg", data: screenshot } });
+      content.push({ type: "text", text: prompt });
+      const stream = this.anthropic.messages.stream({
+        model: this.model,
+        max_tokens: 1024,
+        system: DISCOVERY_SYSTEM_PROMPT,
+        messages: [{ role: "user", content }]
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          fullText += event.delta.text;
+          this.emit("discovered_cases_chunk", { url, text: fullText });
+        }
+      }
+    }
+    this.emit("discovered_cases_complete", { url, cases: fullText });
+  }
+  parseScenarios(text) {
+    const scenarioRegex = /(?:#?\s*(?:Scenario|Test|Case))\s*\d*[:.]\s*/gi;
+    const parts = text.split(scenarioRegex).filter((s) => s.trim());
+    if (parts.length > 1) {
+      const names = text.match(scenarioRegex) || [];
+      return parts.map((steps, i) => ({
+        name: (names[i] || `Case ${i + 1}`).replace(/^#\s*/, "").replace(/[:.]\s*$/, "").trim(),
+        steps: steps.trim()
+      }));
+    }
+    return [{ name: "Test Scenario", steps: text.trim() }];
+  }
+  async runScenario(baseUrl, scenarioName, scenarioSteps, isFirstScenario, previousSummaries) {
+    const startTime = Date.now();
+    const steps = [];
+    const assertions = [];
+    let stepCounter = 0;
+    let completed = false;
+    let scenarioSummary = "";
+    let scenarioPassed = true;
+    const initialSnapshot = await this.browser.snapshot();
+    const initialScreenshot = await this.browser.screenshot();
+    if (initialScreenshot) {
+      console.log(JSON.stringify({ event: "agent.screenshot.emit", size: initialScreenshot.length, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+      this.emit("screenshot", { base64: initialScreenshot });
+    }
+    if (this.broadcastFrame && this.mode !== "local") {
+      await this.browser.startScreencast(this.broadcastFrame);
+    }
+    let contextInfo = "";
+    if (!isFirstScenario && previousSummaries.length > 0) {
+      contextInfo = `
+
+Previous Scenarios (browser state carries over):
+${previousSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}`;
+    } else {
+      contextInfo = `
+Navigated to: ${baseUrl}`;
+    }
+    const emailInfo = this.tempEmail ? `
+Active disposable email: ${this.tempEmail.address}` : "";
+    const userPrompt = `${contextInfo}${emailInfo}
+
+Current page accessibility tree:
+${initialSnapshot}
+
+---
+Execute this test scenario:
+**${scenarioName}**
+${scenarioSteps}
+
+IMPORTANT: Use snapshot refs (e.g. ref="e5") for reliable element targeting. Call snapshot before each interaction to get fresh refs.
+If login/signup needs email, use create_temp_email first.
+
+Analyze the page, act, make assertions, call complete_scenario when done.`;
+    const messages = this.provider === "gemini" ? [{ role: "user", parts: [
+      ...initialScreenshot ? [{ inlineData: { mimeType: "image/jpeg", data: initialScreenshot } }] : [],
+      { text: userPrompt }
+    ] }] : [{ role: "user", content: [
+      ...initialScreenshot ? [{ type: "image", source: { type: "base64", media_type: "image/jpeg", data: initialScreenshot } }] : [],
+      { type: "text", text: userPrompt }
+    ] }];
+    while (!completed && stepCounter < MAX_STEPS_PER_SCENARIO) {
+      let toolCalls = [];
+      for (let attempt = 0; attempt < 4; attempt++) {
+        try {
+          if (this.provider === "gemini" && this.gemini) {
+            const response = await this.gemini.models.generateContent({
+              model: this.model,
+              contents: messages,
+              config: { tools: [{ functionDeclarations: GEMINI_FUNCTION_DECLARATIONS }], systemInstruction: SYSTEM_PROMPT }
+            });
+            const candidate = response?.candidates?.[0];
+            if (!candidate?.content?.parts) break;
+            const parts = candidate.content.parts;
+            messages.push({ role: "model", parts });
+            for (const p of parts) {
+              if (p.text?.trim()) this.emit("reasoning", { text: p.text });
+            }
+            toolCalls = parts.filter((p) => p.functionCall).map((p) => ({
+              id: `gemini_${Date.now()}_${Math.random()}`,
+              name: p.functionCall.name,
+              args: p.functionCall.args || {}
+            }));
+          } else if (this.anthropic) {
+            const response = await this.anthropic.messages.create({
+              model: this.model,
+              max_tokens: 4096,
+              system: SYSTEM_PROMPT,
+              tools: TOOLS,
+              messages
+            });
+            const content = response.content;
+            for (const b of content) {
+              if (b.type === "text" && b.text.trim()) this.emit("reasoning", { text: b.text });
+            }
+            messages.push({ role: "assistant", content });
+            toolCalls = content.filter((b) => b.type === "tool_use").map((b) => ({
+              id: b.id,
+              name: b.name,
+              args: b.input
+            }));
+            if (toolCalls.length === 0 && response.stop_reason === "end_turn") {
+              completed = true;
+            }
+          }
+          break;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const isRetryable = /529|429|503|overloaded|rate/i.test(msg);
+          if (isRetryable && attempt < 3) {
+            const delay = (attempt + 1) * 5e3;
+            this.emit("reasoning", { text: `API busy (attempt ${attempt + 1}/4), retrying in ${delay / 1e3}s...` });
+            await new Promise((r) => setTimeout(r, delay));
+            continue;
+          }
+          const isFatal = /tool_use|tool_result|invalid_request/i.test(msg);
+          if (isFatal) {
+            this.emit("reasoning", { text: `API error, ending scenario: ${msg.slice(0, 200)}` });
+            scenarioPassed = false;
+            scenarioSummary = `API error: ${msg.slice(0, 200)}`;
+            completed = true;
+            break;
+          }
+          throw err;
+        }
+      }
+      if (toolCalls.length === 0) break;
+      const toolResults = [];
+      for (const toolCall of toolCalls) {
+        this.browserBusy = true;
+        const toolInput = toolCall.args;
+        stepCounter++;
+        let result = "";
+        let stepAction = toolCall.name;
+        let stepDescription = "";
+        let stepStatus = "completed";
+        this.emit("step", { id: stepCounter, action: toolCall.name, description: `Executing ${toolCall.name}...`, status: "running", timestamp: Date.now() });
+        try {
+          switch (toolCall.name) {
+            case "navigate": {
+              let navUrl = toolInput.url || "";
+              if (navUrl.startsWith("/")) {
+                const urlObj = new URL(baseUrl.startsWith("http") ? baseUrl : `https://${baseUrl}`);
+                navUrl = `${urlObj.origin}${navUrl}`;
+              }
+              result = await this.browser.navigate(navUrl);
+              stepDescription = `Navigate to ${navUrl}`;
+              this.queueDiscoverPage(navUrl);
+              break;
+            }
+            case "snapshot": {
+              result = await this.browser.snapshot();
+              stepDescription = "Get page snapshot (accessibility tree)";
+              stepAction = "inspect";
+              break;
+            }
+            case "click": {
+              const element = toolInput.element;
+              const ref = toolInput.ref;
+              result = await this.browser.click(element, ref);
+              stepDescription = `Click "${element}"${ref ? ` [ref=${ref}]` : ""}`;
+              break;
+            }
+            case "type_text": {
+              const element = toolInput.element;
+              const text = toolInput.text;
+              const ref = toolInput.ref;
+              result = await this.browser.type(element, text, ref);
+              stepDescription = `Type "${text}" into "${element}"`;
+              break;
+            }
+            case "select_option": {
+              const element = toolInput.element;
+              const values = toolInput.values || [toolInput.value];
+              result = await this.browser.selectOption(element, values);
+              stepDescription = `Select "${values.join(", ")}" in "${element}"`;
+              break;
+            }
+            case "scroll": {
+              const x = toolInput.x || 0;
+              const y = toolInput.y || 400;
+              result = await this.browser.scroll(x, y);
+              stepDescription = `Scroll ${y > 0 ? "down" : "up"} by ${Math.abs(y)}px`;
+              break;
+            }
+            case "press_key": {
+              const key = toolInput.key;
+              result = await this.browser.pressKey(key);
+              stepDescription = `Press ${key}`;
+              break;
+            }
+            case "wait": {
+              if (toolInput.text) {
+                result = await this.browser.waitForText(toolInput.text, toolInput.ms || 1e4);
+                stepDescription = `Wait for text "${toolInput.text}"`;
+              } else {
+                const ms = Math.min(toolInput.ms || 1e3, 1e4);
+                await new Promise((r) => setTimeout(r, ms));
+                result = `Waited ${ms}ms`;
+                stepDescription = `Wait ${ms}ms`;
+              }
+              break;
+            }
+            case "screenshot": {
+              const data = await this.browser.screenshot();
+              if (data) {
+                this.emit("screenshot", { base64: data });
+                result = "Screenshot taken and sent to client.";
+              } else {
+                result = "Screenshot failed.";
+              }
+              stepDescription = "Take screenshot";
+              stepAction = "inspect";
+              break;
+            }
+            case "evaluate": {
+              const expr = toolInput.expression;
+              result = await this.browser.evaluate(expr);
+              stepDescription = `Evaluate JS: ${expr.slice(0, 80)}`;
+              stepAction = "inspect";
+              break;
+            }
+            case "create_temp_email": {
+              this.tempEmail = await DisposableEmail.create();
+              result = `Created disposable email: ${this.tempEmail.address}
+Use this EXACT email in signup forms.`;
+              stepDescription = `Created temp email: ${this.tempEmail.address}`;
+              stepAction = "email";
+              this.emit("reasoning", { text: `Disposable email created: ${this.tempEmail.address}` });
+              break;
+            }
+            case "wait_for_verification_code": {
+              if (!this.tempEmail) {
+                result = "Error: Call create_temp_email first.";
+                stepStatus = "failed";
+                stepDescription = "No temp email";
+                break;
+              }
+              const timeout = Math.min((toolInput.timeout_seconds || 60) * 1e3, 12e4);
+              stepDescription = `Waiting for code at ${this.tempEmail.address}...`;
+              this.emit("step", { id: stepCounter, action: "email", description: stepDescription, status: "running", timestamp: Date.now() });
+              const cr = await this.tempEmail.waitForVerificationCode(timeout, 3e3);
+              if (cr?.code) {
+                result = `Verification code received: ${cr.code}
+From: ${cr.from}
+Subject: ${cr.subject}`;
+                stepDescription = `Received code: ${cr.code}`;
+                stepAction = "email";
+              } else if (cr) {
+                result = `Email received but no code pattern found.
+From: ${cr.from}
+Subject: ${cr.subject}
+Body: ${cr.body}`;
+                stepDescription = "Email received, manual extraction needed";
+                stepAction = "email";
+              } else {
+                result = `No email within ${timeout / 1e3}s.`;
+                stepStatus = "failed";
+                stepDescription = "Verification email timeout";
+                stepAction = "email";
+              }
+              break;
+            }
+            case "check_email_inbox": {
+              if (!this.tempEmail) {
+                result = "Error: Call create_temp_email first.";
+                stepStatus = "failed";
+                stepDescription = "No temp email";
+                break;
+              }
+              const msgs = await this.tempEmail.getMessages();
+              if (msgs.length === 0) {
+                result = `Inbox empty for ${this.tempEmail.address}.`;
+              } else {
+                const latest = msgs[msgs.length - 1];
+                const body = (latest.body_text || latest.body_html || "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+                result = `${msgs.length} email(s). Latest from: ${latest.from} | Subject: ${latest.subject}
+Body: ${body.slice(0, 500)}`;
+              }
+              stepDescription = `Check inbox (${msgs.length} emails)`;
+              stepAction = "email";
+              break;
+            }
+            case "assert": {
+              const desc = toolInput.description;
+              const passed = toolInput.passed;
+              const evidence = toolInput.evidence;
+              assertions.push({ description: desc, passed, evidence });
+              result = `Assertion ${passed ? "PASSED" : "FAILED"}: ${desc} \u2014 ${evidence}`;
+              stepDescription = `Assert: ${desc}`;
+              stepAction = passed ? "assert_pass" : "assert_fail";
+              if (!passed) scenarioPassed = false;
+              this.emit("assertion", { description: desc, passed, evidence });
+              break;
+            }
+            case "complete_scenario": {
+              scenarioSummary = toolInput.summary;
+              scenarioPassed = toolInput.passed;
+              completed = true;
+              result = "Scenario complete";
+              stepDescription = "Scenario complete";
+              stepAction = "complete";
+              break;
+            }
+            case "suggest_improvement": {
+              const title = toolInput.title;
+              const severity = toolInput.severity;
+              const desc = toolInput.description;
+              const suggestion = toolInput.suggestion;
+              this.emit("improvement_suggestion", { title, severity, description: desc, suggestion });
+              result = `Improvement logged: ${title}`;
+              stepDescription = `Issue: ${title}`;
+              stepAction = "suggestion";
+              break;
+            }
+            case "http_request": {
+              const reqUrl = toolInput.url;
+              const method = (toolInput.method || "GET").toUpperCase();
+              const headers = toolInput.headers || {};
+              const body = toolInput.body;
+              try {
+                const fetchOptions = {
+                  method,
+                  headers: { "Content-Type": "application/json", ...headers }
+                };
+                if (body && method !== "GET" && method !== "HEAD") {
+                  fetchOptions.body = body;
+                }
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 3e4);
+                fetchOptions.signal = controller.signal;
+                const resp = await fetch(reqUrl, fetchOptions);
+                clearTimeout(timeoutId);
+                const respText = await resp.text();
+                const truncated = respText.length > 4e3 ? respText.slice(0, 4e3) + "\n...(truncated)" : respText;
+                result = `HTTP ${resp.status} ${resp.statusText}
+
+${truncated}`;
+                stepDescription = `${method} ${reqUrl} \u2192 ${resp.status}`;
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                result = `HTTP request failed: ${msg}`;
+                stepStatus = "failed";
+                stepDescription = `${method} ${reqUrl} failed`;
+              }
+              stepAction = "http";
+              break;
+            }
+            case "wait_for_stable": {
+              const timeoutSec = Math.min(toolInput.timeout_seconds || 30, 60);
+              const stableSec = Math.min(toolInput.stable_seconds || 2, 10);
+              stepDescription = `Wait for page to stabilize (${stableSec}s quiet, ${timeoutSec}s max)`;
+              this.emit("step", { id: stepCounter, action: "wait", description: stepDescription, status: "running", timestamp: Date.now() });
+              try {
+                await this.browser.evaluate(`
+                  window.__assrt_mutations = 0;
+                  window.__assrt_observer = new MutationObserver((mutations) => {
+                    window.__assrt_mutations += mutations.length;
+                  });
+                  window.__assrt_observer.observe(document.body, {
+                    childList: true, subtree: true, characterData: true
+                  });
+                `);
+                const startMs = Date.now();
+                const timeoutMs = timeoutSec * 1e3;
+                const stableMs = stableSec * 1e3;
+                let lastMutationCount = -1;
+                let stableSince = Date.now();
+                while (Date.now() - startMs < timeoutMs) {
+                  await new Promise((r) => setTimeout(r, 500));
+                  const countStr = await this.browser.evaluate("window.__assrt_mutations");
+                  const count = parseInt(countStr, 10) || 0;
+                  if (count !== lastMutationCount) {
+                    lastMutationCount = count;
+                    stableSince = Date.now();
+                  } else if (Date.now() - stableSince >= stableMs) {
+                    break;
+                  }
+                }
+                await this.browser.evaluate(`
+                  if (window.__assrt_observer) { window.__assrt_observer.disconnect(); }
+                  delete window.__assrt_mutations;
+                  delete window.__assrt_observer;
+                `);
+                const elapsed = ((Date.now() - startMs) / 1e3).toFixed(1);
+                const stable = Date.now() - stableSince >= stableMs;
+                result = stable ? `Page stabilized after ${elapsed}s (${lastMutationCount} total mutations)` : `Timed out after ${timeoutSec}s (page still changing, ${lastMutationCount} mutations)`;
+                stepDescription = stable ? `Page stable after ${elapsed}s` : `Stability timeout after ${timeoutSec}s`;
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                result = `wait_for_stable failed: ${msg}`;
+                stepStatus = "failed";
+                stepDescription = "wait_for_stable failed";
+              }
+              stepAction = "wait";
+              break;
+            }
+            default:
+              result = `Unknown: ${toolCall.name}`;
+              stepDescription = `Unknown: ${toolCall.name}`;
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          let snapshotText = "";
+          try {
+            snapshotText = await this.browser.snapshot();
+          } catch {
+          }
+          result = `Error: ${msg}
+
+The action "${toolCall.name}" failed. Current page accessibility tree:
+${snapshotText.slice(0, 2e3)}
+
+Please call snapshot and try a different approach.`;
+          stepStatus = "failed";
+          stepDescription = `${toolCall.name} failed: ${msg.slice(0, 100)}`;
+        }
+        let screenshotData = null;
+        if (!["snapshot", "wait", "wait_for_stable", "assert", "complete_scenario", "create_temp_email", "wait_for_verification_code", "check_email_inbox", "screenshot", "evaluate", "http_request"].includes(toolCall.name)) {
+          try {
+            screenshotData = await this.browser.screenshot();
+            if (screenshotData) {
+              console.log(JSON.stringify({ event: "agent.screenshot.emit", size: screenshotData.length, ts: (/* @__PURE__ */ new Date()).toISOString() }));
+              this.emit("screenshot", { base64: screenshotData });
+            }
+          } catch {
+          }
+        }
+        steps.push({ id: stepCounter, action: stepAction, description: stepDescription, status: stepStatus, timestamp: Date.now() });
+        this.emit("step", { id: stepCounter, action: stepAction, description: stepDescription, status: stepStatus, timestamp: Date.now() });
+        if (this.provider === "gemini") {
+          toolResults.push({ functionResponse: { name: toolCall.name, response: { result } } });
+        } else {
+          const toolResultContent = [{ type: "text", text: result }];
+          if (screenshotData) {
+            toolResultContent.push({ type: "image", source: { type: "base64", media_type: "image/jpeg", data: screenshotData } });
+          }
+          toolResults.push({ type: "tool_result", tool_use_id: toolCall.id, content: toolResultContent });
+        }
+        this.browserBusy = false;
+      }
+      await this.flushDiscovery().catch(() => {
+      });
+      if (this.provider === "gemini") {
+        messages.push({ role: "function", parts: toolResults });
+        const latestScreenshot = await this.browser.screenshot();
+        const latestSnapshot = await this.browser.snapshot();
+        messages.push({ role: "user", parts: [
+          ...latestScreenshot ? [{ inlineData: { mimeType: "image/jpeg", data: latestScreenshot } }] : [],
+          { text: `Current page accessibility tree:
+${latestSnapshot.slice(0, 3e3)}
+
+Continue with the test scenario.` }
+        ] });
+      } else {
+        messages.push({ role: "user", content: toolResults });
+      }
+      if (messages.length > MAX_CONVERSATION_TURNS * 2 + 2) {
+        const initial = messages.slice(0, 1);
+        let cutIdx = messages.length - MAX_CONVERSATION_TURNS * 2;
+        if (cutIdx < 1) cutIdx = 1;
+        while (cutIdx < messages.length - 2) {
+          const msg = messages[cutIdx];
+          const role = msg.role;
+          if (role === "assistant" || role === "model") break;
+          cutIdx++;
+        }
+        const recent = messages.slice(cutIdx);
+        messages.length = 0;
+        messages.push(...initial, ...recent);
+      }
+    }
+    if (!completed) scenarioSummary = `Reached max steps (${MAX_STEPS_PER_SCENARIO})`;
+    return { name: scenarioName, passed: scenarioPassed, steps, assertions, summary: scenarioSummary, duration: Date.now() - startTime };
+  }
+};
+
+// src/core/telemetry.ts
+import { createHash } from "crypto";
+import { hostname, platform, arch, userInfo } from "os";
+import { readFileSync as readSync, writeFileSync as writeSync } from "fs";
+import { join as joinPath } from "path";
+import { tmpdir as getTmpdir } from "os";
+var POSTHOG_KEY = "phc_mS27BrT7FC5m3BiVjDj9T4iOpVY9Oh1PB3g3bHsEiQv";
+var POSTHOG_HOST = "https://us.i.posthog.com";
+function isEnabled() {
+  if (process.env.DO_NOT_TRACK === "1") return false;
+  if (process.env.ASSRT_TELEMETRY === "0") return false;
+  return true;
+}
+function getMachineId() {
+  const raw = `${hostname()}:${userInfo().username}:assrt`;
+  return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "unknown";
+  }
+}
+var posthogClient = null;
+async function getClient() {
+  if (posthogClient) return posthogClient;
+  try {
+    const { PostHog } = await import("posthog-node");
+    posthogClient = new PostHog(POSTHOG_KEY, {
+      host: POSTHOG_HOST,
+      flushAt: 1,
+      flushInterval: 0,
+      // Custom fetch that silently swallows TLS/network errors.
+      // Returns a fake 200 so PostHog SDK doesn't log errors to stderr.
+      fetch: async (url, options) => {
+        try {
+          return await globalThis.fetch(url, options);
+        } catch {
+          return new Response("{}", { status: 200, headers: { "content-type": "application/json" } });
+        }
+      }
+    });
+    posthogClient.on("error", () => {
+    });
+    return posthogClient;
+  } catch {
+    return null;
+  }
+}
+var DEDUP_FILE = joinPath(getTmpdir(), "assrt-telemetry-dedup.json");
+function shouldSend(event) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const machineId = getMachineId();
+  const key = `${machineId}:${event}`;
+  try {
+    const data = JSON.parse(readSync(DEDUP_FILE, "utf-8"));
+    if (data[key] === today) return false;
+    data[key] = today;
+    writeSync(DEDUP_FILE, JSON.stringify(data));
+    return true;
+  } catch {
+    try {
+      writeSync(DEDUP_FILE, JSON.stringify({ [key]: today }));
+    } catch {
+    }
+    return true;
+  }
+}
+async function trackEvent(event, props = {}, options) {
+  if (!isEnabled()) return;
+  if (options?.dedupeDaily && !shouldSend(event)) return;
+  try {
+    const client = await getClient();
+    if (!client) return;
+    const { url, ...rest } = props;
+    client.capture({
+      distinctId: getMachineId(),
+      event,
+      properties: {
+        ...rest,
+        domain: url ? getDomain(url) : void 0,
+        version: "0.3.1",
+        os: platform(),
+        arch: arch(),
+        node_version: process.version
+      }
+    });
+  } catch {
+  }
+}
+async function shutdownTelemetry() {
+  if (posthogClient) {
+    try {
+      await posthogClient.shutdown();
+    } catch {
+    }
+  }
+}
+
+export {
+  getCredential,
+  createTestVm,
+  destroyTestVm,
+  isFreestyleConfigured,
+  McpBrowserManager,
+  TestAgent,
+  trackEvent,
+  shutdownTelemetry
+};